/*
* @implemented
*/
BOOLEAN
NTAPI
RtlDeleteElementGenericTable(IN PRTL_GENERIC_TABLE Table,
IN PVOID Buffer)
{
PRTL_SPLAY_LINKS NodeOrParent;
TABLE_SEARCH_RESULT Result;
/* Get the splay links and table search result immediately */
Result = RtlpFindGenericTableNodeOrParent(Table, Buffer, &NodeOrParent);
if (Result != TableFoundNode)
{
/* Nothing to delete */
return FALSE;
}
/* Delete the entry */
Table->TableRoot = RtlDelete(NodeOrParent);
RemoveEntryList(&((PTABLE_ENTRY_HEADER)NodeOrParent)->ListEntry);
/* Update accounting data */
Table->NumberGenericTableElements--;
Table->WhichOrderedElement = 0;
Table->OrderedPointer = &Table->InsertOrderList;
/* Free the entry */
Table->FreeRoutine(Table, NodeOrParent);
return TRUE;
}
VOID
xixfs_FCBTLBRemovePrefix (
IN BOOLEAN CanWait,
IN PXIXFS_LCB Lcb
)
{
PAGED_CODE();
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CLOSE| DEBUG_TARGET_FCB),
("Enter xixfs_FCBTLBRemovePrefix \n" ));
//
// Check inputs.
//
ASSERT_LCB( Lcb );
//
// Check the acquisition of the two Fcbs.
//
ASSERT_EXCLUSIVE_FCB_OR_VCB( Lcb->ParentFcb );
ASSERT_EXCLUSIVE_FCB_OR_VCB( Lcb->ChildFcb );
//
// Now remove the linkage and delete the Lcb.
//
RemoveEntryList( &Lcb->ParentFcbLinks );
RemoveEntryList( &Lcb->ChildFcbLinks );
if(XIXCORE_TEST_FLAGS(Lcb->LCBFlags, XIFSD_LCB_STATE_IGNORE_CASE_SET)){
Lcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Lcb->IgnoreCaseLinks);
}
Lcb->ParentFcb->Root = RtlDelete( &Lcb->Links );
xixfs_FreeLCB(Lcb);
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CLOSE| DEBUG_TARGET_FCB),
("Exit xixfs_FCBTLBRemovePrefix \n" ));
return;
}
VOID
NTAPI
FatRemoveNames(IN PFAT_IRP_CONTEXT IrpContext,
IN PFCB Fcb)
{
PRTL_SPLAY_LINKS RootNew;
PFCB Parent;
/* Reference the parent for simplicity */
Parent = Fcb->ParentFcb;
/* If this FCB hasn't been added to splay trees - just return */
if (!FlagOn( Fcb->State, FCB_STATE_HAS_NAMES ))
return;
/* Delete the short name link */
RootNew = RtlDelete(&Fcb->ShortName.Links);
/* Set the new root */
Parent->Dcb.SplayLinksAnsi = RootNew;
/* Deal with a unicode name if it exists */
if (FlagOn( Fcb->State, FCB_STATE_HAS_UNICODE_NAME ))
{
/* Delete the long unicode name link */
RootNew = RtlDelete(&Fcb->LongName.Links);
/* Set the new root */
Parent->Dcb.SplayLinksUnicode = RootNew;
/* Free the long name string's buffer*/
RtlFreeUnicodeString(&Fcb->LongName.Name.String);
/* Clear the "has unicode name" flag */
ClearFlag(Fcb->State, FCB_STATE_HAS_UNICODE_NAME);
}
/* This FCB has no names added to splay trees now */
ClearFlag(Fcb->State, FCB_STATE_HAS_NAMES);
}
__inline VOID
FsRtlRemoveNodeFromTunnel (
IN PTUNNEL Cache,
IN PTUNNEL_NODE Node,
IN PLIST_ENTRY FreePoolList,
IN PBOOLEAN Splay OPTIONAL
)
/*++
Routine Description:
Performs the common work of deleting a node from a tunnel cache. Pool memory
is not deleted immediately but is saved aside on a list for deletion later
by the calling routine.
Arguments:
Cache - the tunnel cache the node is in
Node - the node being removed
FreePoolList - an initialized list to take the node if it was allocated from
pool
Splay - an optional flag to indicate whether the tree should be splayed on
the delete. Set to FALSE if splaying was performed.
Return Value:
None.
--*/
{
if (Splay && *Splay) {
Cache->Cache = RtlDelete(&Node->CacheLinks);
*Splay = FALSE;
} else {
RtlDeleteNoSplay(&Node->CacheLinks, &Cache->Cache);
}
RemoveEntryList(&Node->ListLinks);
Cache->NumEntries--;
FsRtlFreeTunnelNode(Node, FreePoolList);
}
VOID
FatRemoveNames (
IN PIRP_CONTEXT IrpContext,
IN PFCB Fcb
)
/*++
Routine Description:
This routine will remove the short name and any long names associated
with the files from their repsective splay tree.
Arguments:
Name - Supplies the Fcb to process.
Return Value:
None.
--*/
{
PDCB Parent;
PRTL_SPLAY_LINKS NewRoot;
PAGED_CODE();
Parent = Fcb->ParentDcb;
//
// We used to assert this condition, but it really isn't good. If
// someone rapidly renames a directory multiple times and we can't
// flush the lower fcbs fast enough (that didn't go away synch.)
// well, well hit some of them again.
//
// ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE ));
//
if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
//
// Delete the node short name.
//
NewRoot = RtlDelete(&Fcb->ShortName.Links);
Parent->Specific.Dcb.RootOemNode = NewRoot;
//
// Now check for the presence of long name and delete it.
//
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME )) {
NewRoot = RtlDelete(&Fcb->LongName.Oem.Links);
Parent->Specific.Dcb.RootOemNode = NewRoot;
RtlFreeOemString( &Fcb->LongName.Oem.Name.Oem );
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
}
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME )) {
NewRoot = RtlDelete(&Fcb->LongName.Unicode.Links);
Parent->Specific.Dcb.RootUnicodeNode = NewRoot;
RtlFreeUnicodeString( &Fcb->LongName.Unicode.Name.Unicode );
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME );
}
ClearFlag( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE );
}
return;
}
VOID
FatRemoveNames (
IN PIRP_CONTEXT IrpContext,
IN PFCB Fcb
)
/*++
Routine Description:
This routine will remove the short name and any long names associated
with the files from their repsective splay tree.
Arguments:
Name - Supplies the Fcb to process.
Return Value:
None.
--*/
{
PDCB Parent;
PRTL_SPLAY_LINKS NewRoot;
Parent = Fcb->ParentDcb;
ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE ));
if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
//
// Delete the node short name.
//
NewRoot = RtlDelete(&Fcb->ShortName.Links);
Parent->Specific.Dcb.RootOemNode = NewRoot;
//
// Now check for the presence of long name and delete it.
//
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME )) {
NewRoot = RtlDelete(&Fcb->LongName.Oem.Links);
Parent->Specific.Dcb.RootOemNode = NewRoot;
FatFreeOemString( &Fcb->LongName.Oem.Name.Oem );
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
}
if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME )) {
NewRoot = RtlDelete(&Fcb->LongName.Unicode.Links);
Parent->Specific.Dcb.RootUnicodeNode = NewRoot;
RtlFreeUnicodeString( &Fcb->LongName.Unicode.Name.Unicode );
ClearFlag( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME );
}
ClearFlag( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE );
}
return;
}
PTREE_NODE
TreeInsert (
IN PTREE_NODE Root,
IN PTREE_NODE Node
)
{
PRTL_SPLAY_LINKS Temp;
if (Root == NULL) {
//DbgPrint("Add as root %u\n", Node->Data);
return Node;
}
while (TRUE) {
if (Root->Data == Node->Data) {
//DbgPrint("Delete %u\n", Node->Data);
Temp = RtlDelete(&Root->Links);
if (Temp == NULL) {
return NULL;
} else {
return CONTAINING_RECORD(Temp, TREE_NODE, Links);
}
}
if (Root->Data < Node->Data) {
//
// Go right
//
if (RtlRightChild(&Root->Links) == NULL) {
//DbgPrint("Add as right child %u\n", Node->Data);
RtlInsertAsRightChild(&Root->Links, &Node->Links);
return CONTAINING_RECORD(RtlSplay(&Node->Links), TREE_NODE, Links);
} else {
Root = CONTAINING_RECORD(RtlRightChild(&Root->Links), TREE_NODE, Links);
}
} else {
//
// Go Left
//
if (RtlLeftChild(&Root->Links) == NULL) {
//DbgPrint("Add as left child %u\n", Node->Data);
RtlInsertAsLeftChild(&Root->Links, &Node->Links);
return CONTAINING_RECORD(RtlSplay(&Node->Links), TREE_NODE, Links);
} else {
Root = CONTAINING_RECORD(RtlLeftChild(&Root->Links), TREE_NODE, Links);
}
}
}
}
VOID
CdRemovePrefix (
_In_ PIRP_CONTEXT IrpContext,
_Inout_ PFCB Fcb
)
/*++
Routine Description:
This routine is called to remove all of the previx entries of a
given Fcb from its parent Fcb.
Arguments:
Fcb - Fcb whose entries are to be removed.
Return Value:
None
--*/
{
PAGED_CODE();
UNREFERENCED_PARAMETER( IrpContext );
//
// Start with the short name prefix entry.
//
if (Fcb->ShortNamePrefix != NULL) {
if (FlagOn( Fcb->ShortNamePrefix->PrefixFlags, PREFIX_FLAG_IGNORE_CASE_IN_TREE )) {
Fcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Fcb->ShortNamePrefix->IgnoreCaseName.Links );
}
if (FlagOn( Fcb->ShortNamePrefix->PrefixFlags, PREFIX_FLAG_EXACT_CASE_IN_TREE )) {
Fcb->ParentFcb->ExactCaseRoot = RtlDelete( &Fcb->ShortNamePrefix->ExactCaseName.Links );
}
ClearFlag( Fcb->ShortNamePrefix->PrefixFlags,
PREFIX_FLAG_IGNORE_CASE_IN_TREE | PREFIX_FLAG_EXACT_CASE_IN_TREE );
}
//
// Now do the long name prefix entries.
//
if (FlagOn( Fcb->FileNamePrefix.PrefixFlags, PREFIX_FLAG_IGNORE_CASE_IN_TREE )) {
Fcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Fcb->FileNamePrefix.IgnoreCaseName.Links );
}
if (FlagOn( Fcb->FileNamePrefix.PrefixFlags, PREFIX_FLAG_EXACT_CASE_IN_TREE )) {
Fcb->ParentFcb->ExactCaseRoot = RtlDelete( &Fcb->FileNamePrefix.ExactCaseName.Links );
}
ClearFlag( Fcb->FileNamePrefix.PrefixFlags,
PREFIX_FLAG_IGNORE_CASE_IN_TREE | PREFIX_FLAG_EXACT_CASE_IN_TREE );
//
// Deallocate any buffer we may have allocated.
//
if ((Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer != (PWCHAR) &Fcb->FileNamePrefix.FileNameBuffer) &&
(Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer != NULL)) {
CdFreePool( &Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer );
Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer = NULL;
}
return;
}
BOOLEAN
RtlDeleteElementGenericTable (
IN PRTL_GENERIC_TABLE Table,
IN PVOID Buffer
)
/*++
Routine Description:
The function DeleteElementGenericTable will find and delete an element
from a generic table. If the element is located and deleted the return
value is TRUE, otherwise if the element is not located the return value
is FALSE. The user supplied input buffer is only used as a key in
locating the element in the table.
Arguments:
Table - Pointer to the table in which to (possibly) delete the
memory accessed by the key buffer.
Buffer - Passed to the user comparasion routine. Its contents are
up to the user but one could imagine that it contains some
sort of key value.
Return Value:
BOOLEAN - If the table contained the key then true, otherwise false.
--*/
{
//
// Holds a pointer to the node in the table or what would be the
// parent of the node.
//
PRTL_SPLAY_LINKS NodeOrParent;
//
// Holds the result of the table lookup.
//
SEARCH_RESULT Lookup;
Lookup = FindNodeOrParent(
Table,
Buffer,
&NodeOrParent
);
if ((Lookup == EmptyTree) || (Lookup != FoundNode)) {
return FALSE;
} else {
//
// Delete the node from the splay tree.
//
Table->TableRoot = RtlDelete(NodeOrParent);
//
// Delete the element from the linked list.
//
RemoveEntryList((PLIST_ENTRY)((PVOID)(NodeOrParent+1)));
Table->NumberGenericTableElements--;
Table->WhichOrderedElement = 0;
Table->OrderedPointer = &Table->InsertOrderList;
//
// The node has been deleted from the splay table.
// Now give the node to the user deletion routine.
// NOTE: We are giving the deletion routine a pointer
// to the splay links rather then the user data. It
// is assumed that the deallocation is rather stupid.
//
Table->FreeRoutine(Table,NodeOrParent);
return TRUE;
}
}
/*
* @implemented
*/
VOID
NTAPI
RtlRemoveUnicodePrefix(PUNICODE_PREFIX_TABLE PrefixTable,
PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry)
{
PUNICODE_PREFIX_TABLE_ENTRY Entry, RefEntry, NewEntry;
PRTL_SPLAY_LINKS SplayLinks;
DPRINT("RtlRemoveUnicodePrefix(): Table %p, TableEntry %p\n",
PrefixTable, PrefixTableEntry);
/* Erase the last entry */
PrefixTable->LastNextEntry = NULL;
/* Check if this was a Case Match Entry */
if (PrefixTableEntry->NodeTypeCode == PFX_NTC_CASE_MATCH)
{
/* Get the case match entry */
Entry = PrefixTableEntry->CaseMatch;
/* Now loop until we find one referencing what the caller sent */
while (Entry->CaseMatch != PrefixTableEntry) Entry = Entry->CaseMatch;
/* We found the entry that was sent, link them to delete this entry */
Entry->CaseMatch = PrefixTableEntry->CaseMatch;
}
else if ((PrefixTableEntry->NodeTypeCode == PFX_NTC_ROOT) ||
(PrefixTableEntry->NodeTypeCode == PFX_NTC_CHILD))
{
/* Check if this entry is a case match */
if (PrefixTableEntry->CaseMatch != PrefixTableEntry)
{
/* Get the case match entry */
Entry = PrefixTableEntry->CaseMatch;
/* Now loop until we find one referencing what the caller sent */
while (Entry->CaseMatch != PrefixTableEntry) Entry = Entry->CaseMatch;
/* We found the entry that was sent, link them to delete this entry */
Entry->CaseMatch = PrefixTableEntry->CaseMatch;
/* Copy the data */
Entry->NodeTypeCode = PrefixTableEntry->NodeTypeCode;
Entry->NextPrefixTree = PrefixTableEntry->NextPrefixTree;
Entry->Links = PrefixTableEntry->Links;
/* Now check if we are a root entry */
if (RtlIsRoot(&PrefixTableEntry->Links))
{
/* We are, so make this entry root as well */
Entry->Links.Parent = &Entry->Links;
/* Find the entry referencing us */
RefEntry = Entry->NextPrefixTree;
while (RefEntry->NextPrefixTree != Entry)
{
/* Not this one, move to the next entry */
RefEntry = RefEntry->NextPrefixTree;
}
/* Link them to us now */
RefEntry->NextPrefixTree = Entry;
}
else if (RtlIsLeftChild(&PrefixTableEntry->Links))
{
/* We were the left child, so make us as well */
RtlParent(&PrefixTableEntry->Links)->LeftChild = &Entry->Links;
}
else
{
/* We were the right child, so make us as well */
RtlParent(&PrefixTableEntry->Links)->RightChild = &Entry->Links;
}
/* Check if we have a left child */
if (RtlLeftChild(&Entry->Links))
{
/* Update its parent link */
RtlLeftChild(&Entry->Links)->Parent = &Entry->Links;
}
/* Check if we have a right child */
if (RtlRightChild(&Entry->Links))
{
/* Update its parent link */
RtlRightChild(&Entry->Links)->Parent = &Entry->Links;
}
}
else
{
/* It's not a case match, so we'll delete the actual entry */
SplayLinks = &PrefixTableEntry->Links;
/* Find the root entry */
while (!RtlIsRoot(SplayLinks)) SplayLinks = RtlParent(SplayLinks);
Entry = CONTAINING_RECORD(SplayLinks,
UNICODE_PREFIX_TABLE_ENTRY,
Links);
/* Delete the entry and check if the whole tree is gone */
SplayLinks = RtlDelete(&PrefixTableEntry->Links);
if (!SplayLinks)
{
/* The tree is also gone now, find the entry referencing us */
RefEntry = Entry->NextPrefixTree;
while (RefEntry->NextPrefixTree != Entry)
{
/* Not this one, move to the next entry */
RefEntry = RefEntry->NextPrefixTree;
}
/* Link them so this entry stops being referenced */
RefEntry->NextPrefixTree = Entry->NextPrefixTree;
}
else if (&Entry->Links != SplayLinks)
{
/* The tree is still here, but we got moved to a new one */
NewEntry = CONTAINING_RECORD(SplayLinks,
UNICODE_PREFIX_TABLE_ENTRY,
Links);
/* Find the entry referencing us */
RefEntry = Entry->NextPrefixTree;
while (RefEntry->NextPrefixTree != Entry)
{
/* Not this one, move to the next entry */
RefEntry = RefEntry->NextPrefixTree;
}
/* Since we got moved, make us the new root entry */
NewEntry->NodeTypeCode = PFX_NTC_ROOT;
/* Link us with the entry referencing the old root */
RefEntry->NextPrefixTree = NewEntry;
/* And link us with the old tree */
NewEntry->NextPrefixTree = Entry->NextPrefixTree;
/* Set the old tree as a child */
Entry->NodeTypeCode = PFX_NTC_CHILD;
Entry->NextPrefixTree = NULL;
}
}
}
}
