prefxsup.c

windows 2000中的UDF文件系统的驱动程序.只有读的功能,不支持未关闭的盘片.只支持UDF2.0以下版本,不支持VAT格式的UDF.

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    PrefxSup.c

Abstract:

    This module implements the Udfs Prefix support routines

Author:

    Dan Lovinger    [DanLo]     8-Oct-1996

Revision History:

--*/

#include "UdfProcs.h"

//
//  The Bug check file id for this module
//

#define BugCheckFileId                   (UDFS_BUG_CHECK_PREFXSUP)

//
//  The local debug trace level
//

#define Dbg                              (UDFS_DEBUG_LEVEL_READ)

//
//  Local support routines.
//

PLCB
UdfFindNameLink (
    IN PIRP_CONTEXT IrpContext,
    IN PRTL_SPLAY_LINKS *RootNode,
    IN PUNICODE_STRING Name
    );

BOOLEAN
UdfInsertNameLink (
    IN PIRP_CONTEXT IrpContext,
    IN PRTL_SPLAY_LINKS *RootNode,
    IN PLCB NameLink
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, UdfFindNameLink)
#pragma alloc_text(PAGE, UdfFindPrefix)
#pragma alloc_text(PAGE, UdfInitializeLcbFromDirContext)
#pragma alloc_text(PAGE, UdfInsertNameLink)
#pragma alloc_text(PAGE, UdfInsertPrefix)
#pragma alloc_text(PAGE, UdfRemovePrefix)
#endif


PLCB
UdfInsertPrefix (
    IN PIRP_CONTEXT IrpContext,
    IN PFCB Fcb,
    IN PUNICODE_STRING Name,
    IN BOOLEAN ShortNameMatch,
    IN BOOLEAN IgnoreCase,
    IN PFCB ParentFcb
    )

/*++

Routine Description:

    This routine inserts an Lcb linking the two Fcbs together.

Arguments:

    Fcb - This is the Fcb whose name is being inserted into the tree.

    Name - This is the name for the component.
    
    ShortNameMatch - Indicates whether this name was found on an explicit 8.3 search

    IgnoreCase - Indicates if we should insert into the case-insensitive tree.

    ParentFcb - This is the ParentFcb.  The prefix tree is attached to this.

Return Value:

    PLCB - the Lcb inserted.

--*/

{
    PLCB Lcb;
    PRTL_SPLAY_LINKS *TreeRoot;
    PLIST_ENTRY ListLinks;
    ULONG Flags;

    PWCHAR NameBuffer;

    PAGED_CODE();

    //
    //  Check inputs.
    //

    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );

    ASSERT_EXCLUSIVE_FCB( Fcb );
    ASSERT_EXCLUSIVE_FCB( ParentFcb );
    ASSERT_FCB_INDEX( ParentFcb );

    //
    //  It must be the case that an index Fcb is only referenced by a single index.  Now
    //  we walk the child's Lcb queue to insure that if any prefixes have already been
    //  inserted, they all refer to the index Fcb we are linking to.  This is the only way
    //  we can detect directory cross-linkage.
    //

    if (SafeNodeType( Fcb ) == UDFS_NTC_FCB_INDEX) {

        for (ListLinks = Fcb->ParentLcbQueue.Flink;
             ListLinks != &Fcb->ParentLcbQueue;
             ListLinks = ListLinks->Flink) {

            Lcb = CONTAINING_RECORD( ListLinks, LCB, ChildFcbLinks );

            if (Lcb->ParentFcb != ParentFcb) {

                UdfRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
            }
        }
    }
    
    //
    //  Capture the separate cases.
    //

    if (IgnoreCase) {

        TreeRoot = &ParentFcb->IgnoreCaseRoot;
        Flags = LCB_FLAG_IGNORE_CASE;

    } else {

        TreeRoot = &ParentFcb->ExactCaseRoot;
        Flags = 0;
    }

    if (ShortNameMatch) {

        SetFlag( Flags, LCB_FLAG_SHORT_NAME );
    }

    //
    //  Allocate space for the Lcb.
    //

    if ( sizeof( LCB ) + Name->Length > SIZEOF_LOOKASIDE_LCB ) {
    
        Lcb = FsRtlAllocatePoolWithTag( UdfPagedPool,
                                        sizeof( LCB ) + Name->Length,
                                        TAG_LCB );

        SetFlag( Flags, LCB_FLAG_POOL_ALLOCATED );

    } else {

        Lcb = ExAllocateFromPagedLookasideList( &UdfLcbLookasideList );
    }

    //
    //  Set the type and size.
    //

    Lcb->NodeTypeCode = UDFS_NTC_LCB;
    Lcb->NodeByteSize = sizeof( LCB ) + Name->Length;

    //
    //  Initialize the name-based file attributes.
    //
    
    Lcb->FileAttributes = 0;
    
    //
    //  Set up the filename in the Lcb.
    //

    Lcb->FileName.Length =
    Lcb->FileName.MaximumLength = Name->Length;

    Lcb->FileName.Buffer = Add2Ptr( Lcb, sizeof( LCB ), PWCHAR );

    RtlCopyMemory( Lcb->FileName.Buffer,
                   Name->Buffer,
                   Name->Length );
    
    //
    //  Insert the Lcb into the prefix tree.
    //
    
    Lcb->Flags = Flags;
    
    if (!UdfInsertNameLink( IrpContext,
                            TreeRoot,
                            Lcb )) {

        //
        //  This will very rarely occur.
        //

        UdfFreePool( &Lcb );

        Lcb = UdfFindNameLink( IrpContext,
                               TreeRoot,
                               Name );

        if (Lcb == NULL) {

            //
            //  Even worse.
            //

            UdfRaiseStatus( IrpContext, STATUS_DRIVER_INTERNAL_ERROR );
        }

        return Lcb;
    }

    //
    //  Link the Fcbs together through the Lcb.
    //

    Lcb->ParentFcb = ParentFcb;
    Lcb->ChildFcb = Fcb;

    InsertHeadList( &ParentFcb->ChildLcbQueue, &Lcb->ParentFcbLinks );
    InsertHeadList( &Fcb->ParentLcbQueue, &Lcb->ChildFcbLinks );

    //
    //  Initialize the reference count.
    //

    Lcb->Reference = 0;
    
    return Lcb;
}


VOID
UdfRemovePrefix (
    IN PIRP_CONTEXT IrpContext,
    IN PLCB Lcb
    )

/*++

Routine Description:

    This routine is called to remove a given prefix of an Fcb.

Arguments:

    Lcb - the prefix being removed.

Return Value:

    None

--*/

{
    PAGED_CODE();

    //
    //  Check inputs.
    //

    ASSERT_IRP_CONTEXT( IrpContext );
    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 (FlagOn( Lcb->Flags, LCB_FLAG_IGNORE_CASE )) {

        Lcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Lcb->Links );
    
    } else {

        Lcb->ParentFcb->ExactCaseRoot = RtlDelete( &Lcb->Links );
    }

    if (FlagOn( Lcb->Flags, LCB_FLAG_POOL_ALLOCATED )) {

        ExFreePool( Lcb );

    } else {

        ExFreeToPagedLookasideList( &UdfLcbLookasideList, Lcb );
    }
    
    return;
}


PLCB
UdfFindPrefix (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PFCB *CurrentFcb,
    IN OUT PUNICODE_STRING RemainingName,
    IN BOOLEAN IgnoreCase
    )

/*++

Routine Description:

    This routine begins from the given CurrentFcb and walks through all of
    components of the name looking for the longest match in the prefix
    splay trees.  The search is relative to the starting Fcb so the
    full name may not begin with a '\'.  On return this routine will
    update Current Fcb with the lowest point it has travelled in the
    tree.  It will also hold only that resource on return and it must
    hold that resource.

Arguments:

    CurrentFcb - Address to store the lowest Fcb we find on this search.
        On return we will have acquired this Fcb.  On entry this is the
        Fcb to examine.
        
    RemainingName - Supplies a buffer to store the exact case of the name being
        searched for.  Initially will contain the upcase name based on the
        IgnoreCase flag.

    IgnoreCase - Indicates if we are doing a case-insensitive compare.

Return Value:

    The Lcb used to find the current Fcb, NULL if we didn't find any prefix
    Fcbs.

--*/

{
    UNICODE_STRING LocalRemainingName;
    UNICODE_STRING FinalName;

    PLCB NameLink;
    PLCB CurrentLcb = NULL;

    PAGED_CODE();

    //
    //  Check inputs.
    //

    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( *CurrentFcb );
    ASSERT_EXCLUSIVE_FCB( *CurrentFcb );

    //
    //  Make a local copy of the input strings.
    //

    LocalRemainingName = *RemainingName;

    //
    //  Loop until we find the longest matching prefix.
    //

    while (TRUE) {

        //
        //  If there are no characters left or we are not at an IndexFcb then
        //  return immediately.
        //

        if ((LocalRemainingName.Length == 0) ||
            (SafeNodeType( *CurrentFcb ) != UDFS_NTC_FCB_INDEX)) {

            return CurrentLcb;
        }

        //
        //  Split off the next component from the name.
        //