dirsup.c File Reference

#include "fatprocs.h"

Include dependency graph for dirsup.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_DIRSUP)
#define	Dbg   (DEBUG_TRACE_DIRSUP)
#define	FatConstructDot(IRPCONTEXT, DCB, PARENT, DIRENT)
#define	FatConstructDotDot(IRPCONTEXT, DCB, PARENT, DIRENT)
#define	FatConstructEndDirent(IRPCONTEXT, DIRENT)   NOTHING
#define	FatReadDirent(IRPCONTEXT, DCB, VBO, BCB, DIRENT, STATUS)

Functions
UCHAR	FatComputeLfnChecksum (PDIRENT Dirent)
	_Requires_lock_held_ (_Global_critical_region_)
VOID	FatTunnelFcbOrDcb (IN PFCB FcbOrDcb, IN PCCB Ccb OPTIONAL)
VOID	FatConstructDirent (IN PIRP_CONTEXT IrpContext, IN OUT PDIRENT Dirent, IN POEM_STRING FileName, IN BOOLEAN ComponentReallyLowercase, IN BOOLEAN ExtensionReallyLowercase, IN PUNICODE_STRING Lfn OPTIONAL, IN USHORT Attributes, IN BOOLEAN ZeroAndSetTimeFields, IN PLARGE_INTEGER SetCreationTime OPTIONAL)
VOID	FatConstructLabelDirent (IN PIRP_CONTEXT IrpContext, IN OUT PDIRENT Dirent, IN POEM_STRING Label)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_DIRSUP)

Definition at line 22 of file dirsup.c.

Dbg

#define Dbg   (DEBUG_TRACE_DIRSUP)

Definition at line 28 of file dirsup.c.

FatConstructDot

#define FatConstructDot	(		IRPCONTEXT,
			DCB,
			PARENT,
			DIRENT
	)

Value:

                                                                         {                  \
                                                                         \
    RtlCopyMemory( (PUCHAR)(DIRENT), ".          ", 11 );                \
    (DIRENT)->Attributes = FAT_DIRENT_ATTR_DIRECTORY;                    \
    (DIRENT)->LastWriteTime = (PARENT)->LastWriteTime;                   \
    if (FatData.ChicagoMode) {                                           \
        (DIRENT)->CreationTime = (PARENT)->CreationTime;                 \
        (DIRENT)->CreationMSec = (PARENT)->CreationMSec;                 \
        (DIRENT)->LastAccessDate = (PARENT)->LastAccessDate;             \
    }                                                                    \
    (DIRENT)->FirstClusterOfFile =                                       \
            (USHORT)(DCB)->FirstClusterOfFile;                           \
    (DIRENT)->FirstClusterOfFileHi =                                     \
            (USHORT)((DCB)->FirstClusterOfFile/0x10000);                 \
}

Definition at line 49 of file dirsup.c.

FatConstructDotDot

#define FatConstructDotDot	(		IRPCONTEXT,
			DCB,
			PARENT,
			DIRENT
	)

Value:

                                                             {   \
                                                             \
    RtlCopyMemory( (PUCHAR)(DIRENT), "..         ", 11 );    \
    (DIRENT)->Attributes = FAT_DIRENT_ATTR_DIRECTORY;        \
    (DIRENT)->LastWriteTime = (PARENT)->LastWriteTime;       \
    if (FatData.ChicagoMode) {                               \
        (DIRENT)->CreationTime = (PARENT)->CreationTime;     \
        (DIRENT)->CreationMSec = (PARENT)->CreationMSec;     \
        (DIRENT)->LastAccessDate = (PARENT)->LastAccessDate; \
    }                                                        \
    if (NodeType((DCB)->ParentDcb) == FAT_NTC_ROOT_DCB) {    \
        (DIRENT)->FirstClusterOfFile = 0;                    \
        (DIRENT)->FirstClusterOfFileHi = 0;                  \
    } else {                                                 \
        (DIRENT)->FirstClusterOfFile = (USHORT)              \
            ((DCB)->ParentDcb->FirstClusterOfFile);          \
        (DIRENT)->FirstClusterOfFileHi = (USHORT)            \
            ((DCB)->ParentDcb->FirstClusterOfFile/0x10000);  \
    }                                                        \
}

Definition at line 80 of file dirsup.c.

FatConstructEndDirent

#define FatConstructEndDirent	(		IRPCONTEXT,
			DIRENT
	)		NOTHING

Definition at line 113 of file dirsup.c.

FatReadDirent

#define FatReadDirent	(		IRPCONTEXT,
			DCB,
			VBO,
			BCB,
			DIRENT,
			STATUS
	)

Value:

if ((VBO) >= (DCB)->Header.AllocationSize.LowPart) {              \
    *(STATUS) = STATUS_END_OF_FILE;                               \
    FatUnpinBcb( (IRPCONTEXT), *(BCB) );                          \
} else if ( ((VBO) % PAGE_SIZE == 0) || (*(BCB) == NULL) ) {      \
    FatUnpinBcb( (IRPCONTEXT), *(BCB) );                          \
    FatReadDirectoryFile( (IRPCONTEXT),                           \
                          (DCB),                                  \
                          (VBO) & ~(PAGE_SIZE - 1),               \
                          PAGE_SIZE,                              \
                          FALSE,                                  \
                          (BCB),                                  \
                          (PVOID *)(DIRENT),                      \
                          (STATUS) );                             \
    *(DIRENT) = (PVOID)((PUCHAR)*(DIRENT) + ((VBO) % PAGE_SIZE)); \
}

Definition at line 132 of file dirsup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 158 of file dirsup.c.

{
    VBO UnusedVbo;
    VBO DeletedHint;
    ULONG ByteOffset;
 
    PBCB Bcb = NULL;
    PDIRENT Dirent = NULL;
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCreateNewDirent\n", 0);
 
    DebugTrace( 0, Dbg, "  ParentDirectory = %p\n", ParentDirectory);
 
    //
    //  If UnusedDirentVbo is within our current file allocation then we
    //  don't have to search through the directory at all; we know just
    //  where to put it.
    //
    //  If UnusedDirentVbo is beyond the current file allocation then
    //  there are no more unused dirents in the current allocation, though
    //  upon adding another cluster of allocation UnusedDirentVbo
    //  will point to an unused dirent.  Haveing found no unused dirents
    //  we use the DeletedDirentHint to try and find a deleted dirent in
    //  the current allocation.  In this also runs off the end of the file,
    //  we finally have to break down and allocate another sector.  Note
    //  that simply writing beyond the current allocation will automatically
    //  do just this.
    //
    //  We also must deal with the special case where UnusedDirentVbo and
    //  DeletedDirentHint have yet to be initialized.  In this case we must
    //  first walk through the directory looking for the first deleted entry
    //  first unused dirent.  After this point we continue as before.
    //  This initial state is denoted by the special value of 0xffffffff.
    //
 
    UnusedVbo = ParentDirectory->Specific.Dcb.UnusedDirentVbo;
    DeletedHint = ParentDirectory->Specific.Dcb.DeletedDirentHint;
 
    //
    //  Check for our first call to this routine with this Dcb.  If so
    //  we have to correctly set the two hints in the Dcb.
    //
 
    if (UnusedVbo == 0xffffffff || RescanDir) {
 
        FatRescanDirectory( IrpContext, ParentDirectory );
 
        UnusedVbo = ParentDirectory->Specific.Dcb.UnusedDirentVbo;
        DeletedHint = ParentDirectory->Specific.Dcb.DeletedDirentHint;
    }
 
    //
    //  Now we know that UnusedDirentVbo and DeletedDirentHint are correctly
    //  set so we check if there is already an unused dirent in the the
    //  current allocation.  This is the easy case.
    //
 
    DebugTrace( 0, Dbg, "  UnusedVbo   = %08lx\n", UnusedVbo);
    DebugTrace( 0, Dbg, "  DeletedHint = %08lx\n", DeletedHint);
 
    if (!RescanDir && ( UnusedVbo + (DirentsNeeded * sizeof(DIRENT)) <=
         ParentDirectory->Header.AllocationSize.LowPart )) {
 
        //
        //  Get this unused dirent for the caller.  We have a
        //  sporting chance that we won't have to wait.
        //
 
        DebugTrace( 0, Dbg, "There is a never used entry.\n", 0);
 
        ByteOffset = UnusedVbo;
 
        UnusedVbo += DirentsNeeded * sizeof(DIRENT);
 
    } else {
 
        //
        //  Life is tough.  We have to march from the DeletedDirentHint
        //  looking for a deleted dirent.  If we get to EOF without finding
        //  one, we will have to allocate a new cluster.
        //
 
        ByteOffset =
            RtlFindClearBits( &ParentDirectory->Specific.Dcb.FreeDirentBitmap,
                              DirentsNeeded,
                              DeletedHint / sizeof(DIRENT) );
 
        //
        //  Do a quick check for a root directory allocation that failed
        //  simply because of fragmentation.  Also, only attempt to defrag
        //  if the length is less that 0x40000.  This is to avoid
        //  complications arising from crossing a MM view boundary (256kb).
        //  By default on DOS the root directory is only 0x2000 long.
        //
        //  Don't try to defrag fat32 root dirs.
        //
 
        if (!FatIsFat32(ParentDirectory->Vcb) &&
            (ByteOffset == -1) &&
            (NodeType(ParentDirectory) == FAT_NTC_ROOT_DCB) &&
            (ParentDirectory->Header.AllocationSize.LowPart <= 0x40000)) {
 
            ByteOffset = FatDefragDirectory( IrpContext, ParentDirectory, DirentsNeeded );
        }
 
        if (ByteOffset != -1) {
 
            //
            //  If we consuemed deleted dirents at Deleted Hint, update.
            //  We also may have consumed some un-used dirents as well,
            //  so be sure to check for that as well.
            //
 
            ByteOffset *= sizeof(DIRENT);
 
            if (ByteOffset == DeletedHint) {
 
                DeletedHint += DirentsNeeded * sizeof(DIRENT);
            }
 
            if (ByteOffset + DirentsNeeded * sizeof(DIRENT) > UnusedVbo) {
 
                UnusedVbo = ByteOffset + DirentsNeeded * sizeof(DIRENT);
            }
 
        } else {
 
            //
            //  We are going to have to allocate another cluster.  Do
            //  so, update both the UnusedVbo and the DeletedHint and bail.
            //
 
            DebugTrace( 0, Dbg, "We have to allocate another cluster.\n", 0);
 
            //
            //  A reason why we might fail, unrelated to physical reasons,
            //  is that we constrain to 64k directory entries to match the
            //  restriction on Win95.  There are fundamental reasons to do
            //  this since searching a FAT directory is a linear operation
            //  and to allow FAT32 to toss us over the cliff is not permissable.
            //
 
            if (ParentDirectory->Header.AllocationSize.LowPart >= (64 * 1024 * sizeof(DIRENT)) ||
 
                //
                //  Make sure we are not trying to expand the root directory on non
                //  FAT32.  FAT16 and FAT12 have fixed size allocations.
                //
 
                (!FatIsFat32(ParentDirectory->Vcb) &&
                 NodeType(ParentDirectory) == FAT_NTC_ROOT_DCB)) {
 
                DebugTrace(0, Dbg, "Full root directory or too big on FAT32.  Raise Status.\n", 0);
 
                FatRaiseStatus( IrpContext, STATUS_CANNOT_MAKE );
            }
 
            //
            //  Take the last dirent(s) in this cluster.  We will allocate
            //  more clusters below.
            //
 
            ByteOffset = UnusedVbo;
            UnusedVbo += DirentsNeeded * sizeof(DIRENT);
 
            //
            //  Touch the directory file to cause space for the new dirents
            //  to be allocated.
            //
 
            Bcb = NULL;
 
            _SEH2_TRY {
 
                PVOID Buffer;
 
                FatPrepareWriteDirectoryFile( IrpContext,
                                              ParentDirectory,
                                              UnusedVbo,
                                              1,
                                              &Bcb,
                                              &Buffer,
                                              FALSE,
                                              TRUE,
                                              &Status );
 
            } _SEH2_FINALLY {
 
                FatUnpinBcb( IrpContext, Bcb );
            } _SEH2_END;
        }
    }
 
    //
    //  If we are only requesting a single dirent, and we did not get the
    //  first dirent in a directory, then check that the preceding dirent
    //  is not an orphaned LFN.  If it is, then mark it deleted.  Thus
    //  reducing the possibility of an accidental pairing.
    //
    //  Only do this when we are in Chicago Mode.
    //
 
    Bcb = NULL;
 
    if (FatData.ChicagoMode &&
        (DirentsNeeded == 1) &&
        (ByteOffset > (NodeType(ParentDirectory) == FAT_NTC_ROOT_DCB ?
                       0 : 2 * sizeof(DIRENT)))) {
        _SEH2_TRY {
 
            FatReadDirent( IrpContext,
                           ParentDirectory,
                           ByteOffset - sizeof(DIRENT),
                           &Bcb,
                           &Dirent,
                           &Status );
 
            if ((Status != STATUS_SUCCESS) ||
                (Dirent->FileName[0] == FAT_DIRENT_NEVER_USED)) {
 
                FatPopUpFileCorrupt( IrpContext, ParentDirectory );
 
                FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            if ((Dirent->Attributes == FAT_DIRENT_ATTR_LFN) &&
                (Dirent->FileName[0] != FAT_DIRENT_DELETED)) {
 
                //
                //  Pin it, mark it, and set it dirty.
                //
 
                FatPinMappedData( IrpContext,
                                  ParentDirectory,
                                  ByteOffset - sizeof(DIRENT),
                                  sizeof(DIRENT),
                                  &Bcb );
 
                Dirent->FileName[0] = FAT_DIRENT_DELETED;
 
                FatSetDirtyBcb( IrpContext, Bcb, ParentDirectory->Vcb, TRUE );
 
                NT_ASSERT( RtlAreBitsSet( &ParentDirectory->Specific.Dcb.FreeDirentBitmap,
                                       (ByteOffset - sizeof(DIRENT))/ sizeof(DIRENT),
                                       DirentsNeeded ) );
 
                RtlClearBits( &ParentDirectory->Specific.Dcb.FreeDirentBitmap,
                              (ByteOffset - sizeof(DIRENT))/ sizeof(DIRENT),
                              DirentsNeeded );
 
            }
 
        } _SEH2_FINALLY {
 
            FatUnpinBcb( IrpContext, Bcb );
        } _SEH2_END;
    }
 
    //
    //  Assert that the dirents are in fact unused
    //
 
    _SEH2_TRY {
 
        ULONG i;
 
        Bcb = NULL;
 
        for (i = 0; i < DirentsNeeded; i++) {
 
            FatReadDirent( IrpContext,
                           ParentDirectory,
                           ByteOffset + i*sizeof(DIRENT),
                           &Bcb,
                           &Dirent,
                           &Status );
 
            if ((Status != STATUS_SUCCESS) ||
                ((Dirent->FileName[0] != FAT_DIRENT_NEVER_USED) &&
                 (Dirent->FileName[0] != FAT_DIRENT_DELETED))) {
 
                FatPopUpFileCorrupt( IrpContext, ParentDirectory );
                FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
        }
 
    } _SEH2_FINALLY {
 
        FatUnpinBcb( IrpContext, Bcb );
    } _SEH2_END;
 
    //
    //  Set the Bits in the bitmap and move the Unused Dirent Vbo.
    //
 
    NT_ASSERT( RtlAreBitsClear( &ParentDirectory->Specific.Dcb.FreeDirentBitmap,
                             ByteOffset / sizeof(DIRENT),
                             DirentsNeeded ) );
 
    RtlSetBits( &ParentDirectory->Specific.Dcb.FreeDirentBitmap,
                ByteOffset / sizeof(DIRENT),
                DirentsNeeded );
 
    //
    //  Save the newly computed values in the Parent Directory Fcb
    //
 
    ParentDirectory->Specific.Dcb.UnusedDirentVbo = UnusedVbo;
    ParentDirectory->Specific.Dcb.DeletedDirentHint = DeletedHint;
 
    DebugTrace(-1, Dbg, "FatCreateNewDirent -> (VOID)\n", 0);
 
    return ByteOffset;
}

FatComputeLfnChecksum()

UCHAR FatComputeLfnChecksum

(

PDIRENT

Dirent

)

Definition at line 2878 of file dirsup.c.

{
    ULONG i;
    UCHAR Checksum;
 
    PAGED_CODE();
 
    Checksum = Dirent->FileName[0];
 
    for (i=1; i < 11; i++) {
 
        Checksum = ((Checksum & 1) ? 0x80 : 0) +
                    (Checksum >> 1) +
                    Dirent->FileName[i];
    }
 
    return Checksum;
}

Referenced by FatConstructDirent().

FatConstructDirent()

VOID FatConstructDirent	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PDIRENT	Dirent,
		IN POEM_STRING	FileName,
		IN BOOLEAN	ComponentReallyLowercase,
		IN BOOLEAN	ExtensionReallyLowercase,
		IN PUNICODE_STRING Lfn	OPTIONAL,
		IN USHORT	Attributes,
		IN BOOLEAN	ZeroAndSetTimeFields,
		IN PLARGE_INTEGER SetCreationTime	OPTIONAL
	)

Definition at line 2171 of file dirsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatConstructDirent\n", 0);
 
    DebugTrace( 0, Dbg, "  Dirent             = %p\n", Dirent);
    DebugTrace( 0, Dbg, "  FileName           = %Z\n", FileName);
    DebugTrace( 0, Dbg, "  Attributes         = %08lx\n", Attributes);
 
    if (ZeroAndSetTimeFields) {
 
        RtlZeroMemory( Dirent, sizeof(DIRENT) );
    }
 
    //
    //  We just merrily go and fill up the dirent with the fields given.
    //
 
    FatStringTo8dot3( IrpContext, *FileName, (PFAT8DOT3)&Dirent->FileName[0] );
 
    if (ZeroAndSetTimeFields || SetCreationTime) {
 
        LARGE_INTEGER Time, SaveTime;
 
        KeQuerySystemTime( &Time );
 
        if (FatData.ChicagoMode) {
 
            if (!SetCreationTime || !FatNtTimeToFatTime( IrpContext,
                                                         SetCreationTime,
                                                         FALSE,
                                                         &Dirent->CreationTime,
                                                         &Dirent->CreationMSec )) {
 
                //
                //  No tunneled time or the tunneled time was bogus. Since we aren't
                //  responsible for initializing the to-be-created Fcb with creation
                //  time, we can't do the usual thing and let NtTimeToFatTime perform
                //  rounding on the timestamp - this would mess up converting to the
                //  LastWriteTime below.
                //
 
                SaveTime = Time;
 
                if (!FatNtTimeToFatTime( IrpContext,
                                         &SaveTime,
                                         FALSE,
                                         &Dirent->CreationTime,
                                         &Dirent->CreationMSec )) {
 
                    //
                    //  Failed again. Wow.
                    //
 
                    RtlZeroMemory( &Dirent->CreationTime, sizeof(FAT_TIME_STAMP));
                    Dirent->CreationMSec = 0;
                }
            }
        }
 
        if (ZeroAndSetTimeFields) {
 
            //
            //  We only touch the other timestamps if we are initializing the dirent
            //
 
            if (!FatNtTimeToFatTime( IrpContext,
                                     &Time,
                                     TRUE,
                                     &Dirent->LastWriteTime,
                                     NULL )) {
 
                DebugTrace( 0, Dbg, "Current time invalid.\n", 0);
 
                RtlZeroMemory( &Dirent->LastWriteTime, sizeof(FAT_TIME_STAMP) );
            }
 
            if (FatData.ChicagoMode) {
 
                Dirent->LastAccessDate = Dirent->LastWriteTime.Date;
            }
        }
    }
 
    //
    //  Copy the attributes
    //
 
    Dirent->Attributes = (UCHAR)Attributes;
 
    //
    //  Set the magic bit here, to tell dirctrl.c that this name is really
    //  lowercase.
    //
 
    Dirent->NtByte = 0;
 
    if (ComponentReallyLowercase) {
 
        SetFlag( Dirent->NtByte, FAT_DIRENT_NT_BYTE_8_LOWER_CASE );
    }
 
    if (ExtensionReallyLowercase) {
 
        SetFlag( Dirent->NtByte, FAT_DIRENT_NT_BYTE_3_LOWER_CASE );
    }
 
    //
    //  See if we have to create an Lfn entry
    //
 
    if (ARGUMENT_PRESENT(Lfn)) {
 
        UCHAR DirentChecksum;
        UCHAR DirentsInLfn;
        UCHAR LfnOrdinal;
        PWCHAR LfnBuffer;
        PLFN_DIRENT LfnDirent;
 
        NT_ASSERT( FatData.ChicagoMode );
 
        DirentChecksum = FatComputeLfnChecksum( Dirent );
 
        LfnOrdinal =
        DirentsInLfn = (UCHAR)FAT_LFN_DIRENTS_NEEDED(Lfn);
 
        LfnBuffer = &Lfn->Buffer[(DirentsInLfn - 1) * 13];
 
        NT_ASSERT( DirentsInLfn <= MAX_LFN_DIRENTS );
 
        for (LfnDirent = (PLFN_DIRENT)Dirent - DirentsInLfn;
             LfnDirent < (PLFN_DIRENT)Dirent;
             LfnDirent += 1, LfnOrdinal -= 1, LfnBuffer -= 13) {
 
            WCHAR FinalLfnBuffer[13];
            PWCHAR Buffer;
 
            //
            //  We need to special case the "final" dirent.
            //
 
            if (LfnOrdinal == DirentsInLfn) {
 
                ULONG i;
                ULONG RemainderChars;
 
                RemainderChars = (Lfn->Length / sizeof(WCHAR)) % 13;
 
                LfnDirent->Ordinal = LfnOrdinal | FAT_LAST_LONG_ENTRY;
 
                if (RemainderChars != 0) {
 
                    RtlCopyMemory( FinalLfnBuffer,
                                   LfnBuffer,
                                   RemainderChars * sizeof(WCHAR) );
 
                    for (i = RemainderChars; i < 13; i++) {
 
                        //
                        //  Figure out which character to use.
                        //
 
                        if (i == RemainderChars) {
 
                            FinalLfnBuffer[i] = 0x0000;
 
                        } else {
 
                            FinalLfnBuffer[i] = 0xffff;
                        }
                    }
 
                    Buffer = FinalLfnBuffer;
 
                } else {
 
                    Buffer = LfnBuffer;
                }
 
            } else {
 
                LfnDirent->Ordinal = LfnOrdinal;
 
                Buffer = LfnBuffer;
            }
 
            //
            //  Now fill in the name.
            //
 
            RtlCopyMemory( &LfnDirent->Name1[0],
                           &Buffer[0],
                           5 * sizeof(WCHAR) );
 
            RtlCopyMemory( &LfnDirent->Name2[0],
                           &Buffer[5],
                           6 * sizeof(WCHAR) );
 
            RtlCopyMemory( &LfnDirent->Name3[0],
                           &Buffer[11],
                           2 * sizeof(WCHAR) );
 
            //
            //  And the other fields
            //
 
            LfnDirent->Attributes = FAT_DIRENT_ATTR_LFN;
 
            LfnDirent->Type = 0;
 
            LfnDirent->Checksum = DirentChecksum;
 
            LfnDirent->MustBeZero = 0;
        }
    }
 
    DebugTrace(-1, Dbg, "FatConstructDirent -> (VOID)\n", 0);
    return;
}

Referenced by FatSetRenameInfo().

FatConstructLabelDirent()

VOID FatConstructLabelDirent	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PDIRENT	Dirent,
		IN POEM_STRING	Label
	)

Definition at line 2440 of file dirsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatConstructLabelDirent\n", 0);
 
    DebugTrace( 0, Dbg, "  Dirent             = %p\n", Dirent);
    DebugTrace( 0, Dbg, "  Label              = %Z\n", Label);
 
    RtlZeroMemory( Dirent, sizeof(DIRENT) );
 
    //
    //  We just merrily go and fill up the dirent with the fields given.
    //
 
    RtlCopyMemory( Dirent->FileName, Label->Buffer, Label->Length );
 
    //
    // Pad the label with spaces, not nulls.
    //
 
    RtlFillMemory( &Dirent->FileName[Label->Length], 11 - Label->Length, ' ');
 
    Dirent->LastWriteTime = FatGetCurrentFatTime( IrpContext );
 
    Dirent->Attributes = FAT_DIRENT_ATTR_VOLUME_ID;
    Dirent->ExtendedAttributes = 0;
    Dirent->FileSize = 0;
 
    DebugTrace(-1, Dbg, "FatConstructLabelDirent -> (VOID)\n", 0);
    return;
}

Referenced by FatSetFsLabelInfo().

FatTunnelFcbOrDcb()

VOID FatTunnelFcbOrDcb	(	IN PFCB	FcbOrDcb,
		IN PCCB Ccb	OPTIONAL
	)

Definition at line 652 of file dirsup.c.

{
    UNICODE_STRING ShortNameWithCase = {0};
    UNICODE_STRING DownCaseSeg;
    WCHAR ShortNameBuffer[8+1+3];
    NTSTATUS Status;
    USHORT i;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatTunnelFcbOrDcb\n", 0);
 
    if (NodeType(FcbOrDcb) == FAT_NTC_DCB) {
 
        //
        //  Directory deletion. Flush all entries from this directory in
        //  the cache for this volume
        //
 
        FsRtlDeleteKeyFromTunnelCache( &FcbOrDcb->Vcb->Tunnel,
                                       FatDirectoryKey(FcbOrDcb) );
 
    } else {
 
        //
        //  Was a file, so throw it into the tunnel cache
        //
 
        //
        //  Get the short name into UNICODE
        //
 
        ShortNameWithCase.Length = 0;
        ShortNameWithCase.MaximumLength = sizeof(ShortNameBuffer);
        ShortNameWithCase.Buffer = ShortNameBuffer;
 
#ifdef _MSC_VER
#pragma prefast( suppress:28931, "needed for debug build" )
#endif
        Status = RtlOemStringToCountedUnicodeString( &ShortNameWithCase,
                                                     &FcbOrDcb->ShortName.Name.Oem,
                                                     FALSE);
 
        NT_ASSERT(ShortNameWithCase.Length != 0);
 
        NT_ASSERT(NT_SUCCESS(Status));
 
        if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_8_LOWER_CASE | FCB_STATE_3_LOWER_CASE)) {
 
            //
            //  Have to repair the case of the short name
            //
 
            for (i = 0; i < (ShortNameWithCase.Length/sizeof(WCHAR)) &&
                        ShortNameWithCase.Buffer[i] != L'.'; i++);
 
            //
            //  Now pointing at the '.', or otherwise the end of name component
            //
 
            if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_8_LOWER_CASE)) {
 
                DownCaseSeg.Buffer = ShortNameWithCase.Buffer;
                DownCaseSeg.MaximumLength = DownCaseSeg.Length = i*sizeof(WCHAR);
 
                RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
            }
 
            i++;
 
            //
            //  Now pointing at first wchar of the extension.
            //
 
            if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_3_LOWER_CASE)) {
 
                //
                //  It is not neccesarily the case that we can rely on the flag
                //  indicating that we really have an extension.
                //
 
                if ((i*sizeof(WCHAR)) < ShortNameWithCase.Length) {
                    DownCaseSeg.Buffer = &ShortNameWithCase.Buffer[i];
                    DownCaseSeg.MaximumLength = DownCaseSeg.Length = ShortNameWithCase.Length - i*sizeof(WCHAR);
 
                    RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
                }
            }
        }
 
        //
        //  ... and add it in
        //
 
        FsRtlAddToTunnelCache( &FcbOrDcb->Vcb->Tunnel,
                               FatDirectoryKey(FcbOrDcb->ParentDcb),
                               &ShortNameWithCase,
                               &FcbOrDcb->ExactCaseLongName,
                               BooleanFlagOn(Ccb->Flags, CCB_FLAG_OPENED_BY_SHORTNAME),
                               sizeof(LARGE_INTEGER),
                               &FcbOrDcb->CreationTime );
    }
 
    DebugTrace(-1, Dbg, "FatTunnelFcbOrDcb -> (VOID)\n", 0);
 
    return;
}

Referenced by _Requires_lock_held_(), and FatSetRenameInfo().