763 lines
20 KiB
C
763 lines
20 KiB
C
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
msvctbl.c
|
|
|
|
Abstract:
|
|
|
|
Master Service Table routines. Handles all access to the master service
|
|
table kept for per-seat information.
|
|
|
|
=========================== DATA STRUCTURES =============================
|
|
|
|
MasterServiceTable (PMASTER_SERVICE_RECORD *)
|
|
MasterServiceList (PMASTER_SERVICE_RECORD *)
|
|
Each of these points to an array of pointers to dynamically allocated
|
|
MASTER_SERVICE_RECORDs. There is exactly one MASTER_SERVICE_RECORD
|
|
for each (product, version) pairing; e.g., (SQL 4.0, SNA 2.0,
|
|
SNA 2.1). The MasterServiceTable is never re-ordered, so a valid
|
|
index into this table is guaranteed to always dereference to the same
|
|
(product, version). The MasterServiceList contains the same data
|
|
sorted lexicographically by product name (and therefore the data
|
|
pointed to by a specific index may change over time as new
|
|
(product, version) pairs are added to the table). Each table
|
|
contains MasterServiceListSize entries.
|
|
|
|
RootServiceList (PMASTER_SERVICE_ROOT *)
|
|
This points to an array of pointers to dynamically allocated
|
|
MASTER_SERVICE_ROOTs. There is exactly one MASTER_SERVICE_ROOT
|
|
for each product family. Each MASTER_SERVICE_ROOT contains a
|
|
pointer to an array of indices into the MasterServiceTable
|
|
corresponding to all the products in the family, sorted by
|
|
ascending version number. The RootServiceList itself is
|
|
sorted lexicographically by ascending family name. It contains
|
|
RootServiceListSize entries.
|
|
|
|
Author:
|
|
|
|
Arthur Hanson (arth) 07-Dec-1994
|
|
|
|
Revision History:
|
|
|
|
Jeff Parham (jeffparh) 05-Dec-1995
|
|
o Added a few comments.
|
|
o Added parameter to LicenseServiceListFind().
|
|
o Fixed benign bug in memory allocation:
|
|
sizeof(PULONG) -> sizeof(ULONG).
|
|
|
|
--*/
|
|
|
|
#include <stdlib.h>
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <dsgetdc.h>
|
|
|
|
#include "llsapi.h"
|
|
#include "debug.h"
|
|
#include "llssrv.h"
|
|
#include "registry.h"
|
|
#include "ntlsapi.h"
|
|
#include "mapping.h"
|
|
#include "msvctbl.h"
|
|
#include "svctbl.h"
|
|
#include "purchase.h"
|
|
#include "perseat.h"
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Master Service Table - Keeps list of products (SQL, SNA, etc.) with a
|
|
// sub-list for each version of the product.
|
|
//
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
#define DEFAULT_SERVICE_TABLE_ENTRIES 10
|
|
|
|
ULONG RootServiceListSize = 0;
|
|
PMASTER_SERVICE_ROOT *RootServiceList = NULL;
|
|
|
|
ULONG MasterServiceListSize = 0;
|
|
PMASTER_SERVICE_RECORD *MasterServiceList = NULL;
|
|
PMASTER_SERVICE_RECORD *MasterServiceTable = NULL;
|
|
|
|
TCHAR BackOfficeStr[100];
|
|
PMASTER_SERVICE_RECORD BackOfficeRec;
|
|
|
|
RTL_RESOURCE MasterServiceListLock;
|
|
|
|
HANDLE gLlsDllHandle = NULL;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
NTSTATUS
|
|
MasterServiceListInit()
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates the Master Service table, used for tracking the services and
|
|
session count. This will pull the initial services from the registry.
|
|
|
|
The table is linear so a binary search can be used on the table, so
|
|
some extra records are initialized so that each time we add a new
|
|
service we don't have to do a realloc. We also assume that adding
|
|
new services is a relatively rare occurance, since we need to sort
|
|
it each time.
|
|
|
|
The service table is guarded by a read and write semaphore. Multiple
|
|
reads can occur, but a write blocks everything.
|
|
|
|
The service table has two default entries for FilePrint and REMOTE_ACCESS.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
int nLen;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
try
|
|
{
|
|
RtlInitializeResource(&MasterServiceListLock);
|
|
} except(EXCEPTION_EXECUTE_HANDLER ) {
|
|
status = GetExceptionCode();
|
|
}
|
|
|
|
if (!NT_SUCCESS(status))
|
|
return status;
|
|
|
|
memset(BackOfficeStr, 0, sizeof(BackOfficeStr));
|
|
BackOfficeRec = NULL;
|
|
gLlsDllHandle = LoadLibrary(TEXT("LLSRPC.DLL"));
|
|
|
|
|
|
if (gLlsDllHandle != NULL) {
|
|
nLen = LoadString(gLlsDllHandle, IDS_BACKOFFICE, BackOfficeStr, sizeof(BackOfficeStr)/sizeof(TCHAR));
|
|
|
|
if (nLen != 0) {
|
|
BackOfficeRec = MasterServiceListAdd( BackOfficeStr, BackOfficeStr, 0 );
|
|
if (NULL == BackOfficeRec)
|
|
status = STATUS_NO_MEMORY;
|
|
|
|
} else {
|
|
#if DBG
|
|
dprintf(TEXT("LLS ERROR: Could not load BackOffice string\n"));
|
|
#endif
|
|
|
|
status = GetLastError();
|
|
}
|
|
|
|
status = GetLastError();
|
|
}
|
|
|
|
return status;
|
|
|
|
} // MasterServiceListInit
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// used by qsort to sort MasterServiceList by product name
|
|
int __cdecl MasterServiceListCompare(const void *arg1, const void *arg2) {
|
|
PMASTER_SERVICE_RECORD Svc1, Svc2;
|
|
|
|
Svc1 = (PMASTER_SERVICE_RECORD) *((PMASTER_SERVICE_RECORD *) arg1);
|
|
Svc2 = (PMASTER_SERVICE_RECORD) *((PMASTER_SERVICE_RECORD *) arg2);
|
|
|
|
return lstrcmpi( Svc1->Name, Svc2->Name );
|
|
|
|
} // MasterServiceListCompare
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// used by qsort to sort the Services array of indices pointed to by the
|
|
// MASTER_SERVICE_ROOT structure by product version number
|
|
int __cdecl MServiceRecordCompare(const void *arg1, const void *arg2) {
|
|
PMASTER_SERVICE_RECORD Svc1, Svc2;
|
|
|
|
Svc1 = (PMASTER_SERVICE_RECORD) MasterServiceTable[*((PULONG) arg1)];
|
|
Svc2 = (PMASTER_SERVICE_RECORD) MasterServiceTable[*((PULONG) arg2)];
|
|
|
|
return (int) Svc1->Version - Svc2->Version;
|
|
|
|
} // MServiceRecordCompare
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// used by qsort to sort the RootServiceList array of product families
|
|
// by family name
|
|
int __cdecl MServiceRootCompare(const void *arg1, const void *arg2) {
|
|
PMASTER_SERVICE_ROOT Svc1, Svc2;
|
|
|
|
Svc1 = (PMASTER_SERVICE_ROOT) *((PMASTER_SERVICE_ROOT *) arg1);
|
|
Svc2 = (PMASTER_SERVICE_ROOT) *((PMASTER_SERVICE_ROOT *) arg2);
|
|
|
|
return lstrcmpi( Svc1->Name, Svc2->Name );
|
|
|
|
} // MServiceRootCompare
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
PMASTER_SERVICE_ROOT
|
|
MServiceRootFind(
|
|
LPTSTR ServiceName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Internal routine to actually do binary search on MasterServiceList, this
|
|
does not do any locking as we expect the wrapper routine to do this.
|
|
The search is a simple binary search.
|
|
|
|
Arguments:
|
|
|
|
ServiceName -
|
|
|
|
Return Value:
|
|
|
|
Pointer to found service table entry or NULL if not found.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG begin = 0;
|
|
LONG end = (LONG) RootServiceListSize - 1;
|
|
LONG cur;
|
|
int match;
|
|
PMASTER_SERVICE_ROOT ServiceRoot;
|
|
|
|
#if DBG
|
|
if (TraceFlags & TRACE_FUNCTION_TRACE)
|
|
dprintf(TEXT("LLS TRACE: MServiceRootFind\n"));
|
|
#endif
|
|
|
|
if ((RootServiceListSize == 0) || (ServiceName == NULL))
|
|
return NULL;
|
|
|
|
while (end >= begin) {
|
|
// go halfway in-between
|
|
cur = (begin + end) / 2;
|
|
ServiceRoot = RootServiceList[cur];
|
|
|
|
// compare the two result into match
|
|
match = lstrcmpi(ServiceName, ServiceRoot->Name);
|
|
|
|
if (match < 0)
|
|
// move new begin
|
|
end = cur - 1;
|
|
else
|
|
begin = cur + 1;
|
|
|
|
if (match == 0)
|
|
return ServiceRoot;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
} // MServiceRootFind
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
PMASTER_SERVICE_RECORD
|
|
MasterServiceListFind(
|
|
LPTSTR Name
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Internal routine to actually do binary search on MasterServiceList, this
|
|
does not do any locking as we expect the wrapper routine to do this.
|
|
The search is a simple binary search.
|
|
|
|
Arguments:
|
|
|
|
ServiceName -
|
|
|
|
Return Value:
|
|
|
|
Pointer to found service table entry or NULL if not found.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG begin = 0;
|
|
LONG end;
|
|
LONG cur;
|
|
int match;
|
|
PMASTER_SERVICE_RECORD Service;
|
|
|
|
#if DBG
|
|
if (TraceFlags & TRACE_FUNCTION_TRACE)
|
|
dprintf(TEXT("LLS TRACE: MasterServiceListFind\n"));
|
|
#endif
|
|
|
|
if ((Name == NULL) || (MasterServiceListSize == 0))
|
|
return NULL;
|
|
|
|
end = (LONG) MasterServiceListSize - 1;
|
|
|
|
while (end >= begin) {
|
|
// go halfway in-between
|
|
cur = (begin + end) / 2;
|
|
Service = MasterServiceList[cur];
|
|
|
|
// compare the two result into match
|
|
match = lstrcmpi(Name, Service->Name);
|
|
|
|
if (match < 0)
|
|
// move new begin
|
|
end = cur - 1;
|
|
else
|
|
begin = cur + 1;
|
|
|
|
if (match == 0)
|
|
return Service;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
} // MasterServiceListFind
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
PMASTER_SERVICE_RECORD
|
|
MasterServiceListAdd(
|
|
LPTSTR FamilyName,
|
|
LPTSTR Name,
|
|
DWORD Version
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
ServiceName -
|
|
|
|
Return Value:
|
|
|
|
Pointer to added service table entry, or NULL if failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i;
|
|
ULONG SessionLimit = 0;
|
|
BOOL PerSeatLicensing = FALSE;
|
|
LPTSTR NewServiceName, pDisplayName;
|
|
PMASTER_SERVICE_RECORD Service = NULL;
|
|
PMASTER_SERVICE_ROOT ServiceRoot = NULL;
|
|
PULONG ServiceList;
|
|
PLICENSE_SERVICE_RECORD pLicense;
|
|
PMASTER_SERVICE_ROOT *pRootServiceListTmp;
|
|
PULONG pServiceListTmp;
|
|
PMASTER_SERVICE_RECORD *pMasterServiceListTmp, *pMasterServiceTableTmp;
|
|
|
|
#if DBG
|
|
if (TraceFlags & TRACE_FUNCTION_TRACE)
|
|
dprintf(TEXT("LLS TRACE: MasterServiceListAdd\n"));
|
|
#endif
|
|
|
|
if ((FamilyName == NULL) || (Name == NULL))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Mask off low word of version - as it doesn't matter to licensing
|
|
//
|
|
Version &= 0xFFFF0000;
|
|
|
|
//
|
|
// Try to find a root node for that family of products
|
|
//
|
|
ServiceRoot = MServiceRootFind(FamilyName);
|
|
|
|
if (ServiceRoot == NULL) {
|
|
//
|
|
// No root record - so create a new one
|
|
//
|
|
if (RootServiceList == NULL)
|
|
pRootServiceListTmp = (PMASTER_SERVICE_ROOT *) LocalAlloc(LPTR, sizeof(PMASTER_SERVICE_ROOT));
|
|
else
|
|
pRootServiceListTmp = (PMASTER_SERVICE_ROOT *) LocalReAlloc(RootServiceList, sizeof(PMASTER_SERVICE_ROOT) * (RootServiceListSize + 1), LHND);
|
|
|
|
//
|
|
// Make sure we could allocate service table
|
|
//
|
|
if (pRootServiceListTmp == NULL) {
|
|
return NULL;
|
|
} else {
|
|
RootServiceList = pRootServiceListTmp;
|
|
}
|
|
|
|
//
|
|
// Allocate space for Root.
|
|
//
|
|
ServiceRoot = (PMASTER_SERVICE_ROOT) LocalAlloc(LPTR, sizeof(MASTER_SERVICE_ROOT));
|
|
if (ServiceRoot == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
NewServiceName = (LPTSTR) LocalAlloc(LPTR, (lstrlen(FamilyName) + 1) * sizeof(TCHAR));
|
|
if (NewServiceName == NULL) {
|
|
LocalFree(ServiceRoot);
|
|
return NULL;
|
|
}
|
|
|
|
try
|
|
{
|
|
RtlInitializeResource(&ServiceRoot->ServiceLock);
|
|
} except(EXCEPTION_EXECUTE_HANDLER ) {
|
|
LocalFree(ServiceRoot);
|
|
LocalFree(NewServiceName);
|
|
return NULL;
|
|
}
|
|
|
|
RootServiceList[RootServiceListSize] = ServiceRoot;
|
|
|
|
// now copy it over...
|
|
ServiceRoot->Name = NewServiceName;
|
|
lstrcpy(NewServiceName, FamilyName);
|
|
|
|
//
|
|
// Initialize stuff for list of various versions of this product
|
|
//
|
|
ServiceRoot->ServiceTableSize = 0;
|
|
ServiceRoot->Services = NULL;
|
|
ServiceRoot->Flags = 0;
|
|
|
|
RootServiceListSize++;
|
|
|
|
// Have added the entry - now need to sort it in order of the service names
|
|
qsort((void *) RootServiceList, (size_t) RootServiceListSize, sizeof(PMASTER_SERVICE_ROOT), MServiceRootCompare);
|
|
|
|
}
|
|
|
|
RtlAcquireResourceShared(&ServiceRoot->ServiceLock, TRUE);
|
|
Service = MasterServiceListFind(Name);
|
|
RtlReleaseResource(&ServiceRoot->ServiceLock);
|
|
if (Service != NULL)
|
|
return Service;
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Whether added or found, ServiceRoot points to the Root Node entry.
|
|
// Now double check to see if another thread just got done adding the
|
|
// actual service before we got the write lock.
|
|
//
|
|
RtlAcquireResourceShared(&ServiceRoot->ServiceLock, TRUE);
|
|
Service = MasterServiceListFind(Name);
|
|
|
|
if (Service == NULL) {
|
|
//
|
|
// No Service Record - so create a new one
|
|
//
|
|
RtlConvertSharedToExclusive(&ServiceRoot->ServiceLock);
|
|
|
|
//
|
|
// Double-check that no one snuck in and created it
|
|
//
|
|
Service = MasterServiceListFind(Name);
|
|
|
|
if (Service == NULL) {
|
|
|
|
ServiceList = ServiceRoot->Services;
|
|
if (ServiceList == NULL)
|
|
pServiceListTmp = (PULONG) LocalAlloc(LPTR, sizeof(ULONG));
|
|
else
|
|
pServiceListTmp = (PULONG) LocalReAlloc(ServiceList, sizeof(ULONG) * (ServiceRoot->ServiceTableSize + 1), LHND);
|
|
|
|
if (MasterServiceList == NULL) {
|
|
pMasterServiceListTmp = (PMASTER_SERVICE_RECORD *) LocalAlloc(LPTR, sizeof(PMASTER_SERVICE_RECORD));
|
|
pMasterServiceTableTmp = (PMASTER_SERVICE_RECORD *) LocalAlloc(LPTR, sizeof(PMASTER_SERVICE_RECORD));
|
|
} else {
|
|
pMasterServiceListTmp = (PMASTER_SERVICE_RECORD *) LocalReAlloc(MasterServiceList, sizeof(PMASTER_SERVICE_RECORD) * (MasterServiceListSize + 1), LHND);
|
|
pMasterServiceTableTmp = (PMASTER_SERVICE_RECORD *) LocalReAlloc(MasterServiceTable, sizeof(PMASTER_SERVICE_RECORD) * (MasterServiceListSize + 1), LHND);
|
|
}
|
|
|
|
//
|
|
// Make sure we could allocate service table
|
|
//
|
|
if ((pServiceListTmp == NULL) || (pMasterServiceListTmp == NULL) || (pMasterServiceTableTmp == NULL)) {
|
|
if (pServiceListTmp != NULL)
|
|
LocalFree(pServiceListTmp);
|
|
|
|
if (pMasterServiceListTmp != NULL)
|
|
LocalFree(pMasterServiceListTmp);
|
|
|
|
if (pMasterServiceTableTmp != NULL)
|
|
LocalFree(pMasterServiceTableTmp);
|
|
|
|
RtlReleaseResource(&ServiceRoot->ServiceLock);
|
|
return NULL;
|
|
} else {
|
|
ServiceList = pServiceListTmp;
|
|
MasterServiceList = pMasterServiceListTmp;
|
|
MasterServiceTable = pMasterServiceTableTmp;
|
|
}
|
|
|
|
ServiceRoot->Services = ServiceList;
|
|
|
|
//
|
|
// Allocate space for saving off Service Record.
|
|
//
|
|
Service = (PMASTER_SERVICE_RECORD) LocalAlloc(LPTR, sizeof(MASTER_SERVICE_RECORD));
|
|
if (Service == NULL) {
|
|
ASSERT(FALSE);
|
|
RtlReleaseResource(&ServiceRoot->ServiceLock);
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// ...DisplayName
|
|
//
|
|
NewServiceName = (LPTSTR) LocalAlloc(LPTR, (lstrlen(Name) + 1) * sizeof(TCHAR));
|
|
if (NewServiceName == NULL) {
|
|
ASSERT(FALSE);
|
|
LocalFree(Service);
|
|
RtlReleaseResource(&ServiceRoot->ServiceLock);
|
|
return NULL;
|
|
}
|
|
|
|
ServiceList[ServiceRoot->ServiceTableSize] = MasterServiceListSize;
|
|
MasterServiceList[MasterServiceListSize] = Service;
|
|
MasterServiceTable[MasterServiceListSize] = Service;
|
|
|
|
// now copy it over...
|
|
Service->Name = NewServiceName;
|
|
lstrcpy(NewServiceName, Name);
|
|
|
|
//
|
|
// Init rest of values.
|
|
//
|
|
Service->Version= Version;
|
|
Service->LicensesUsed = 0;
|
|
Service->LicensesClaimed = 0;
|
|
Service->next = 0;
|
|
Service->Index = MasterServiceListSize;
|
|
Service->Family = ServiceRoot;
|
|
|
|
pLicense = LicenseServiceListFind(Service->Name, FALSE);
|
|
if (pLicense == NULL)
|
|
Service->Licenses = 0;
|
|
else
|
|
Service->Licenses = pLicense->NumberLicenses;
|
|
|
|
//
|
|
// Init next pointer
|
|
//
|
|
i = 0;
|
|
while ((i < ServiceRoot->ServiceTableSize) && (MasterServiceTable[ServiceRoot->Services[i]]->Version < Version))
|
|
i++;
|
|
|
|
if (i > 0) {
|
|
Service->next = MasterServiceTable[ServiceRoot->Services[i - 1]]->next;
|
|
MasterServiceTable[ServiceRoot->Services[i - 1]]->next = Service->Index + 1;
|
|
}
|
|
|
|
ServiceRoot->ServiceTableSize++;
|
|
MasterServiceListSize++;
|
|
|
|
// Have added the entry - now need to sort it in order of the versions
|
|
qsort((void *) ServiceList, (size_t) ServiceRoot->ServiceTableSize, sizeof(ULONG), MServiceRecordCompare);
|
|
|
|
// And sort the list the UI uses (sorted by service name)
|
|
qsort((void *) MasterServiceList, (size_t) MasterServiceListSize, sizeof(PMASTER_SERVICE_RECORD), MasterServiceListCompare);
|
|
}
|
|
}
|
|
|
|
RtlReleaseResource(&ServiceRoot->ServiceLock);
|
|
return Service;
|
|
|
|
} // MasterServiceListAdd
|
|
|
|
|
|
#if DBG
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DEBUG INFORMATION DUMP ROUTINES
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
VOID
|
|
MasterServiceRootDebugDump( )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i = 0;
|
|
|
|
//
|
|
// Need to scan list so get read access.
|
|
//
|
|
RtlAcquireResourceShared(&MasterServiceListLock, TRUE);
|
|
|
|
dprintf(TEXT("Service Family Table, # Entries: %lu\n"), RootServiceListSize);
|
|
if (RootServiceList == NULL)
|
|
goto MasterServiceRootDebugDumpExit;
|
|
|
|
for (i = 0; i < RootServiceListSize; i++) {
|
|
dprintf(TEXT("%3lu) Services: %3lu Svc: %s [%s]\n"),
|
|
i + 1, RootServiceList[i]->ServiceTableSize, RootServiceList[i]->Name, RootServiceList[i]->Name);
|
|
}
|
|
|
|
MasterServiceRootDebugDumpExit:
|
|
RtlReleaseResource(&MasterServiceListLock);
|
|
|
|
return;
|
|
} // MasterServiceRootDebugDump
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
VOID
|
|
MasterServiceRootDebugInfoDump( PVOID Data )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i = 0;
|
|
|
|
//
|
|
// Need to scan list so get read access.
|
|
//
|
|
RtlAcquireResourceShared(&MasterServiceListLock, TRUE);
|
|
|
|
dprintf(TEXT("Service Family Table, # Entries: %lu\n"), RootServiceListSize);
|
|
if (RootServiceList == NULL)
|
|
goto MasterServiceRootDebugDumpExit;
|
|
|
|
for (i = 0; i < RootServiceListSize; i++) {
|
|
dprintf(TEXT("%3lu) Services: %3lu Svc: %s [%s]\n"),
|
|
i + 1, RootServiceList[i]->ServiceTableSize, RootServiceList[i]->Name, RootServiceList[i]->Name);
|
|
}
|
|
|
|
MasterServiceRootDebugDumpExit:
|
|
RtlReleaseResource(&MasterServiceListLock);
|
|
|
|
return;
|
|
} // MasterServiceRootDebugInfoDump
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
VOID
|
|
MasterServiceListDebugDump( )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i = 0;
|
|
|
|
//
|
|
// Need to scan list so get read access.
|
|
//
|
|
RtlAcquireResourceShared(&MasterServiceListLock, TRUE);
|
|
|
|
dprintf(TEXT("Master Service Table, # Entries: %lu\n"), MasterServiceListSize);
|
|
if (MasterServiceList == NULL)
|
|
goto MasterServiceListDebugDumpExit;
|
|
|
|
for (i = 0; i < MasterServiceListSize; i++) {
|
|
dprintf(TEXT("%3lu) [%3lu] LU: %4lu LP: %4lu LC: %4lu MS: %4lu HM: %4lu Next: %3lu Svc: %s %lX\n"),
|
|
i + 1, MasterServiceList[i]->Index,
|
|
MasterServiceList[i]->LicensesUsed, MasterServiceList[i]->Licenses, MasterServiceList[i]->LicensesClaimed,
|
|
MasterServiceList[i]->MaxSessionCount, MasterServiceList[i]->HighMark,
|
|
MasterServiceList[i]->next, MasterServiceList[i]->Name, MasterServiceList[i]->Version);
|
|
}
|
|
|
|
MasterServiceListDebugDumpExit:
|
|
RtlReleaseResource(&MasterServiceListLock);
|
|
|
|
return;
|
|
} // MasterServiceListDebugDump
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
VOID
|
|
MasterServiceListDebugInfoDump( PVOID Data )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
PMASTER_SERVICE_RECORD CurrentRecord = NULL;
|
|
|
|
dprintf(TEXT("Master Service Table, # Entries: %lu\n"), RootServiceListSize);
|
|
|
|
if (lstrlen((LPWSTR) Data) > 0) {
|
|
// CurrentRecord = MasterServiceListFind((LPWSTR) Data);
|
|
if (CurrentRecord != NULL) {
|
|
}
|
|
}
|
|
|
|
} // MasterServiceListDebugInfoDump
|
|
|
|
#endif
|