2328 lines
58 KiB
C++
2328 lines
58 KiB
C++
/*++
|
||
|
||
Copyright (c) 1992 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
groupman.cxx
|
||
|
||
Abstract:
|
||
|
||
Contains code for the Group List Database manager. This includes
|
||
all the linked list routines. This file contains the following
|
||
functions:
|
||
ScGetOrderGroupList
|
||
ScGetStandaloneGroupList
|
||
ScGetUnresolvedDependList
|
||
ScGetNamedGroupRecord
|
||
|
||
ScCreateOrderGroupEntry
|
||
ScAllocateGroupEntry
|
||
ScCreateGroupMembership
|
||
ScDeleteGroupMembership
|
||
ScCreateRegistryGroupPointer
|
||
ScDeleteRegistryGroupPointer
|
||
ScCreateStandaloneGroup
|
||
ScDeleteStandaloneGroup
|
||
|
||
ScGenerateDependencies
|
||
ScSetDependencyPointers
|
||
ScResolveDependencyToService
|
||
ScCreateDependencies
|
||
ScCreateUnresolvedDepend
|
||
ScDeleteUnresolvedDepend
|
||
ScCreateDependRecord
|
||
ScDeleteStartDependencies
|
||
ScDeleteStopDependencies
|
||
ScSetServiceDependList
|
||
ScGetUniqueTag
|
||
ScCompareVector
|
||
|
||
ScGetDependencySize
|
||
ScGetDependencyString
|
||
|
||
ScDumpGroups
|
||
ScDumpServiceDependencies
|
||
|
||
Author:
|
||
|
||
Dan Lafferty (danl) 04-Feb-1992
|
||
|
||
Environment:
|
||
|
||
User Mode -Win32
|
||
|
||
Revision History:
|
||
|
||
22-Oct-1993 danl
|
||
Created by splitting these functions out of dataman.c because it was
|
||
getting too large.
|
||
|
||
--*/
|
||
|
||
//
|
||
// INCLUDES
|
||
//
|
||
|
||
#include "precomp.hxx"
|
||
#include <stdlib.h> // wide character c runtimes.
|
||
#include <tstr.h> // Unicode string macros
|
||
#include <ntrpcp.h> // MIDL_user_allocate
|
||
#include <control.h> // SendControl
|
||
#include "scconfig.h" // ScGenerateServiceDB,ScInitSecurityProcess
|
||
#include "scsec.h" // ScCreateScServiceObject
|
||
#include "account.h" // ScRemoveAccount
|
||
#include <sclib.h> // ScImagePathsMatch().
|
||
#include "bootcfg.h" // ScDeleteRegTree().
|
||
#include <strarray.h> // ScWStrArraySize
|
||
|
||
//
|
||
// Defines
|
||
//
|
||
|
||
// Names of specially treated groups
|
||
#define SC_GROUPNAME_TDI L"TDI"
|
||
#define SC_GROUPNAME_PNP_TDI L"PNP_TDI"
|
||
|
||
// A value that will not match any real pointer to a load order group
|
||
#define SC_INVALID_GROUP ((LPLOAD_ORDER_GROUP)(DWORD_PTR) 0xFFFFFFFF)
|
||
|
||
|
||
//
|
||
// External Globals
|
||
//
|
||
|
||
//
|
||
// TDI GROUP SPECIAL: The groups named TDI and PNP_TDI are treated
|
||
// specially during dependency handling. This is done by remembering a
|
||
// pointer to each of those groups, if it occurs in the group order list,
|
||
// and checking against the remembered pointers during dependency
|
||
// handling.
|
||
//
|
||
|
||
LPLOAD_ORDER_GROUP ScGlobalTDIGroup = SC_INVALID_GROUP;
|
||
LPLOAD_ORDER_GROUP ScGlobalPNP_TDIGroup = SC_INVALID_GROUP;
|
||
|
||
//
|
||
// Static Globals
|
||
//
|
||
|
||
//
|
||
// These are the linked list heads for each of the databases
|
||
// that are maintained.
|
||
//
|
||
|
||
LOAD_ORDER_GROUP OrderGroupList; // empty header for doubly linked
|
||
LOAD_ORDER_GROUP StandaloneGroupList; // empty header for doubly linked
|
||
|
||
UNRESOLVED_DEPEND UnresolvedDependList; // empty header for doubly linked
|
||
|
||
//
|
||
// Local Function Prototypes
|
||
//
|
||
|
||
DWORD
|
||
ScAllocateOrderGroupEntry(
|
||
OUT LPLOAD_ORDER_GROUP *NewGroup,
|
||
IN LPWSTR GroupName
|
||
);
|
||
|
||
DWORD
|
||
ScCreateStandaloneGroup(
|
||
IN LPWSTR GroupName,
|
||
OUT LPLOAD_ORDER_GROUP *GroupPointer
|
||
);
|
||
|
||
VOID
|
||
ScDeleteStandaloneGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
);
|
||
|
||
VOID
|
||
ScRememberSpecialGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
);
|
||
|
||
VOID
|
||
ScForgetSpecialGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
);
|
||
|
||
DWORD
|
||
ScCreateUnresolvedDepend(
|
||
IN LPWSTR Name,
|
||
OUT LPUNRESOLVED_DEPEND *Unresolved
|
||
);
|
||
|
||
VOID
|
||
ScDeleteUnresolvedDepend(
|
||
IN OUT LPUNRESOLVED_DEPEND *Unresolved
|
||
);
|
||
|
||
DWORD
|
||
ScSetServiceDependList(
|
||
LPDEPEND_RECORD Start,
|
||
LPSERVICE_RECORD ServiceRecord,
|
||
PVOID DependOnRecord,
|
||
DEPEND_TYPE DependOnType
|
||
);
|
||
|
||
VOID
|
||
ScCompareVector(
|
||
IN LPDWORD TagArray,
|
||
IN DWORD TagArrayLength,
|
||
IN OUT LPDWORD ReturnTagPtr
|
||
);
|
||
|
||
|
||
|
||
//****************************************************************************/
|
||
// Miscellaneous Short Functions
|
||
//****************************************************************************/
|
||
LPLOAD_ORDER_GROUP
|
||
ScGetOrderGroupList(
|
||
VOID
|
||
)
|
||
{
|
||
SC_ASSERT(ScGroupListLock.Have());
|
||
return OrderGroupList.Next;
|
||
}
|
||
|
||
LPLOAD_ORDER_GROUP
|
||
ScGetStandaloneGroupList(
|
||
VOID
|
||
)
|
||
{
|
||
SC_ASSERT(ScGroupListLock.Have());
|
||
return StandaloneGroupList.Next;
|
||
}
|
||
|
||
LPUNRESOLVED_DEPEND
|
||
ScGetUnresolvedDependList(
|
||
VOID
|
||
)
|
||
{
|
||
SC_ASSERT(ScGroupListLock.Have());
|
||
return UnresolvedDependList.Next;
|
||
}
|
||
|
||
VOID
|
||
ScInitGroupDatabase(VOID)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
--*/
|
||
{
|
||
OrderGroupList.Next = NULL;
|
||
OrderGroupList.Prev = NULL;
|
||
|
||
StandaloneGroupList.Next = NULL;
|
||
StandaloneGroupList.Prev = NULL;
|
||
|
||
UnresolvedDependList.Next = NULL;
|
||
UnresolvedDependList.Prev = NULL;
|
||
|
||
}
|
||
|
||
VOID
|
||
ScEndGroupDatabase(VOID)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
--*/
|
||
{
|
||
LPLOAD_ORDER_GROUP Group;
|
||
LPLOAD_ORDER_GROUP Grp;
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
Group = OrderGroupList.Next;
|
||
|
||
while (Group != NULL) {
|
||
|
||
Grp = Group;
|
||
Group = Group->Next;
|
||
|
||
REMOVE_FROM_LIST(Grp);
|
||
LocalFree(Grp);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateOrderGroupEntry(
|
||
IN LPWSTR GroupName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function adds a group entry into the end of the load order group
|
||
list.
|
||
|
||
Arguments:
|
||
|
||
GroupName - Supplies the name of the load group.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - The call to allocate memory for a new
|
||
group entry failed.
|
||
|
||
Note:
|
||
|
||
The GroupListLock must be held exclusively prior to calling this function.
|
||
|
||
--*/
|
||
{
|
||
DWORD status;
|
||
LPLOAD_ORDER_GROUP NewGroup;
|
||
LPLOAD_ORDER_GROUP GroupListPointer;
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
if ((status = ScAllocateOrderGroupEntry(
|
||
&NewGroup,
|
||
GroupName
|
||
)) != NO_ERROR) {
|
||
return status;
|
||
}
|
||
|
||
GroupListPointer = &OrderGroupList;
|
||
|
||
//
|
||
// Add the group entry to the group list at the end.
|
||
//
|
||
ADD_TO_LIST(GroupListPointer, NewGroup);
|
||
|
||
SC_LOG(CONFIG, "ScCreateOrderGroupEntry: Added %ws to GroupList\n", GroupName);
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScAllocateOrderGroupEntry(
|
||
OUT LPLOAD_ORDER_GROUP *NewGroup,
|
||
IN LPWSTR GroupName
|
||
)
|
||
{
|
||
|
||
//
|
||
// Allocate memory for the new group.
|
||
//
|
||
*NewGroup = (LPLOAD_ORDER_GROUP)LocalAlloc(
|
||
LMEM_ZEROINIT,
|
||
WCSSIZE(GroupName) + sizeof(LOAD_ORDER_GROUP)
|
||
);
|
||
|
||
if (*NewGroup == NULL) {
|
||
SC_LOG(ERROR,"ScAllocateOrderGroupEntry: LocalAlloc failure %ld\n",
|
||
GetLastError());
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
//
|
||
// Save away the GroupName
|
||
//
|
||
(*NewGroup)->GroupName = (LPWSTR) ((LPBYTE) (*NewGroup) + sizeof(LOAD_ORDER_GROUP));
|
||
wcscpy((*NewGroup)->GroupName, GroupName);
|
||
|
||
ScRememberSpecialGroup(*NewGroup);
|
||
|
||
//
|
||
// Set the RefCount field to 0xffffffff so that we can differentiate an
|
||
// order group from a standalone group. This field actually indicates
|
||
// the number of members in a group and dependency references to it if
|
||
// the group is standalone so that we can delete the standalone group
|
||
// when it goes to 0.
|
||
//
|
||
(*NewGroup)->RefCount = MAXULONG;
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateGroupMembership(
|
||
OUT PSERVICE_RECORD ServiceRecord,
|
||
IN LPWSTR Group OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function assigns the load order group membership information
|
||
of the service to its specified service record. If the service
|
||
belongs to a group in OrderGroupList, a pointer to the group in the load
|
||
order group list is saved. If the service belongs to a group which
|
||
is not in the load order group list, the name of the group is saved
|
||
in the service record in case the group gets added to the load order
|
||
group list later. If Group is not specified, no group membership
|
||
information is saved.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Receives the group membership information in this service
|
||
record.
|
||
|
||
Group - Supplies the string which contains the name of the group. This
|
||
is the raw string read from the registry which may contain blank,
|
||
tab or newline characters which we should ignore.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - The call to allocate memory for a group name
|
||
failed.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the database lock is already held. It is
|
||
called by ScAddConfigInfoServiceRecord.
|
||
|
||
It also assumes that the caller has exclusive access to the group
|
||
list lock.
|
||
|
||
--*/
|
||
{
|
||
DWORD status;
|
||
LPWSTR GroupPtr = Group;
|
||
LPWSTR GroupName;
|
||
PLOAD_ORDER_GROUP GroupEntry = ScGetOrderGroupList();
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
//
|
||
// Extract the group name from the string read in from the registry.
|
||
//
|
||
if ((! ARGUMENT_PRESENT(GroupPtr)) || (! ScGetToken(&GroupPtr, &GroupName))) {
|
||
ServiceRecord->MemberOfGroup = (PLOAD_ORDER_GROUP) NULL;
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// Search for matching group name in load order list
|
||
//
|
||
while (GroupEntry != NULL) {
|
||
if (_wcsicmp(GroupEntry->GroupName, GroupName) == 0) {
|
||
ServiceRecord->MemberOfGroup = GroupEntry;
|
||
return NO_ERROR;
|
||
}
|
||
GroupEntry = GroupEntry->Next;
|
||
}
|
||
|
||
//
|
||
// Group name not NULL, and not found in load order group list.
|
||
// Group is a standalone group.
|
||
//
|
||
status = ScCreateStandaloneGroup(
|
||
GroupName,
|
||
&(ServiceRecord->MemberOfGroup)
|
||
);
|
||
|
||
if (status != NO_ERROR) {
|
||
return status;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteGroupMembership(
|
||
IN OUT PSERVICE_RECORD ServiceRecord
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function deletes any memory allocated for group membership
|
||
association.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Supplies the group membership information in this
|
||
service record.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the database lock is already held. It is
|
||
called by ScAddConfigInfoServiceRecord and ScDecrementUseCountAndDelete.
|
||
|
||
It also assumes that the group list lock is held exclusively.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
if (ServiceRecord->MemberOfGroup != NULL &&
|
||
ServiceRecord->MemberOfGroup->RefCount != MAXULONG) {
|
||
ScDeleteStandaloneGroup(ServiceRecord->MemberOfGroup);
|
||
}
|
||
|
||
ServiceRecord->MemberOfGroup = NULL;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateRegistryGroupPointer(
|
||
OUT PSERVICE_RECORD ServiceRecord,
|
||
IN LPWSTR Group OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function assigns the load order group RegistryGroup
|
||
information in the service record to match the load order group
|
||
stored in the registry, which is not the same as MemberOfGroup
|
||
information if the load order group of the service is changed
|
||
while the service is running. However, we need to know what the
|
||
resultant load order group of the service is when it stops so
|
||
that when we can guarantee uniqueness of a tag based on all
|
||
members the group.
|
||
|
||
This function does exactly the same thing as the
|
||
ScCreateGroupMembership function but alters the RegistryGroup
|
||
pointer instead of the MemberOfGroup pointer in the service
|
||
record.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Receives the group membership information in this service
|
||
record.
|
||
|
||
Group - Supplies the string which contains the name of the group. This
|
||
is the raw string read from the registry which may contain blank,
|
||
tab or newline characters which we should ignore.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - The call to allocate memory for a group name
|
||
failed.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the database lock is already held. It is
|
||
called by ScAddConfigInfoServiceRecord.
|
||
|
||
It also assumes that the caller has exclusive access to the group
|
||
list lock.
|
||
|
||
--*/
|
||
{
|
||
DWORD status;
|
||
LPWSTR GroupPtr = Group;
|
||
LPWSTR GroupName;
|
||
PLOAD_ORDER_GROUP GroupEntry = ScGetOrderGroupList();
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
|
||
//
|
||
// Extract the group name from the string read in from the registry.
|
||
//
|
||
if ((! ARGUMENT_PRESENT(GroupPtr)) || (! ScGetToken(&GroupPtr, &GroupName))) {
|
||
ServiceRecord->RegistryGroup = (PLOAD_ORDER_GROUP) NULL;
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// Search for matching group name in load order list
|
||
//
|
||
while (GroupEntry != NULL) {
|
||
if (_wcsicmp(GroupEntry->GroupName, GroupName) == 0) {
|
||
ServiceRecord->RegistryGroup = GroupEntry;
|
||
return NO_ERROR;
|
||
}
|
||
GroupEntry = GroupEntry->Next;
|
||
}
|
||
|
||
//
|
||
// Group name not NULL, and not found in load order group list.
|
||
// Group is a standalone group.
|
||
//
|
||
status = ScCreateStandaloneGroup(
|
||
GroupName,
|
||
&(ServiceRecord->RegistryGroup)
|
||
);
|
||
|
||
if (status != NO_ERROR) {
|
||
return status;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteRegistryGroupPointer(
|
||
IN OUT PSERVICE_RECORD ServiceRecord
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function deletes any memory allocated for registry group
|
||
association.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Supplies the registry group information in this
|
||
service record.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the database lock is already held. It is
|
||
called by ScAddConfigInfoServiceRecord and ScDecrementUseCountAndDelete.
|
||
|
||
It also assumes that the group list lock is held exclusively.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
if (ServiceRecord->RegistryGroup != NULL &&
|
||
ServiceRecord->RegistryGroup->RefCount != MAXULONG) {
|
||
ScDeleteStandaloneGroup(ServiceRecord->RegistryGroup);
|
||
}
|
||
|
||
ServiceRecord->RegistryGroup = NULL;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateStandaloneGroup(
|
||
IN LPWSTR GroupName,
|
||
OUT LPLOAD_ORDER_GROUP *GroupPointer
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function looks for a matching standalone group entry in the
|
||
standalone group list. If a match is found, the reference count is
|
||
incremented and the pointer to the matching entry is returned.
|
||
|
||
If no matching entry is found, this function creates a new standalone
|
||
group entry, insert it into the end of the standalone group list, and
|
||
return a pointer to the new entry.
|
||
|
||
|
||
Arguments:
|
||
|
||
Name - Supplies the name of the group which is not in the
|
||
ServiceOrderList.
|
||
|
||
GroupPointer - Receives a pointer to the unresolved entry.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - Allocation of memory failed.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
group list lock. It is called by ScCreateGroupMembership.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
LPLOAD_ORDER_GROUP Group = ScGetStandaloneGroupList();
|
||
|
||
BOOL Found = FALSE;
|
||
|
||
|
||
//
|
||
// Search the existing standalone group list for the matching
|
||
// standalone group entry.
|
||
//
|
||
while (Group != NULL) {
|
||
|
||
if (_wcsicmp(Group->GroupName, GroupName) == 0) {
|
||
Found = TRUE;
|
||
break;
|
||
}
|
||
|
||
Group = Group->Next;
|
||
}
|
||
|
||
if (Found) {
|
||
|
||
Group->RefCount++;
|
||
|
||
SC_LOG2(DEPEND_DUMP,
|
||
"Found existing group entry for " FORMAT_LPWSTR
|
||
", just increment refcount to %lu\n", Group->GroupName,
|
||
Group->RefCount);
|
||
|
||
*GroupPointer = Group;
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// Not found. Allocate a new group entry.
|
||
//
|
||
if ((*GroupPointer = (LPLOAD_ORDER_GROUP)LocalAlloc(
|
||
LMEM_ZEROINIT,
|
||
sizeof(LOAD_ORDER_GROUP) + WCSSIZE(GroupName)
|
||
)) == NULL) {
|
||
SC_LOG(ERROR,"ScCreateStandaloneGroup: LocalAlloc failure %lu\n",
|
||
GetLastError());
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
(*GroupPointer)->GroupName = (LPWSTR) ((DWORD_PTR) *GroupPointer +
|
||
sizeof(LOAD_ORDER_GROUP));
|
||
wcscpy((*GroupPointer)->GroupName, GroupName);
|
||
|
||
(*GroupPointer)->RefCount = 1;
|
||
|
||
SC_LOG1(DEPEND_DUMP, "Created new standalone group entry "
|
||
FORMAT_LPWSTR "\n", (*GroupPointer)->GroupName);
|
||
|
||
ScRememberSpecialGroup(*GroupPointer);
|
||
|
||
Group = &StandaloneGroupList;
|
||
|
||
//
|
||
// Add the new group entry to the standalone group list at the end.
|
||
//
|
||
ADD_TO_LIST(Group, *GroupPointer);
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteStandaloneGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
)
|
||
{
|
||
if (Group->RefCount) {
|
||
Group->RefCount--;
|
||
|
||
SC_LOG1(DEPEND, "DeleteStandaloneGroup: Subtracted RefCount is "
|
||
FORMAT_DWORD "\n", Group->RefCount);
|
||
}
|
||
else {
|
||
SC_LOG0(ERROR, "ScDeleteStandaloneGroup: Before delete, refcount is 0!\n");
|
||
SC_ASSERT(FALSE);
|
||
}
|
||
|
||
if (Group->RefCount == 0) {
|
||
|
||
SC_LOG1(DEPEND, "Deleting standalone group " FORMAT_LPWSTR "\n",
|
||
Group->GroupName);
|
||
|
||
REMOVE_FROM_LIST(Group);
|
||
|
||
ScForgetSpecialGroup(Group);
|
||
|
||
LocalFree(Group);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
ScRememberSpecialGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Compares the group name against a set of known group names to see if it
|
||
is a group that requires special handling, and if so, saves the pointer
|
||
to the group in a global variable.
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
// CODEWORK: If the number of special groups keeps growing, do this
|
||
// in a table-driven way!
|
||
|
||
if (_wcsicmp(Group->GroupName, SC_GROUPNAME_TDI) == 0)
|
||
{
|
||
if (ScGlobalTDIGroup != SC_INVALID_GROUP)
|
||
{
|
||
SC_LOG0(ERROR, "Warning: TDI group occurs more than once in load order group list\n");
|
||
}
|
||
ScGlobalTDIGroup = Group;
|
||
}
|
||
else if (_wcsicmp(Group->GroupName, SC_GROUPNAME_PNP_TDI) == 0)
|
||
{
|
||
if (ScGlobalPNP_TDIGroup != SC_INVALID_GROUP)
|
||
{
|
||
SC_LOG0(ERROR, "Warning: PNP_TDI group occurs more than once in load order group list\n");
|
||
}
|
||
ScGlobalPNP_TDIGroup = Group;
|
||
}
|
||
}
|
||
|
||
|
||
VOID
|
||
ScForgetSpecialGroup(
|
||
IN LPLOAD_ORDER_GROUP Group
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
if (Group == ScGlobalTDIGroup)
|
||
{
|
||
ScGlobalTDIGroup = SC_INVALID_GROUP;
|
||
}
|
||
else if (Group == ScGlobalPNP_TDIGroup)
|
||
{
|
||
ScGlobalPNP_TDIGroup = SC_INVALID_GROUP;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
ScGenerateDependencies(
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
Note:
|
||
|
||
The GroupListLock must be held exclusively prior to calling this routine.
|
||
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
FOR_ALL_SERVICES(Service)
|
||
{
|
||
(void) ScSetDependencyPointers(Service);
|
||
}
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScSetDependencyPointers(
|
||
IN LPSERVICE_RECORD Service
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
|
||
Note:
|
||
|
||
The GroupListLock must be held exclusively prior to calling this routine.
|
||
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
|
||
DWORD status;
|
||
|
||
if (Service->Dependencies != NULL) {
|
||
|
||
status = ScCreateDependencies(
|
||
Service,
|
||
Service->Dependencies
|
||
);
|
||
|
||
if (status == NO_ERROR) {
|
||
LocalFree(Service->Dependencies);
|
||
Service->Dependencies = NULL;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScResolveDependencyToService(
|
||
LPSERVICE_RECORD DependOnService
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function resolves all dependencies to the service we are
|
||
currently installing via CreateService. The start depend entry
|
||
of these services will point to the service record of the service
|
||
we are installing instead of the unresolved depend record. A
|
||
stop depend entry is created for the service we are installing to
|
||
point back to every service that depends on it.
|
||
|
||
Arguments:
|
||
|
||
DependOnService - Supplies a pointer to the service we are installing
|
||
via CreateService which other services may depend on.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - Fail to allocate memory for required data
|
||
structures.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by RCreateServiceW.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.Have());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
DWORD status;
|
||
LPUNRESOLVED_DEPEND UnresolvedEntry = ScGetUnresolvedDependList();
|
||
|
||
|
||
//
|
||
// Search the unresolved depend list for a matching entry
|
||
//
|
||
while (UnresolvedEntry != NULL) {
|
||
|
||
if (_wcsicmp(UnresolvedEntry->Name, DependOnService->ServiceName) == 0) {
|
||
SC_LOG1(DEPEND, "Found unresolved entry for " FORMAT_LPWSTR "\n",
|
||
DependOnService->ServiceName);
|
||
break;
|
||
}
|
||
|
||
UnresolvedEntry = UnresolvedEntry->Next;
|
||
}
|
||
|
||
if (UnresolvedEntry == NULL) {
|
||
//
|
||
// There are no service which depends on the service we are
|
||
// installing; hence, no unresolved dependency to resolve.
|
||
//
|
||
SC_LOG1(DEPEND, "No service depends on " FORMAT_LPWSTR "\n",
|
||
DependOnService->ServiceName);
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
//
|
||
// Loop through all services to see if any of them has a start depend
|
||
// entry that points to UnresolvedEntry.
|
||
//
|
||
FOR_ALL_SERVICES(Service)
|
||
{
|
||
if (UnresolvedEntry == NULL)
|
||
{
|
||
break;
|
||
}
|
||
|
||
for (LPDEPEND_RECORD Start = Service->StartDepend;
|
||
Start != NULL;
|
||
Start = Start->Next)
|
||
{
|
||
if (Start->DependUnresolved == UnresolvedEntry)
|
||
{
|
||
status = ScSetServiceDependList(
|
||
Start,
|
||
Service,
|
||
(PVOID)DependOnService,
|
||
TypeDependOnService
|
||
);
|
||
|
||
if (status != NO_ERROR)
|
||
{
|
||
//
|
||
// Error with creating the stop depend entry for
|
||
// DependOnService. Back out changes set for the
|
||
// current start depend entry.
|
||
//
|
||
Start->DependType = TypeDependOnUnresolved;
|
||
Start->DependUnresolved = UnresolvedEntry;
|
||
|
||
//
|
||
// Back out of all other resolved dependencies to
|
||
// DependOnService will be done in ScDecrementUseCountAndDelete.
|
||
//
|
||
SC_LOG2(ERROR, "ScResolvedDependencyToService " FORMAT_LPWSTR
|
||
" failed " FORMAT_DWORD "\n",
|
||
DependOnService->ServiceName, status);
|
||
return status;
|
||
}
|
||
|
||
SC_LOG2(DEPEND, FORMAT_LPWSTR " depends on " FORMAT_LPWSTR
|
||
". Dependency resolved!\n", Service->ServiceName,
|
||
UnresolvedEntry->Name);
|
||
|
||
ScDeleteUnresolvedDepend(&UnresolvedEntry);
|
||
}
|
||
}
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateDependencies(
|
||
OUT PSERVICE_RECORD ServiceRecord,
|
||
IN LPWSTR Dependencies OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function creates the start dependencies list of a service.
|
||
If the service specified by ServiceRecord depends on a service that
|
||
has not been inserted into the service list yet, that service entry
|
||
will be created and inserted into the service list so that the depend
|
||
record can point to it. The service this one points to in its start
|
||
dependency list will get a new entry in its stop dependency list because
|
||
this one must be stopped before it can stop.
|
||
|
||
The dependencies list is not ordered.
|
||
|
||
NOTE: This function is for call from RChangeServiceConfig.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Receives the start dependencies information in this
|
||
service record.
|
||
|
||
Dependencies - Supplies the string which contains the names this service
|
||
depend on to be started first. This is a multi-sz string of
|
||
service or group names.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - Fail to allocate memory for required data
|
||
structures.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScSetDependencyPointers.
|
||
|
||
It also assumes that the caller has exclusively acquired the group
|
||
list lock.
|
||
|
||
--*/
|
||
{
|
||
DWORD status;
|
||
|
||
LPWSTR DependPtr = Dependencies;
|
||
LPWSTR DependOnName;
|
||
PVOID DependOnRecord = NULL;
|
||
DEPEND_TYPE Type;
|
||
|
||
PDEPEND_RECORD Start;
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
if (! ARGUMENT_PRESENT(DependPtr)) {
|
||
return NO_ERROR;
|
||
}
|
||
|
||
while (*DependPtr != 0) {
|
||
|
||
if (ScGetToken(&DependPtr, &DependOnName)) {
|
||
|
||
//
|
||
// Initialize flag for noting that a new service record is
|
||
// created for resolving the dependency chain.
|
||
//
|
||
Type = TypeNone;
|
||
|
||
if (*DependOnName != SC_GROUP_IDENTIFIERW) {
|
||
|
||
//
|
||
// Depend on a service
|
||
//
|
||
|
||
//
|
||
// Look for the service we depend on in the service record list
|
||
//
|
||
status = ScGetNamedServiceRecord(
|
||
DependOnName,
|
||
(LPSERVICE_RECORD *) &DependOnRecord
|
||
);
|
||
|
||
if (status == ERROR_SERVICE_DOES_NOT_EXIST) {
|
||
|
||
//
|
||
// Could not find the service we depend on. Create an
|
||
// unresolved dependency entry.
|
||
//
|
||
status = ScCreateUnresolvedDepend(
|
||
DependOnName,
|
||
(PUNRESOLVED_DEPEND *) &DependOnRecord
|
||
);
|
||
|
||
if (status != NO_ERROR) {
|
||
goto ErrorExit;
|
||
}
|
||
|
||
//
|
||
// New unresolved depend entry created. We have to remove
|
||
// it if any error occurs later.
|
||
//
|
||
Type = TypeDependOnUnresolved;
|
||
|
||
}
|
||
else {
|
||
|
||
Type = TypeDependOnService;
|
||
}
|
||
|
||
if (status != NO_ERROR) {
|
||
goto ErrorExit;
|
||
}
|
||
}
|
||
else {
|
||
|
||
//
|
||
// Depend on a group
|
||
//
|
||
|
||
PLOAD_ORDER_GROUP GroupEntry = ScGetOrderGroupList();
|
||
|
||
DependOnName++;
|
||
|
||
//
|
||
// Search for matching group name in load order list
|
||
//
|
||
while (GroupEntry != NULL) {
|
||
if (_wcsicmp(GroupEntry->GroupName, DependOnName) == 0) {
|
||
DependOnRecord = (PVOID) GroupEntry;
|
||
Type = TypeDependOnGroup;
|
||
break;
|
||
}
|
||
GroupEntry = GroupEntry->Next;
|
||
}
|
||
|
||
if (GroupEntry == NULL) {
|
||
//
|
||
// Could not find group in the OrderGroup list. Must
|
||
// depend on a standalone group.
|
||
//
|
||
status = ScCreateStandaloneGroup(
|
||
DependOnName,
|
||
(LPLOAD_ORDER_GROUP *) &DependOnRecord
|
||
);
|
||
|
||
if (status != NO_ERROR) {
|
||
goto ErrorExit;
|
||
}
|
||
|
||
Type = TypeDependOnGroup;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Allocate memory for start depend record and insert it in the
|
||
// front of the start depend list of the service we are processing.
|
||
//
|
||
if ((status = ScCreateDependRecord(
|
||
TRUE, // For start list
|
||
ServiceRecord,
|
||
&Start
|
||
)) != NO_ERROR) {
|
||
|
||
goto ErrorExit;
|
||
}
|
||
|
||
//
|
||
// Start depend record created OK, set fields. Set stop
|
||
// depend if appropriate (Type == TypeDependOnService).
|
||
//
|
||
status = ScSetServiceDependList(
|
||
Start,
|
||
ServiceRecord,
|
||
DependOnRecord,
|
||
Type
|
||
);
|
||
|
||
if (status != NO_ERROR) {
|
||
|
||
//
|
||
// Remove the start depend record just created in the front of
|
||
// the start depend list and delete it.
|
||
//
|
||
ServiceRecord->StartDepend = Start->Next;
|
||
LocalFree(Start);
|
||
|
||
goto ErrorExit;
|
||
}
|
||
|
||
} // if got token
|
||
|
||
} // while there is a dependency
|
||
|
||
return NO_ERROR;
|
||
|
||
ErrorExit:
|
||
|
||
//
|
||
// Remove newly created service record because of errors and we cannot
|
||
// proceed.
|
||
//
|
||
if (Type == TypeDependOnUnresolved) {
|
||
|
||
ScDeleteUnresolvedDepend((PUNRESOLVED_DEPEND *) &DependOnRecord);
|
||
}
|
||
|
||
//
|
||
// Clean up dependencies created up to the point of failure
|
||
//
|
||
ScDeleteStartDependencies(ServiceRecord);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateUnresolvedDepend(
|
||
IN LPWSTR Name,
|
||
OUT LPUNRESOLVED_DEPEND *Unresolved
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function looks for a matching unresolved entry in the unresolved
|
||
depend list. If a match is found, the reference count is incremented
|
||
and the pointer to the matching entry is returned.
|
||
|
||
If no matching entry is found, this function creates a new unresolved
|
||
entry, insert it into the end of the unresolved depend list, and
|
||
return a pointer to the new entry.
|
||
|
||
|
||
Arguments:
|
||
|
||
Name - Supplies the name of the service or group which has not been
|
||
installed yet, and thus needing this unresolved depend entry.
|
||
|
||
Unresolved - Receives a pointer to the unresolved entry.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - Allocation of memory failed.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScCreateDependencies.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
LPUNRESOLVED_DEPEND UnresolvedList = ScGetUnresolvedDependList();
|
||
|
||
BOOL Found = FALSE;
|
||
|
||
|
||
//
|
||
// Search the existing unresolved depend list for the matching
|
||
// unresolved depend entry.
|
||
//
|
||
while (UnresolvedList != NULL) {
|
||
|
||
if (_wcsicmp(UnresolvedList->Name, Name) == 0) {
|
||
Found = TRUE;
|
||
break;
|
||
}
|
||
|
||
UnresolvedList = UnresolvedList->Next;
|
||
}
|
||
|
||
if (Found) {
|
||
|
||
UnresolvedList->RefCount++;
|
||
|
||
SC_LOG2(DEPEND,
|
||
"Found existing unresolved entry for " FORMAT_LPWSTR
|
||
", just increment refcount to %lu\n", UnresolvedList->Name,
|
||
UnresolvedList->RefCount);
|
||
|
||
*Unresolved = UnresolvedList;
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// Not found. Allocate a new unresolved entry.
|
||
//
|
||
if ((*Unresolved = (LPUNRESOLVED_DEPEND)LocalAlloc(
|
||
LMEM_ZEROINIT,
|
||
sizeof(UNRESOLVED_DEPEND) + WCSSIZE(Name)
|
||
)) == NULL) {
|
||
SC_LOG1(ERROR,"ScCreateUnresolvedDepend: LocalAlloc failure %lu\n",
|
||
GetLastError());
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
(*Unresolved)->Name = (LPWSTR) ((DWORD_PTR) *Unresolved +
|
||
sizeof(UNRESOLVED_DEPEND));
|
||
wcscpy((*Unresolved)->Name, Name);
|
||
|
||
(*Unresolved)->RefCount = 1;
|
||
|
||
SC_LOG1(DEPEND, "Created new unresolved depend entry "
|
||
FORMAT_LPWSTR "\n", (*Unresolved)->Name);
|
||
|
||
UnresolvedList = &UnresolvedDependList;
|
||
|
||
//
|
||
// Add the new unresolved entry to the unresolved list at the end.
|
||
//
|
||
ADD_TO_LIST(UnresolvedList, *Unresolved);
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteUnresolvedDepend(
|
||
IN OUT LPUNRESOLVED_DEPEND *Unresolved
|
||
)
|
||
{
|
||
|
||
if ((*Unresolved)->RefCount) {
|
||
(*Unresolved)->RefCount--;
|
||
SC_LOG1(DEPEND, "ScDeleteUnresolvedDepend: Subtracted RefCount is "
|
||
FORMAT_DWORD "\n", (*Unresolved)->RefCount);
|
||
}
|
||
else {
|
||
//
|
||
// The reference count better not be 0.
|
||
//
|
||
SC_LOG0(ERROR, "ScDeleteUnresolvedDepend: Before delete, refcount is 0!\n");
|
||
SC_ASSERT(FALSE);
|
||
}
|
||
|
||
if ((*Unresolved)->RefCount == 0) {
|
||
REMOVE_FROM_LIST(*Unresolved);
|
||
LocalFree(*Unresolved);
|
||
*Unresolved = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScCreateDependRecord(
|
||
IN BOOL IsStartList,
|
||
IN OUT PSERVICE_RECORD ServiceRecord,
|
||
OUT PDEPEND_RECORD *DependRecord
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function allocates the memory for a depend record, and insert
|
||
it into the front of the specific depend list. If IsStartList is
|
||
TRUE, the depend record goes into the start depend list of
|
||
ServiceRecord, otherwise the depend record goes into the stop
|
||
depend list of the ServiceRecord.
|
||
|
||
Arguments:
|
||
|
||
IsStartList - TRUE indicates to insert into start list, FALSE indicates
|
||
to insert into stop list.
|
||
|
||
ServiceRecord - Receives the start/stop depend record in its dependency
|
||
list.
|
||
|
||
DependRecord - Receives a pointer to the new depend record created.
|
||
|
||
Return Value:
|
||
|
||
NO_ERROR - The operation was successful.
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY - The call to allocate memory for a depend
|
||
record failed.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScCreateDependencies.
|
||
|
||
--*/
|
||
{
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
if ((*DependRecord = (PDEPEND_RECORD)LocalAlloc(
|
||
LMEM_ZEROINIT,
|
||
sizeof(DEPEND_RECORD)
|
||
)) == NULL) {
|
||
SC_LOG(ERROR,"ScCreateDependRecord: LocalAlloc failure %ld\n",
|
||
GetLastError());
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
|
||
//
|
||
// Insert the depend record into the front of the list
|
||
//
|
||
if (IsStartList) {
|
||
//
|
||
// Start depend
|
||
//
|
||
(*DependRecord)->Next = ServiceRecord->StartDepend;
|
||
ServiceRecord->StartDepend = *DependRecord;
|
||
}
|
||
else {
|
||
//
|
||
// Stop depend
|
||
//
|
||
(*DependRecord)->Next = ServiceRecord->StopDepend;
|
||
ServiceRecord->StopDepend = *DependRecord;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteStartDependencies(
|
||
IN PSERVICE_RECORD ServiceRecord
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function deletes the start dependencies list of a service. It also
|
||
deletes the the stop dependencies of other services which need this
|
||
service to be stopped first.
|
||
|
||
NOTE: This function is for call from RChangeServiceConfig.
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord - Supplies the start dependencies information in this
|
||
service record.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScAddConfigInfoServiceRecord and
|
||
ScDecrementUseCountAndDelete.
|
||
|
||
It also assumes that the caller has exclusively acquired the group
|
||
list lock.
|
||
|
||
--*/
|
||
{
|
||
PDEPEND_RECORD StartEntry;
|
||
PDEPEND_RECORD StopEntry;
|
||
PDEPEND_RECORD StopBackPointer;
|
||
|
||
SC_ASSERT(ScGroupListLock.HaveExclusive());
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
StartEntry = ServiceRecord->StartDepend;
|
||
|
||
while (StartEntry != NULL) {
|
||
|
||
if (StartEntry->DependType == TypeDependOnService) {
|
||
|
||
LPSERVICE_RECORD DependencyService = StartEntry->DependService;
|
||
|
||
|
||
//
|
||
// Find the stop depend record for the service which depends on this
|
||
// service to be stopped first, and delete it.
|
||
//
|
||
StopEntry = DependencyService->StopDepend;
|
||
StopBackPointer = StopEntry;
|
||
|
||
while ((StopEntry != NULL) &&
|
||
(StopEntry->DependService != ServiceRecord)) {
|
||
|
||
StopBackPointer = StopEntry;
|
||
StopEntry = StopEntry->Next;
|
||
}
|
||
|
||
if (StopEntry == NULL) {
|
||
#ifndef _CAIRO_
|
||
//
|
||
// We allow Netlogon to appear in the start dependency list, but
|
||
// not in the stop dependency list. This is for the case where
|
||
// we add a "soft" dependency on netlogon because the service runs
|
||
// in a remove account.
|
||
//
|
||
if (_wcsicmp(DependencyService->ServiceName,L"Netlogon") != 0) {
|
||
#endif // _CAIRO_
|
||
SC_LOG1(ERROR,
|
||
"ScDeleteStartDependencies: Failed to find matching stop depend node for "
|
||
FORMAT_LPWSTR "\n",
|
||
DependencyService->ServiceName);
|
||
SC_ASSERT(FALSE);
|
||
return;
|
||
#ifndef _CAIRO_
|
||
}
|
||
#endif // _CAIRO_
|
||
}
|
||
else {
|
||
|
||
if (StopEntry->DependService == ServiceRecord) {
|
||
|
||
if ((PVOID) StopBackPointer == StopEntry) {
|
||
//
|
||
// Unchaining from the front of the list
|
||
//
|
||
DependencyService->StopDepend = StopEntry->Next;
|
||
}
|
||
else {
|
||
//
|
||
// Unchaining from the middle or end of the list
|
||
//
|
||
StopBackPointer->Next = StopEntry->Next;
|
||
}
|
||
|
||
LocalFree(StopEntry);
|
||
}
|
||
}
|
||
}
|
||
else if (StartEntry->DependType == TypeDependOnGroup) {
|
||
|
||
//
|
||
// Decrement the reference count on the standalone group
|
||
// entry and deletes it if 0.
|
||
//
|
||
if (StartEntry->DependGroup->RefCount != MAXULONG) {
|
||
ScDeleteStandaloneGroup(StartEntry->DependGroup);
|
||
}
|
||
|
||
}
|
||
else {
|
||
|
||
//
|
||
// Dependency type is unresolved.
|
||
//
|
||
ScDeleteUnresolvedDepend(&StartEntry->DependUnresolved);
|
||
}
|
||
|
||
//
|
||
// Now delete the start depend record.
|
||
//
|
||
ServiceRecord->StartDepend = StartEntry->Next;
|
||
LocalFree(StartEntry);
|
||
StartEntry = ServiceRecord->StartDepend;
|
||
}
|
||
}
|
||
|
||
|
||
VOID
|
||
ScDeleteStopDependencies(
|
||
IN PSERVICE_RECORD ServiceToBeDeleted
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function deletes the stop dependencies list of a service. For
|
||
every stop depend service, it makes the start depend pointer of that
|
||
service to point to an unresolved depend entry.
|
||
|
||
This function is called when the service is to be deleted.
|
||
|
||
Arguments:
|
||
|
||
ServiceToBeDeleted - Supplies the pointer to the service that will
|
||
be deleted.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScDecrementUseCountAndDelete.
|
||
|
||
--*/
|
||
{
|
||
|
||
DWORD status;
|
||
PDEPEND_RECORD StartEntry;
|
||
PDEPEND_RECORD StopEntry;
|
||
LPUNRESOLVED_DEPEND Unresolved;
|
||
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
StopEntry = ServiceToBeDeleted->StopDepend;
|
||
|
||
while (StopEntry != NULL) {
|
||
|
||
LPSERVICE_RECORD DependencyService = StopEntry->DependService;
|
||
|
||
//
|
||
// Loop through the start depend entries of the service which
|
||
// depends on ServiceToBeDeleted.
|
||
//
|
||
StartEntry = DependencyService->StartDepend;
|
||
|
||
while (StartEntry != NULL) {
|
||
|
||
if (StartEntry->DependService == ServiceToBeDeleted) {
|
||
break;
|
||
}
|
||
|
||
StartEntry = StartEntry->Next;
|
||
}
|
||
|
||
if (StartEntry != NULL) {
|
||
|
||
//
|
||
// Found a start depend entry that points to the service to be.
|
||
// deleted. Make it point to an unresolved depend entry that
|
||
// represents that service.
|
||
//
|
||
status = ScCreateUnresolvedDepend(
|
||
ServiceToBeDeleted->ServiceName,
|
||
&Unresolved
|
||
);
|
||
|
||
if (status == NO_ERROR) {
|
||
StartEntry->DependType = TypeDependOnUnresolved;
|
||
StartEntry->DependUnresolved = Unresolved;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Now delete the start depend record.
|
||
//
|
||
ServiceToBeDeleted->StopDepend = StopEntry->Next;
|
||
LocalFree(StopEntry);
|
||
StopEntry = ServiceToBeDeleted->StopDepend;
|
||
}
|
||
}
|
||
|
||
|
||
DWORD
|
||
ScSetServiceDependList(
|
||
LPDEPEND_RECORD Start,
|
||
LPSERVICE_RECORD ServiceRecord,
|
||
PVOID DependOnRecord,
|
||
DEPEND_TYPE DependOnType
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
database lock. It is called by ScResolveDependencyToService and
|
||
ScCreateDependencies.
|
||
|
||
--*/
|
||
{
|
||
DWORD status;
|
||
LPDEPEND_RECORD Stop;
|
||
|
||
SC_ASSERT(ScServiceRecordLock.HaveExclusive());
|
||
|
||
//
|
||
// Set fields for start depend entry.
|
||
//
|
||
Start->DependType = DependOnType;
|
||
Start->Depend = DependOnRecord;
|
||
|
||
if (DependOnType == TypeDependOnService) {
|
||
|
||
//
|
||
// Allocate memory for stop depend record and insert it in the
|
||
// front of the stop depend list of the service we depend on.
|
||
//
|
||
if ((status = ScCreateDependRecord(
|
||
FALSE, // For stop list
|
||
(LPSERVICE_RECORD) DependOnRecord,
|
||
&Stop
|
||
)) != NO_ERROR) {
|
||
|
||
return status;
|
||
}
|
||
|
||
Stop->DependType = TypeDependOnService;
|
||
Stop->DependService = ServiceRecord;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
LPLOAD_ORDER_GROUP
|
||
ScGetNamedGroupRecord(
|
||
IN LPCWSTR GroupName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function searches for a named group, first in the order group
|
||
list and next in the standalone group list.
|
||
|
||
Arguments:
|
||
|
||
GroupName - Supplies the name of the group to look for.
|
||
|
||
Return Value:
|
||
|
||
Returns the pointer to group found. If not found, this value is
|
||
NULL.
|
||
|
||
Note:
|
||
|
||
This routine assumes that the caller has exclusively acquired the
|
||
group list lock.
|
||
|
||
--*/
|
||
{
|
||
LPLOAD_ORDER_GROUP Group;
|
||
|
||
for (Group = ScGetOrderGroupList();
|
||
Group != NULL;
|
||
Group = Group->Next)
|
||
{
|
||
if (_wcsicmp(Group->GroupName, GroupName) == 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (Group == NULL)
|
||
{
|
||
for (Group = ScGetStandaloneGroupList();
|
||
Group != NULL;
|
||
Group = Group->Next)
|
||
{
|
||
if (_wcsicmp(Group->GroupName, GroupName) == 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return Group;
|
||
}
|
||
|
||
|
||
VOID
|
||
ScGetUniqueTag(
|
||
IN LPWSTR GroupName,
|
||
OUT LPDWORD Tag
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function looks for a unique tag value within the specified
|
||
group.
|
||
|
||
Arguments:
|
||
|
||
GroupName - Specifies the group name within which the value tag
|
||
returned must be unique.
|
||
|
||
Tag - Receives the unique tag value.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
This function acquires share access to the group list lock.
|
||
|
||
It assumes that the exclusive service database lock is already
|
||
acquired so that no other caller can execute this code until
|
||
the returned tag is fully assigned to the service, and that the
|
||
service entries in the database list don't change.
|
||
|
||
The GroupListLock must be held exclusively prior to calling this
|
||
function.
|
||
|
||
--*/
|
||
{
|
||
LPDWORD TagArray;
|
||
DWORD TagArrayLength;
|
||
|
||
DWORD ReturnTag = 1;
|
||
|
||
LPLOAD_ORDER_GROUP Group;
|
||
|
||
SC_ASSERT(ScGroupListLock.Have());
|
||
SC_ASSERT(ScServiceRecordLock.Have());
|
||
|
||
if (ScGetGroupVector(
|
||
GroupName,
|
||
(LPBYTE *) &TagArray,
|
||
&TagArrayLength
|
||
) == NO_ERROR) {
|
||
|
||
if (TagArray != NULL) {
|
||
//
|
||
// The returned values is actually the number of bytes. Divide it
|
||
// by size of DWORD to make it the number of array entries.
|
||
//
|
||
TagArrayLength = TagArrayLength / sizeof(DWORD);
|
||
|
||
SC_ASSERT((TagArrayLength - 1) == TagArray[0]);
|
||
|
||
ScCompareVector(
|
||
TagArray,
|
||
TagArrayLength,
|
||
&ReturnTag
|
||
);
|
||
}
|
||
}
|
||
else {
|
||
|
||
TagArray = NULL;
|
||
}
|
||
|
||
Group = ScGetNamedGroupRecord(GroupName);
|
||
|
||
if (Group != NULL) {
|
||
|
||
GroupAgain:
|
||
FOR_ALL_SERVICES(Service) {
|
||
|
||
if ((Service->RegistryGroup == Group) &&
|
||
(Service->Tag == ReturnTag)) {
|
||
|
||
ReturnTag++;
|
||
|
||
if (TagArray != NULL) {
|
||
|
||
ScCompareVector(
|
||
TagArray,
|
||
TagArrayLength,
|
||
&ReturnTag
|
||
);
|
||
}
|
||
|
||
goto GroupAgain;
|
||
}
|
||
} // while all services
|
||
}
|
||
|
||
|
||
*Tag = ReturnTag;
|
||
|
||
SC_LOG(DEPEND, "ScGetUniqueTag: Tag=" FORMAT_DWORD "\n", *Tag);
|
||
|
||
}
|
||
|
||
|
||
VOID
|
||
ScCompareVector(
|
||
IN LPDWORD TagArray,
|
||
IN DWORD TagArrayLength,
|
||
IN OUT LPDWORD ReturnTagPtr
|
||
)
|
||
{
|
||
DWORD i;
|
||
|
||
VectorAgain:
|
||
for (i = 1; i < TagArrayLength; i++) {
|
||
|
||
if (TagArray[i] == (*ReturnTagPtr)) {
|
||
|
||
SC_LOG(DEPEND_DUMP, "Tag " FORMAT_DWORD " is not unique\n",
|
||
*ReturnTagPtr);
|
||
|
||
(*ReturnTagPtr)++;
|
||
goto VectorAgain;
|
||
}
|
||
}
|
||
}
|
||
|
||
VOID
|
||
ScGetDependencySize(
|
||
LPSERVICE_RECORD ServiceRecord,
|
||
LPDWORD DependSize,
|
||
LPDWORD MaxDependSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord -
|
||
|
||
DependSize - This points to a location that will contain the number
|
||
of bytes required for the list of dependency strings.
|
||
|
||
MaxDependSize - This points to a location that will contain the
|
||
number of bytes in the longest dependency string in the set.
|
||
|
||
Return Value:
|
||
|
||
|
||
|
||
--*/
|
||
{
|
||
LPDEPEND_RECORD dependRecord;
|
||
DWORD bytesNeeded = 0;
|
||
DWORD StrSize=0;
|
||
|
||
dependRecord = ServiceRecord->StartDepend;
|
||
|
||
//
|
||
// NOTE: Dependencies are expected to be a double NULL terminated
|
||
// terminated set of strings.
|
||
//
|
||
bytesNeeded += sizeof(WCHAR);
|
||
|
||
if (dependRecord == NULL) {
|
||
bytesNeeded += sizeof(WCHAR);
|
||
}
|
||
while (dependRecord != NULL) {
|
||
|
||
SC_ASSERT( dependRecord->Depend != NULL );
|
||
|
||
// Add room. WCSSIZE adds 1 char. For final entry, we'll
|
||
// use null char. In between, we'll put some separator.
|
||
|
||
if (dependRecord->DependType == TypeDependOnService) {
|
||
StrSize =
|
||
(DWORD) WCSSIZE(dependRecord->DependService->ServiceName); // sizes...
|
||
|
||
}
|
||
else if (dependRecord->DependType == TypeDependOnGroup) {
|
||
StrSize =
|
||
(DWORD) WCSSIZE(dependRecord->DependGroup->GroupName) +
|
||
sizeof(WCHAR); // name size plus SC_GROUP_IDENTIFIERW
|
||
}
|
||
else {
|
||
//
|
||
// Unresolved service dependency
|
||
//
|
||
StrSize = (DWORD) WCSSIZE(dependRecord->DependUnresolved->Name);
|
||
}
|
||
|
||
bytesNeeded += StrSize;
|
||
|
||
if (StrSize > *MaxDependSize) {
|
||
*MaxDependSize = StrSize;
|
||
}
|
||
|
||
dependRecord = dependRecord->Next;
|
||
}
|
||
*DependSize = bytesNeeded;
|
||
}
|
||
|
||
DWORD
|
||
ScGetDependencyString(
|
||
LPSERVICE_RECORD ServiceRecord,
|
||
DWORD MaxDependSize,
|
||
DWORD DependSize,
|
||
LPWSTR lpDependencies
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
|
||
|
||
Arguments:
|
||
|
||
ServiceRecord -
|
||
|
||
MaxDependSize - This is the size of the largest string in the
|
||
dependency list.
|
||
|
||
lpDependencies - This is a pointer to the location where the
|
||
list of dependency strings is to be stored.
|
||
|
||
Return Value:
|
||
|
||
|
||
|
||
--*/
|
||
{
|
||
LPWSTR endOfVariableData;
|
||
LPWSTR fixedDataEnd;
|
||
LPDEPEND_RECORD dependRecord;
|
||
DWORD bufSize;
|
||
DWORD ApiStatus = NO_ERROR;
|
||
|
||
//
|
||
// Put dependencies in the return buffer. Since it is a NULL-NULL
|
||
// string, put an extra NULL at the end to begin with.
|
||
//
|
||
endOfVariableData = (LPWSTR) (((LPBYTE)lpDependencies) + DependSize);
|
||
|
||
endOfVariableData = endOfVariableData - 1;
|
||
* endOfVariableData = L'\0';
|
||
|
||
fixedDataEnd = lpDependencies;
|
||
|
||
dependRecord = ServiceRecord->StartDepend;
|
||
|
||
if (dependRecord == NULL) {
|
||
//
|
||
// If there are no dependencies, then we need to add a separator
|
||
// that will be followed by the NULL (immediately above).
|
||
// This separator is used to get us across the RPC interface.
|
||
// Then on the client side, it is changed to a NULL. So we end
|
||
// up with an empty-double-NULL-terminated-string.
|
||
//
|
||
endOfVariableData = endOfVariableData - 1;
|
||
* endOfVariableData = L'/';
|
||
lpDependencies = endOfVariableData;
|
||
}
|
||
else {
|
||
|
||
LPWSTR DependName;
|
||
|
||
|
||
DependName = (LPWSTR)LocalAlloc(0, (UINT) MaxDependSize);
|
||
|
||
if (DependName == NULL) {
|
||
ApiStatus = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
lpDependencies = endOfVariableData;
|
||
while (dependRecord != NULL) {
|
||
|
||
SC_ASSERT( dependRecord->Depend != NULL );
|
||
|
||
|
||
if (dependRecord->DependType == TypeDependOnService) {
|
||
|
||
wcscpy(DependName, dependRecord->DependService->ServiceName);
|
||
|
||
}
|
||
else if (dependRecord->DependType == TypeDependOnGroup) {
|
||
|
||
*DependName = SC_GROUP_IDENTIFIERW;
|
||
|
||
wcscpy(DependName + 1, dependRecord->DependGroup->GroupName);
|
||
}
|
||
else {
|
||
//
|
||
// Unresolved service dependency
|
||
//
|
||
wcscpy(DependName, dependRecord->DependUnresolved->Name);
|
||
}
|
||
|
||
bufSize = (DWORD) wcslen(DependName);
|
||
|
||
if ( !ScCopyStringToBufferW (
|
||
DependName,
|
||
bufSize,
|
||
fixedDataEnd,
|
||
&endOfVariableData,
|
||
&lpDependencies,
|
||
NULL
|
||
) ) {
|
||
|
||
SC_LOG0(ERROR,
|
||
"RQueryServiceConfigW:ScCopyStringtoBufferW (Dependencies)Failed\n");
|
||
|
||
SC_ASSERT( FALSE );
|
||
ApiStatus = ERROR_INSUFFICIENT_BUFFER;
|
||
LocalFree(DependName);
|
||
goto Cleanup;
|
||
}
|
||
else {
|
||
//
|
||
// Add separator character.
|
||
//
|
||
|
||
lpDependencies[bufSize] = L'/';
|
||
}
|
||
|
||
dependRecord = dependRecord->Next;
|
||
}
|
||
|
||
LocalFree(DependName);
|
||
}
|
||
Cleanup:
|
||
return(ApiStatus);
|
||
}
|
||
|
||
|
||
#if DBG
|
||
VOID
|
||
ScDumpGroups(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function walks group list prints out each entry.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
Calls to this routine must be enclosed within #if DBG.
|
||
|
||
--*/
|
||
{
|
||
PLOAD_ORDER_GROUP GroupEntry = ScGetOrderGroupList();
|
||
|
||
|
||
while (GroupEntry != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"\nOrdered Groups:\n"));
|
||
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"Group: Handle=%08lx Name=%ws RefCount=x%lx\n",
|
||
GroupEntry,
|
||
GroupEntry->GroupName,
|
||
GroupEntry->RefCount));
|
||
|
||
GroupEntry = GroupEntry->Next;
|
||
}
|
||
|
||
GroupEntry = ScGetStandaloneGroupList();
|
||
|
||
while (GroupEntry != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"Standalone Groups:\n"));
|
||
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"Group: Handle=%08lx Name=%ws RefCount=x%lx\n",
|
||
GroupEntry,
|
||
GroupEntry->GroupName,
|
||
GroupEntry->RefCount));
|
||
|
||
GroupEntry = GroupEntry->Next;
|
||
}
|
||
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"\nTDI group is at %08lx" "\nPNP_TDI group is at %08lx\n",
|
||
ScGlobalTDIGroup,
|
||
ScGlobalPNP_TDIGroup));
|
||
}
|
||
|
||
VOID
|
||
ScDumpServiceDependencies(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function walks the start and stop dependencies lists of every
|
||
service in the service record list.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
Note:
|
||
|
||
Calls to this routine must be enclosed within #if DBG.
|
||
|
||
--*/
|
||
{
|
||
PDEPEND_RECORD DependList;
|
||
|
||
FOR_ALL_SERVICES(ServiceRecord)
|
||
{
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"Service: %-20ws UseCount=%lu",
|
||
ServiceRecord->ServiceName,
|
||
ServiceRecord->UseCount));
|
||
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
" MemberOfGroup=%08lx ",
|
||
ServiceRecord->MemberOfGroup));
|
||
|
||
if (ServiceRecord->MemberOfGroup != NULL) {
|
||
if (ServiceRecord->MemberOfGroup->RefCount != MAXULONG) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"SG=%ws\n",
|
||
ServiceRecord->MemberOfGroup->GroupName));
|
||
}
|
||
else if (ServiceRecord->MemberOfGroup->RefCount == MAXULONG) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
"OG=%ws\n",
|
||
ServiceRecord->MemberOfGroup->GroupName));
|
||
}
|
||
}
|
||
else {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID, DEBUG_DEPEND_DUMP, "\n"));
|
||
}
|
||
|
||
if (ServiceRecord->RegistryGroup != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
" RG=%ws\n",
|
||
ServiceRecord->RegistryGroup->GroupName));
|
||
}
|
||
|
||
//
|
||
// Dump start depend
|
||
//
|
||
DependList = ServiceRecord->StartDepend;
|
||
|
||
if (DependList != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID, DEBUG_DEPEND_DUMP, " StartDepend:\n"));
|
||
}
|
||
|
||
while (DependList != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
" %ws\n",
|
||
DependList->DependService->ServiceName));
|
||
|
||
DependList = DependList->Next;
|
||
}
|
||
|
||
//
|
||
// Dump stop depend
|
||
//
|
||
DependList = ServiceRecord->StopDepend;
|
||
if (DependList != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID, DEBUG_DEPEND_DUMP, " StopDepend:\n"));
|
||
}
|
||
|
||
while (DependList != NULL) {
|
||
KdPrintEx((DPFLTR_SCSERVER_ID,
|
||
DEBUG_DEPEND_DUMP,
|
||
" %ws\n",
|
||
DependList->DependService->ServiceName));
|
||
|
||
DependList = DependList->Next;
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif // #if DBG
|