able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/svcimgs/ntrepl/util/frstable.c

1258 lines
25 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
frstable.c
Abstract:
These routines manage the tables used by the FRS.
Author:
Billy J. Fuller 19-Apr-1997
Environment
User mode winnt
--*/
#include <ntreppch.h>
#pragma hdrstop
#define DEBSUB "FRSTABLE:"
#include <frs.h>
PVOID
GTabAllocTableMem(
IN PRTL_GENERIC_TABLE Table,
IN DWORD NodeSize
)
/*++
Routine Description:
Allocate space for a table entry. The entry includes the user-defined
struct and some overhead used by the generic table routines. The
generic table routines call this function when they need memory.
Arguments:
Table - Address of the table (not used).
NodeSize - Bytes to allocate
Return Value:
Address of newly allocated memory.
--*/
{
return FrsAlloc(NodeSize);
}
VOID
GTabFreeTableMem(
IN PRTL_GENERIC_TABLE Table,
IN PVOID Buffer
)
/*++
Routine Description:
Free the space allocated by GTAlloc(). The generic table
routines call this function to free memory.
Arguments:
Table - Address of the table (not used).
Buffer - Address of previously allocated memory
Return Value:
None.
--*/
{
FrsFree(Buffer);
}
RTL_GENERIC_COMPARE_RESULTS
GTabCmpTableEntry(
IN PRTL_GENERIC_TABLE Table,
IN PVOID TableEntry1,
IN PVOID TableEntry2
)
/*++
Routine Description:
Compare two entries in the table for guid/names.
Arguments:
Table - Address of the table (not used).
Entry1 - PGEN_ENTRY
Entry2 - PGEN_ENTRY
Return Value:
<0 First < Second
=0 First == Second
>0 First > Second
--*/
{
INT Cmp;
PGEN_ENTRY Entry1 = (PGEN_ENTRY)TableEntry1;
PGEN_ENTRY Entry2 = (PGEN_ENTRY)TableEntry2;
//
// Primary key must be present
//
FRS_ASSERT(Entry1->Key1 && Entry2->Key1);
//
// Compare primary keys
//
Cmp = memcmp(Entry1->Key1, Entry2->Key1, sizeof(GUID));
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0) {
return (GenericGreaterThan);
}
//
// No second key; done
//
if (!Entry1->Key2 || !Entry2->Key2)
return GenericEqual;
//
// Compare secondary keys
//
Cmp = _wcsicmp(Entry1->Key2, Entry2->Key2);
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0){
return (GenericGreaterThan);
}
return (GenericEqual);
}
RTL_GENERIC_COMPARE_RESULTS
GTabCmpTableNumberEntry(
IN PRTL_GENERIC_TABLE Table,
IN PVOID TableEntry1,
IN PVOID TableEntry2
)
/*++
Routine Description:
Compare two entries in the table for number
Arguments:
Table - Address of the table (not used).
Entry1 - PGEN_ENTRY
Entry2 - PGEN_ENTRY
Return Value:
<0 First < Second
=0 First == Second
>0 First > Second
--*/
{
INT Cmp;
PGEN_ENTRY Entry1 = (PGEN_ENTRY)TableEntry1;
PGEN_ENTRY Entry2 = (PGEN_ENTRY)TableEntry2;
//
// Primary key must be present
//
FRS_ASSERT(Entry1->Key1 && Entry2->Key1);
//
// Compare primary keys
//
Cmp = memcmp(Entry1->Key1, Entry2->Key1, sizeof(ULONG));
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0){
return (GenericGreaterThan);
}
return GenericEqual;
}
RTL_GENERIC_COMPARE_RESULTS
GTabCmpTableStringAndBoolEntry(
IN PRTL_GENERIC_TABLE Table,
IN PVOID TableEntry1,
IN PVOID TableEntry2
)
/*++
Routine Description:
Compare two entries in the table for data with strings used as key.
Arguments:
Table - Address of the table (not used).
Entry1 - PGEN_ENTRY
Entry2 - PGEN_ENTRY
Return Value:
<0 First < Second
=0 First == Second
>0 First > Second
--*/
{
INT Cmp;
PGEN_ENTRY Entry1 = (PGEN_ENTRY)TableEntry1;
PGEN_ENTRY Entry2 = (PGEN_ENTRY)TableEntry2;
//
// Primary key must be present
//
FRS_ASSERT(Entry1->Key1 && Entry2->Key1);
//
// Compare primary keys
//
Cmp = _wcsicmp((PWCHAR)(Entry1->Key1), (PWCHAR)(Entry2->Key1));
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0){
return (GenericGreaterThan);
}
//
// Compare secondary keys if they exist.
//
if ((Entry1->Key2 == NULL) || (Entry2->Key2 == NULL)) {
return GenericEqual;
}
if (*(Entry1->Key2) == *(Entry2->Key2)) {
return GenericEqual;
} else if (*(Entry1->Key2) == FALSE) {
return GenericLessThan;
}
return GenericGreaterThan;
}
RTL_GENERIC_COMPARE_RESULTS
GTabCmpTableStringEntry(
IN PRTL_GENERIC_TABLE Table,
IN PVOID TableEntry1,
IN PVOID TableEntry2
)
/*++
Routine Description:
Compare two entries in the table for data with strings used as key.
Arguments:
Table - Address of the table (not used).
Entry1 - PGEN_ENTRY
Entry2 - PGEN_ENTRY
Return Value:
<0 First < Second
=0 First == Second
>0 First > Second
--*/
{
INT Cmp;
PGEN_ENTRY Entry1 = (PGEN_ENTRY)TableEntry1;
PGEN_ENTRY Entry2 = (PGEN_ENTRY)TableEntry2;
//
// Primary key must be present
//
FRS_ASSERT(Entry1->Key1 && Entry2->Key1);
//
// Compare primary keys
//
Cmp = _wcsicmp((PWCHAR)(Entry1->Key1), (PWCHAR)(Entry2->Key1));
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0){
return (GenericGreaterThan);
}
//
// Compare secondary keys if they exist.
//
if ((Entry1->Key2 == NULL) || (Entry2->Key2 == NULL)) {
return GenericEqual;
}
Cmp = _wcsicmp(Entry1->Key2, Entry2->Key2);
if (Cmp < 0) {
return (GenericLessThan);
}
if (Cmp > 0){
return (GenericGreaterThan);
}
return GenericEqual;
}
VOID
GTabLockTable(
PGEN_TABLE GTable
)
/*++
Routine Description:
Lock the table
Arguments:
GTable - frs generic table
Return Value:
None.
--*/
{
EnterCriticalSection(&GTable->Critical);
}
VOID
GTabUnLockTable(
PGEN_TABLE GTable
)
/*++
Routine Description:
Unlock the table
Arguments:
GTable - frs generic table
Return Value:
None.
--*/
{
LeaveCriticalSection(&GTable->Critical);
}
PGEN_TABLE
GTabAllocNumberTable(
VOID
)
/*++
Routine Description:
Initialize a generic table + lock for numbers.
Arguments:
None.
Return Value:
None.
--*/
{
PGEN_TABLE GTable;
GTable = FrsAllocType(GEN_TABLE_TYPE);
InitializeCriticalSection(&GTable->Critical);
RtlInitializeGenericTable(&GTable->Table,
GTabCmpTableNumberEntry,
GTabAllocTableMem,
GTabFreeTableMem,
NULL);
return GTable;
}
PGEN_TABLE
GTabAllocStringTable(
VOID
)
/*++
Routine Description:
Initialize a generic table + lock for data with strings
used as a key.
Arguments:
None.
Return Value:
None.
--*/
{
PGEN_TABLE GTable;
GTable = FrsAllocType(GEN_TABLE_TYPE);
InitializeCriticalSection(&GTable->Critical);
RtlInitializeGenericTable(&GTable->Table,
GTabCmpTableStringEntry,
GTabAllocTableMem,
GTabFreeTableMem,
NULL);
return GTable;
}
PGEN_TABLE
GTabAllocStringAndBoolTable(
VOID
)
/*++
Routine Description:
Initialize a generic table + lock for data with a string and bool
used as a key.
Arguments:
None.
Return Value:
None.
--*/
{
PGEN_TABLE GTable;
GTable = FrsAllocType(GEN_TABLE_TYPE);
InitializeCriticalSection(&GTable->Critical);
RtlInitializeGenericTable(&GTable->Table,
GTabCmpTableStringAndBoolEntry,
GTabAllocTableMem,
GTabFreeTableMem,
NULL);
return GTable;
}
PGEN_TABLE
GTabAllocTable(
VOID
)
/*++
Routine Description:
Initialize a generic table + lock.
Arguments:
None.
Return Value:
None.
--*/
{
PGEN_TABLE GTable;
GTable = FrsAllocType(GEN_TABLE_TYPE);
InitializeCriticalSection(&GTable->Critical);
RtlInitializeGenericTable(&GTable->Table,
GTabCmpTableEntry,
GTabAllocTableMem,
GTabFreeTableMem,
NULL);
return GTable;
}
VOID
GTabEmptyTableNoLock(
IN PGEN_TABLE GTable,
IN PVOID (*CallerFree)(PVOID)
)
/*++
Routine Description:
Free every entry in the frs generic table. Caller has acquired the table lock.
Arguments:
GTable - frs generic table
CallerFree - The free routine to use to free up the callers datum (optional)
Return Value:
None.
--*/
{
PGEN_ENTRY Entry; // Next entry in table
PGEN_ENTRY Dup; // Next entry in table
PVOID Data;
//
// For every entry in the table
//
while (Entry = RtlEnumerateGenericTable(&GTable->Table, TRUE)) {
//
// Delete the dups
//
while (Dup = Entry->Dups) {
Entry->Dups = Dup->Dups;
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Dup->Data);
}
Dup = FrsFree(Dup);
}
//
// Delete the entry from the table
//
Data = Entry->Data;
RtlDeleteElementGenericTable(&GTable->Table, Entry);
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Data);
}
}
}
VOID
GTabEmptyTable(
IN PGEN_TABLE GTable,
IN PVOID (*CallerFree)(PVOID)
)
/*++
Routine Description:
Free every entry in the frs generic table.
Arguments:
GTable - frs generic table
CallerFree - The free routine to use to free up the callers datum (optional)
Return Value:
None.
--*/
{
GTabLockTable(GTable);
GTabEmptyTableNoLock(GTable, CallerFree);
GTabUnLockTable(GTable);
}
PVOID
GTabFreeTable(
IN PGEN_TABLE GTable,
IN PVOID (*CallerFree)(PVOID)
)
/*++
Routine Description:
Undo the work done by GenTableInitialize.
Arguments:
GTTable - Address of the gen table.
CallerFree - The free routine to use to free up the callers datum (optional)
Return Value:
None.
--*/
{
if (GTable == NULL) {
return NULL;
}
//
// Empty the table
//
GTabEmptyTable(GTable, CallerFree);
DeleteCriticalSection(&GTable->Critical);
return FrsFreeType(GTable);
}
PVOID
GTabLookupNoLock(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Find the entry in the table.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
Data for an entry or NULL
--*/
{
PVOID Data;
PGEN_ENTRY Entry; // entry in table
GEN_ENTRY Key; // Search key
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for any table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Search the table
//
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
Data = (Entry) ? Entry->Data : NULL;
return Data;
}
PVOID
GTabLookup(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Find the data for an entry in the table.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
Data for an entry or NULL
--*/
{
PVOID Data;
PGEN_ENTRY Entry; // entry in table
GEN_ENTRY Key; // Search key
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for any table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Search the table
//
GTabLockTable(GTable);
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
Data = (Entry) ? Entry->Data : NULL;
GTabUnLockTable(GTable);
return Data;
}
BOOL
GTabIsEntryPresent(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Find the entry in the table and return TRUE if found.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
Boolean
--*/
{
PVOID Data;
PGEN_ENTRY Entry; // entry in table
GEN_ENTRY Key; // Search key
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for any table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Search the table
//
GTabLockTable(GTable);
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
GTabUnLockTable(GTable);
return (Entry != NULL);
}
PVOID
GTabLookupTableString(
IN PGEN_TABLE GTable,
IN PWCHAR Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Find the data for an entry in the table that is indexed by string.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
Data for an entry or NULL
--*/
{
PVOID Data;
PGEN_ENTRY Entry; // entry in table
GEN_ENTRY Key; // Search key
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for any table
//
Key.Key1 = (GUID *)Key1;
Key.Key2 = Key2;
//
// Search the table
//
GTabLockTable(GTable);
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
Data = (Entry) ? Entry->Data : NULL;
GTabUnLockTable(GTable);
return Data;
}
PGEN_ENTRY
GTabLookupEntryNoLock(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Find the data for an entry in the table.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
Data for an entry or NULL
--*/
{
PGEN_ENTRY Entry; // entry in table
GEN_ENTRY Key; // Search key
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for any table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Search the table
//
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
return Entry;
}
PGEN_ENTRY
GTabNextEntryNoLock(
PGEN_TABLE GTable,
PVOID *Key
)
/*++
Routine Description:
Return the entry for Key in GTable. The caller is responsible for
insuring synchronization.
Arguments:
GTable - frs generic table
Key - NULL on first call
Return Value:
The address of an entry in the table or NULL.
--*/
{
PGEN_ENTRY Entry;
//
// Return the entry's address
//
Entry = (PVOID)RtlEnumerateGenericTableWithoutSplaying(&GTable->Table, Key);
return Entry;
}
PVOID
GTabNextDatumNoLock(
PGEN_TABLE GTable,
PVOID *Key
)
/*++
Routine Description:
Return the data for the entry for Key in GTable.
Caller acquires the table lock.
Arguments:
GTable - frs generic table
Key - NULL on first call
GetData - return the entry or the data for the entry
Return Value:
The address of an entry in the table or NULL.
--*/
{
PVOID Data;
PGEN_ENTRY Entry;
//
// Return the address of the entry's data
//
Entry = GTabNextEntryNoLock(GTable, Key);
Data = (Entry) ? Entry->Data : NULL;
return Data;
}
PVOID
GTabNextDatum(
PGEN_TABLE GTable,
PVOID *Key
)
/*++
Routine Description:
Return the data for the entry for Key in GTable.
Arguments:
GTable - frs generic table
Key - NULL on first call
GetData - return the entry or the data for the entry
Return Value:
The address of an entry in the table or NULL.
--*/
{
PVOID Data;
PGEN_ENTRY Entry;
//
// Return the address of the entry's data
//
GTabLockTable(GTable);
Entry = GTabNextEntryNoLock(GTable, Key);
Data = (Entry) ? Entry->Data : NULL;
GTabUnLockTable(GTable);
return Data;
}
DWORD
GTabNumberInTable(
PGEN_TABLE GTable
)
/*++
Routine Description:
Return the number of entries in a table.
Arguments:
GTable - frs generic table
Return Value:
Number of entries in the table.
--*/
{
if (GTable) {
return RtlNumberGenericTableElements(&GTable->Table);
} else {
return 0;
}
}
PVOID
GTabInsertUniqueEntry(
IN PGEN_TABLE GTable,
IN PVOID NewData,
IN PVOID Key1,
IN PVOID Key2
)
/*++
Routine Description:
Insert an entry into the table. If a duplicate is found then
return the original entry. Do not insert in that case.
Arguments:
GTable - frs generic table
NewData - data for the entry to insert
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
NULL if the entry was successfully inserted in the table.
Pointer to the data from old entry if a collision is found.
--*/
{
PGEN_ENTRY OldEntry; // Existing entry in the table
BOOLEAN IsNew; // TRUE if insert found existing entry
GEN_ENTRY NewEntry; // new entry to insert.
PGEN_ENTRY DupEntry; // Newly allocated table entry for duplicate.
//
// Init the new entry. Have to typecast here becasue the GEN_ENTRY expects a GUID* and PWCHAR.
//
NewEntry.Data = NewData;
NewEntry.Key1 = (GUID*)Key1;
NewEntry.Key2 = (PWCHAR)Key2;
NewEntry.Dups = NULL;
//
// Lock the table and Insert the entry
//
GTabLockTable(GTable);
OldEntry = RtlInsertElementGenericTable(&GTable->Table,
&NewEntry,
sizeof(NewEntry),
&IsNew);
GTabUnLockTable(GTable);
if (!IsNew) {
return OldEntry;
}
return NULL;
}
VOID
GTabInsertEntry(
IN PGEN_TABLE GTable,
IN PVOID NewData,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Insert an entry into the table. Duplicates are simply linked
to the current entry.
Arguments:
GTable - frs generic table
NewData - data for the entry to insert
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
None.
--*/
{
PGEN_ENTRY OldEntry; // Existing entry in the table
BOOLEAN IsNew; // TRUE if insert found existing entry
GEN_ENTRY NewEntry; // new entry to insert.
PGEN_ENTRY DupEntry; // Newly allocated table entry for duplicate.
//
// Init the new entry.
//
NewEntry.Data = NewData;
NewEntry.Key1 = Key1;
NewEntry.Key2 = Key2;
NewEntry.Dups = NULL;
//
// Lock the table and Insert the entry
//
GTabLockTable(GTable);
OldEntry = RtlInsertElementGenericTable(&GTable->Table,
&NewEntry,
sizeof(NewEntry),
&IsNew);
if (!IsNew) {
//
// Duplicate entry; add to list
//
DupEntry = FrsAlloc(sizeof(GEN_ENTRY));
CopyMemory(DupEntry, &NewEntry, sizeof(NewEntry));
DupEntry->Dups = OldEntry->Dups;
OldEntry->Dups = DupEntry;
}
GTabUnLockTable(GTable);
}
VOID
GTabInsertEntryNoLock(
IN PGEN_TABLE GTable,
IN PVOID NewData,
IN GUID *Key1,
IN PWCHAR Key2
)
/*++
Routine Description:
Insert an entry into the table. Duplicates are simply linked
to the current entry.
Caller acquires the table lock.
Arguments:
GTable - frs generic table
NewData - data for the entry to insert
Key1 - primary key
Key2 - secondary key (may be NULL)
Return Value:
None.
--*/
{
PGEN_ENTRY OldEntry; // Existing entry in the table
BOOLEAN IsNew; // TRUE if insert found existing entry
GEN_ENTRY NewEntry; // new entry to insert.
PGEN_ENTRY DupEntry; // Newly allocated table entry for duplicate.
//
// Init the new entry.
//
NewEntry.Data = NewData;
NewEntry.Key1 = Key1;
NewEntry.Key2 = Key2;
NewEntry.Dups = NULL;
//
// Lock the table and Insert the entry
//
OldEntry = RtlInsertElementGenericTable(&GTable->Table,
&NewEntry,
sizeof(NewEntry),
&IsNew);
if (!IsNew) {
//
// Duplicate entry; add to list
//
DupEntry = FrsAlloc(sizeof(GEN_ENTRY));
CopyMemory(DupEntry, &NewEntry, sizeof(NewEntry));
DupEntry->Dups = OldEntry->Dups;
OldEntry->Dups = DupEntry;
}
}
VOID
GTabDelete(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2,
IN PVOID (*CallerFree)(PVOID)
)
/*++
Routine Description:
Delete the entry in the table.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
CallerFree - The free routine to use to free up the callers datum (optional)
Return Value:
None.
--*/
{
GEN_ENTRY Key; // Search key
PGEN_ENTRY Entry; // entry in table
PGEN_ENTRY Dup; // dup entry in table
PVOID Data;
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for either table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Find the entry
//
GTabLockTable(GTable);
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
if (Entry == NULL) {
goto out;
}
//
// Delete the dups
//
while (Dup = Entry->Dups) {
Entry->Dups = Dup->Dups;
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Dup->Data);
}
Dup = FrsFree(Dup);
}
//
// Delete entry
//
Data = Entry->Data;
RtlDeleteElementGenericTable(&GTable->Table, Entry);
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Data);
}
out:
GTabUnLockTable(GTable);
}
VOID
GTabDeleteNoLock(
IN PGEN_TABLE GTable,
IN GUID *Key1,
IN PWCHAR Key2,
IN PVOID (*CallerFree)(PVOID)
)
/*++
Routine Description:
Delete the entry in the table.
Arguments:
GTable - frs generic table
Key1 - primary key
Key2 - secondary key (may be NULL)
CallerFree - The free routine to use to free up the callers datum (optional)
Return Value:
None.
--*/
{
GEN_ENTRY Key; // Search key
PGEN_ENTRY Entry; // entry in table
PGEN_ENTRY Dup; // dup entry in table
PVOID Data;
FRS_ASSERT(Key1);
//
// Set up a search key that is suitable for either table
//
Key.Key1 = Key1;
Key.Key2 = Key2;
//
// Find the entry
//
Entry = (PVOID)RtlLookupElementGenericTable(&GTable->Table, &Key);
if (Entry == NULL) {
return;
}
//
// Delete the dups
//
while (Dup = Entry->Dups) {
Entry->Dups = Dup->Dups;
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Dup->Data);
}
Dup = FrsFree(Dup);
}
//
// Delete entry
//
Data = Entry->Data;
RtlDeleteElementGenericTable(&GTable->Table, Entry);
if (CallerFree) {
//
// Free up the callers Datum
//
(*CallerFree)(Data);
}
}
VOID
GTabPrintTable(
IN PGEN_TABLE GTable
)
/*++
Routine Description:
Print the table and all of its dups.
Arguments:
GTable - frs generic table
Return Value:
None.
--*/
{
PGEN_ENTRY Entry;
PGEN_ENTRY Dup;
PVOID Key;
CHAR Guid[GUID_CHAR_LEN + 1];
//
// print the entries
//
GTabLockTable(GTable);
Key = NULL;
while (Entry = GTabNextEntryNoLock(GTable, &Key)) {
GuidToStr(Entry->Key1, &Guid[0]);
if (Entry->Key2) {
DPRINT3(0, "\t0x%x %s %ws\n", Entry->Data, Guid, Entry->Key2);
} else {
DPRINT2(0, "\t0x%x %s NULL\n", Entry->Data, Guid);
}
for (Dup = Entry->Dups; Dup; Dup = Dup->Dups) {
GuidToStr(Entry->Key1, &Guid[0]);
if (Dup->Key2) {
DPRINT3(0, "\t0x%x %s %ws\n", Dup->Data, Guid, Dup->Key2);
} else {
DPRINT2(0, "\t0x%x %s NULL\n", Dup->Data, Guid);
}
}
}
GTabUnLockTable(GTable);
}
Reference in a new issue Copy permalink