pathsup.c File Reference

#include "cdprocs.h"

Include dependency graph for pathsup.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_PATHSUP)
#define	CdRawPathEntry(IC, PC)    Add2Ptr( (PC)->Data, (PC)->DataOffset, PRAW_PATH_ENTRY )

Functions
VOID	CdMapPathTableBlock (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ LONGLONG BaseOffset, _Inout_ PPATH_ENUM_CONTEXT PathContext)
	_Success_ (return !=FALSE)
BOOLEAN	CdLookupNextPathEntry (_In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENUM_CONTEXT PathContext, _Inout_ PPATH_ENTRY PathEntry)
VOID	CdUpdatePathEntryName (_In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENTRY PathEntry, _In_ BOOLEAN IgnoreCase)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_PATHSUP)

Definition at line 82 of file pathsup.c.

CdRawPathEntry

#define CdRawPathEntry	(		IC,
			PC
	)		Add2Ptr( (PC)->Data, (PC)->DataOffset, PRAW_PATH_ENTRY )

Definition at line 96 of file pathsup.c.

Function Documentation

_Success_()

_Success_

(

return !

= FALSE

)

Definition at line 111 of file pathsup.c.

{
    PPATH_ENUM_CONTEXT PathContext = &CompoundPathEntry->PathContext;
    LONGLONG CurrentBaseOffset;
 
    PAGED_CODE();
 
    //
    //  Compute the starting base and starting path table offset.
    //
 
    CurrentBaseOffset = SectorTruncate( PathEntryOffset );
 
    //
    //  Map the next block in the Path Table.
    //
 
    CdMapPathTableBlock( IrpContext,
                         IrpContext->Vcb->PathTableFcb,
                         CurrentBaseOffset,
                         PathContext );
 
    //
    //  Set up our current offset into the Path Context.
    //
 
    PathContext->DataOffset = PathEntryOffset - PathContext->BaseOffset;
 
    //
    //  Update the in-memory structure for this path entry.
    //
 
    (VOID) CdUpdatePathEntryFromRawPathEntry( IrpContext,
                                              Ordinal,
                                              VerifyBounds,
                                              &CompoundPathEntry->PathContext,
                                              &CompoundPathEntry->PathEntry );
}

CdLookupNextPathEntry()

BOOLEAN CdLookupNextPathEntry	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PPATH_ENUM_CONTEXT	PathContext,
		_Inout_ PPATH_ENTRY	PathEntry
	)

Definition at line 207 of file pathsup.c.

{
    LONGLONG CurrentBaseOffset;
 
    PAGED_CODE();
 
    //
    //  Get the offset of the next path entry within the current
    //  data block.
    //
 
    PathContext->DataOffset += PathEntry->PathEntryLength;
 
    //
    //  If we are in the last data block then check if we are beyond the
    //  end of the file.
    //
 
    if (PathContext->LastDataBlock) {
 
        if (PathContext->DataOffset >= PathContext->DataLength) {
 
            return FALSE;
        }
 
    //
    //  If we are not in the last data block of the path table and
    //  this offset is in the second sector then move to the next
    //  data block.
    //
 
    } else if (PathContext->DataOffset >= SECTOR_SIZE) {
 
        CurrentBaseOffset = PathContext->BaseOffset + SECTOR_SIZE;
 
        CdMapPathTableBlock( IrpContext,
                             IrpContext->Vcb->PathTableFcb,
                             CurrentBaseOffset,
                             PathContext );
 
        //
        //  Set up our current offset into the Path Context.
        //
 
        PathContext->DataOffset -= SECTOR_SIZE;
    }
 
    //
    //  Now update the path entry with the values from the on-disk
    //  structure.
    //
 
    return CdUpdatePathEntryFromRawPathEntry( IrpContext,
                                              PathEntry->Ordinal + 1,
                                              TRUE,
                                              PathContext,
                                              PathEntry );
}

Referenced by _Requires_lock_held_().

CdMapPathTableBlock()

VOID CdMapPathTableBlock	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ LONGLONG	BaseOffset,
		_Inout_ PPATH_ENUM_CONTEXT	PathContext
	)

Definition at line 484 of file pathsup.c.

{
    ULONG CurrentLength;
    ULONG SectorSize;
    ULONG DataOffset;
    ULONG PassCount;
    PVOID Sector;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Map the new block and set the enumeration context to this
    //  point.  Allocate an auxilary buffer if necessary.
    //
 
    CurrentLength = 2 * SECTOR_SIZE;
 
    if (CurrentLength >= (ULONG) (Fcb->FileSize.QuadPart - BaseOffset)) {
 
        CurrentLength = (ULONG) (Fcb->FileSize.QuadPart - BaseOffset);
 
        //
        //  We know this is the last data block for this
        //  path table.
        //
 
        PathContext->LastDataBlock = TRUE;
    }
 
    //
    //  Set context values.
    //
 
    PathContext->BaseOffset = (ULONG) BaseOffset;
    PathContext->DataLength = CurrentLength;
 
    //
    //  Drop the previous sector's mapping
    //
 
    CdUnpinData( IrpContext, &PathContext->Bcb );
 
    //
    //  Check if spanning a view section.  The following must
    //  be true before we take this step.
    //
    //      Data length is more than one sector.
    //      Starting offset must be one sector before the
    //          cache manager VACB boundary.
    //
 
    if ((CurrentLength > SECTOR_SIZE) &&
        (FlagOn( ((ULONG) BaseOffset), VACB_MAPPING_MASK ) == LAST_VACB_SECTOR_OFFSET )) {
 
        //
        //  Map each sector individually and store into an auxilary
        //  buffer.
        //
 
        SectorSize = SECTOR_SIZE;
        DataOffset = 0;
        PassCount = 2;
 
        PathContext->Data = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                      CurrentLength,
                                                      TAG_SPANNING_PATH_TABLE );
        PathContext->AllocatedData = TRUE;
 
        while (PassCount--) {
 
            CcMapData( Fcb->FileObject,
                       (PLARGE_INTEGER) &BaseOffset,
                       SectorSize,
                       TRUE,
                       &PathContext->Bcb,
                       &Sector );
 
            RtlCopyMemory( Add2Ptr( PathContext->Data, DataOffset, PVOID ),
                           Sector,
                           SectorSize );
 
            CdUnpinData( IrpContext, &PathContext->Bcb );
 
            BaseOffset += SECTOR_SIZE;
            SectorSize = CurrentLength - SECTOR_SIZE;
            DataOffset = SECTOR_SIZE;
        }
 
    //
    //  Otherwise we can just map the data into the cache.
    //
 
    } else {
 
        //
        //  There is a slight chance that we have allocated an
        //  auxilary buffer on the previous sector.
        //
 
        if (PathContext->AllocatedData) {
 
            CdFreePool( &PathContext->Data );
            PathContext->AllocatedData = FALSE;
        }
 
        CcMapData( Fcb->FileObject,
                   (PLARGE_INTEGER) &BaseOffset,
                   CurrentLength,
                   TRUE,
                   &PathContext->Bcb,
                   &PathContext->Data );
    }
 
    return;
}

Referenced by CdLookupNextPathEntry().

CdUpdatePathEntryName()

VOID CdUpdatePathEntryName	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PPATH_ENTRY	PathEntry,
		_In_ BOOLEAN	IgnoreCase
	)

Definition at line 781 of file pathsup.c.

{
    ULONG Length;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    //
    //  Check if this is a self entry.  We use a fixed string for this.
    //
    //      Self-Entry - Length is 1, value is 0.
    //
 
    if ((*PathEntry->DirName == 0) &&
        (PathEntry->DirNameLen == 1)) {
 
        //
        //  There should be no allocated buffers.
        //
 
        NT_ASSERT( !FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER ));
 
        //
        //  Now use one of the hard coded directory names.
        //
 
        PathEntry->CdDirName.FileName = CdUnicodeDirectoryNames[0];
 
        //
        //  Show that there is no version number.
        //
 
        PathEntry->CdDirName.VersionString.Length = 0;
 
        //
        //  The case name is identical.
        //
 
        PathEntry->CdCaseDirName = PathEntry->CdDirName;
 
        //
        //  Return now.
        //
 
        return;
    }
 
    //
    //  Compute how large a buffer we will need.  If this is an ignore
    //  case operation then we will want a double size buffer.  If the disk is not
    //  a Joliet disk then we might need two bytes for each byte in the name.
    //
 
    Length = PathEntry->DirNameLen;
 
    if (IgnoreCase) {
 
        Length *= 2;
    }
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Length *= sizeof( WCHAR );
    }
 
    //
    //  Now decide if we need to allocate a new buffer.  We will if
    //  this name won't fit in the embedded name buffer and it is
    //  larger than the current allocated buffer.  We always use the
    //  allocated buffer if present.
    //
    //  If we haven't allocated a buffer then use the embedded buffer if the data
    //  will fit.  This is the typical case.
    //
 
    if (!FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER ) &&
        (Length <= sizeof( PathEntry->NameBuffer ))) {
 
        PathEntry->CdDirName.FileName.MaximumLength = sizeof( PathEntry->NameBuffer );
        PathEntry->CdDirName.FileName.Buffer = PathEntry->NameBuffer;
 
    } else {
 
        //
        //  We need to use an allocated buffer.  Check if the current buffer
        //  is large enough.
        //
 
        if (Length > PathEntry->CdDirName.FileName.MaximumLength) {
 
            //
            //  Free any allocated buffer.
            //
 
            if (FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER )) {
 
                CdFreePool( &PathEntry->CdDirName.FileName.Buffer );
                ClearFlag( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER );
            }
 
            PathEntry->CdDirName.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                                             Length,
                                                                             TAG_PATH_ENTRY_NAME );
 
            SetFlag( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER );
 
            PathEntry->CdDirName.FileName.MaximumLength = (USHORT) Length;
        }
    }
 
    //
    //  We now have a buffer for the name.  We need to either convert the on-disk bigendian
    //  to little endian or covert the name to Unicode.
    //
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Status = RtlOemToUnicodeN( PathEntry->CdDirName.FileName.Buffer,
                                   PathEntry->CdDirName.FileName.MaximumLength,
                                   &Length,
                                   PathEntry->DirName,
                                   PathEntry->DirNameLen );
 
        NT_ASSERT( Status == STATUS_SUCCESS );
        __analysis_assert( Status == STATUS_SUCCESS );
        PathEntry->CdDirName.FileName.Length = (USHORT) Length;
 
    } else {
 
        //
        //  Convert this string to little endian.
        //
 
        CdConvertBigToLittleEndian( IrpContext,
                                    PathEntry->DirName,
                                    PathEntry->DirNameLen,
                                    (PCHAR) PathEntry->CdDirName.FileName.Buffer );
 
        PathEntry->CdDirName.FileName.Length = (USHORT) PathEntry->DirNameLen;
    }
 
    //
    //  There is no version string.
    //
 
    PathEntry->CdDirName.VersionString.Length =
    PathEntry->CdCaseDirName.VersionString.Length = 0;
 
    //
    //  If the name string ends with a period then knock off the last
    //  character.
    //
 
    if (PathEntry->CdDirName.FileName.Buffer[(PathEntry->CdDirName.FileName.Length - sizeof( WCHAR )) / 2] == L'.') {
 
        //
        //  Shrink the filename length.
        //
 
        PathEntry->CdDirName.FileName.Length -= sizeof( WCHAR );
    }
 
    //
    //  Update the case name buffer if necessary.  If this is an exact case
    //  operation then just copy the exact case string.
    //
 
    if (IgnoreCase) {
 
        PathEntry->CdCaseDirName.FileName.Buffer = Add2Ptr( PathEntry->CdDirName.FileName.Buffer,
                                                            PathEntry->CdDirName.FileName.MaximumLength / 2,
                                                            PWCHAR);
 
        PathEntry->CdCaseDirName.FileName.MaximumLength = PathEntry->CdDirName.FileName.MaximumLength / 2;
 
        CdUpcaseName( IrpContext,
                      &PathEntry->CdDirName,
                      &PathEntry->CdCaseDirName );
 
    } else {
 
        PathEntry->CdCaseDirName = PathEntry->CdDirName;
    }
 
    return;
}