ReactOS  0.4.13-dev-92-gf251225
dirsup.c File Reference
#include "cdprocs.h"
Include dependency graph for dirsup.c:

Go to the source code of this file.

Macros

#define BugCheckFileId   (CDFS_BUG_CHECK_DIRSUP)
 
#define CdRawDirent(IC, DC)   Add2Ptr( (DC)->Sector, (DC)->SectorOffset, PRAW_DIRENT )
 

Functions

ULONG CdCheckRawDirentBounds (_In_ PIRP_CONTEXT IrpContext, _In_ PDIRENT_ENUM_CONTEXT DirContext)
 
XA_EXTENT_TYPE CdCheckForXAExtent (_In_ PIRP_CONTEXT IrpContext, _In_ PRAW_DIRENT RawDirent, _Inout_ PDIRENT Dirent)
 
VOID CdLookupDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG DirentOffset, _Out_ PDIRENT_ENUM_CONTEXT DirContext)
 
BOOLEAN CdLookupNextDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext)
 
 _At_ (Dirent->CdTime, _Post_notnull_) VOID CdUpdateDirentFromRawDirent(_In_ PIRP_CONTEXT IrpContext
 
 PAGED_CODE ()
 
 UNREFERENCED_PARAMETER (Fcb)
 
 ClearFlag (Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
 
 if (RawDirent->IntLeaveSize !=0)
 
 if (RawDirent->FileIdLen==0)
 
 if (!FlagOn(Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY) &&(Dirent->DirentLength >((FIELD_OFFSET(RAW_DIRENT, FileId)+Dirent->FileNameLen)+1)))
 
VOID CdUpdateDirentName (_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
 
 _Success_ (return !=FALSE)
 
BOOLEAN CdFindDirectory (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _Inout_ PFILE_ENUM_CONTEXT FileContext)
 
 _At_ (FileContext->ShortName.FileName.MaximumLength, _In_range_(>=, BYTE_COUNT_8_DOT_3)) BOOLEAN CdFindFileByShortName(_In_ PIRP_CONTEXT IrpContext
 
 CdVerifyOrCreateDirStreamFile (IrpContext, Fcb)
 
 CdLookupInitialFileDirent (IrpContext, Fcb, FileContext, Fcb->StreamOffset)
 
 if (ThisShortNameDirentOffset > ShortNameDirentOffset)
 
 if (ThisShortNameDirentOffset==ShortNameDirentOffset)
 
 while (CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
 
 if (Found)
 
BOOLEAN CdLookupNextInitialFileDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
 
VOID CdLookupLastFileDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
 
VOID CdCleanupFileContext (_In_ PIRP_CONTEXT IrpContext, _In_ PFILE_ENUM_CONTEXT FileContext)
 

Variables

_In_ PFCB Fcb
 
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext
 
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
 
Dirent DirentOffset = DirContext->BaseOffset + DirContext->SectorOffset
 
Dirent DirentLength = RawDirent->DirLen
 
Dirent StartingOffset = RawDirent->XarLen
 
Dirent CdTime = (PCHAR)RawDirent->RecordTime
 
Dirent DirentFlags = CdRawDirentFlags( IrpContext, RawDirent )
 
Dirent FileUnitSize
 
Dirent FileNameLen = RawDirent->FileIdLen
 
Dirent FileName = (PCHAR)RawDirent->FileId
 
Dirent XAAttributes = 0
 
Dirent XAFileNumber = 0
 
Dirent ExtentType = Form1Data
 
Dirent SystemUseOffset = 0
 
 return
 
_In_ PFCB _In_ PCD_NAME Name
 
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN IgnoreCase
 
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG ShortNameDirentOffset
 
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
 
ULONG ThisShortNameDirentOffset = Dirent->DirentOffset >> SHORT_NAME_SHIFT
 
 do
 
return Found
 

Macro Definition Documentation

◆ BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_DIRSUP)

Definition at line 74 of file dirsup.c.

◆ CdRawDirent

#define CdRawDirent (   IC,
  DC 
)    Add2Ptr( (DC)->Sector, (DC)->SectorOffset, PRAW_DIRENT )

Definition at line 88 of file dirsup.c.

Function Documentation

◆ _At_() [1/2]

_At_ ( Dirent->  CdTime,
_Post_notnull_   
)

◆ _At_() [2/2]

_At_ ( FileContext->ShortName.FileName.  MaximumLength,
_In_range_(>=, BYTE_COUNT_8_DOT_3  
)

◆ _Success_()

_Success_ ( return = FALSE)

Definition at line 823 of file dirsup.c.

864 {
865  PDIRENT Dirent;
867 
868  BOOLEAN Found = FALSE;
869 
870  PAGED_CODE();
871 
872  //
873  // Make sure there is a stream file for this Fcb.
874  //
875 
876  CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
877 
878  //
879  // Check to see whether we need to check for a possible short name.
880  //
881 
882  ShortNameDirentOffset = CdShortNameDirentOffset( IrpContext, &Name->FileName );
883 
884  //
885  // Position ourselves at the first entry.
886  //
887 
888  CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
889 
890  //
891  // Loop while there are more entries in this directory.
892  //
893 
894  do {
895 
896  Dirent = &FileContext->InitialDirent->Dirent;
897 
898  //
899  // We only consider files which don't have the associated bit set.
900  // We also only look for files. All directories would already
901  // have been found.
902  //
903 
904  if (!FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_ASSOC | CD_ATTRIBUTE_DIRECTORY )) {
905 
906  //
907  // Update the name in the current dirent.
908  //
909 
910  CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
911 
912  //
913  // Don't bother with constant entries.
914  //
915 
917 
918  continue;
919  }
920 
921  //
922  // Now check whether we have a name match.
923  // We exit the loop if we have a match.
924  //
925 
926  if (CdIsNameInExpression( IrpContext,
927  &Dirent->CdCaseFileName,
928  Name,
929  0,
930  TRUE )) {
931 
932  *MatchingName = &Dirent->CdCaseFileName;
933  Found = TRUE;
934  break;
935  }
936 
937  //
938  // The names didn't match. If the input name is a possible short
939  // name and we are at the correct offset in the directory then
940  // check if the short names match.
941  //
942 
943  if (((Dirent->DirentOffset >> SHORT_NAME_SHIFT) == ShortNameDirentOffset) &&
944  (Name->VersionString.Length == 0) &&
945  !CdIs8dot3Name( IrpContext,
946  Dirent->CdFileName.FileName )) {
947 
948  //
949  // Create the short name and check for a match.
950  //
951 
952  CdGenerate8dot3Name( IrpContext,
953  &Dirent->CdCaseFileName.FileName,
954  Dirent->DirentOffset,
955  FileContext->ShortName.FileName.Buffer,
956  &FileContext->ShortName.FileName.Length );
957 
958  //
959  // Now check whether we have a name match.
960  // We exit the loop if we have a match.
961  //
962 
963  if (CdIsNameInExpression( IrpContext,
965  Name,
966  0,
967  FALSE )) {
968 
970  Found = TRUE;
971  break;
972  }
973  }
974  }
975 
976  //
977  // Go to the next initial dirent for a file.
978  //
979 
980  } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
981 
982  //
983  // If we find the file then collect all of the dirents.
984  //
985 
986  if (Found) {
987 
988  CdLookupLastFileDirent( IrpContext, Fcb, FileContext );
989 
990  }
991 
992  return Found;
993 }
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
#define TRUE
Definition: types.h:120
BOOLEAN CdIsNameInExpression(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
Definition: namesup.c:844
BOOLEAN CdIs8dot3Name(_In_ PIRP_CONTEXT IrpContext, _In_ UNICODE_STRING FileName)
Definition: namesup.c:429
VOID CdLookupLastFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1426
ULONG CdShortNameDirentOffset(_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING Name)
Definition: namesup.c:955
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT _Out_ PCD_NAME * MatchingName
Definition: cdprocs.h:444
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG ShortNameDirentOffset
Definition: dirsup.c:1110
CdLookupInitialFileDirent(IrpContext, Fcb, FileContext, Fcb->StreamOffset)
#define CD_ATTRIBUTE_DIRECTORY
Definition: cd.h:354
unsigned char BOOLEAN
PAGED_CODE()
return Found
Definition: dirsup.c:1270
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN IgnoreCase
Definition: dirsup.c:1110
#define DIRENT_FLAG_CONSTANT_ENTRY
Definition: cdstruc.h:1677
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
VOID CdGenerate8dot3Name(_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName, _In_ ULONG DirentOffset, _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName, _Out_ PUSHORT ShortByteCount)
Definition: namesup.c:550
CdVerifyOrCreateDirStreamFile(IrpContext, Fcb)
#define CD_ATTRIBUTE_ASSOC
Definition: cd.h:355
ULONG Flags
Definition: ntfs.h:520
_In_ PFCB Fcb
Definition: dirsup.c:398
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425
unsigned int ULONG
Definition: retypes.h:1
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1111
#define SHORT_NAME_SHIFT
Definition: cd.h:364

◆ CdCheckForXAExtent()

XA_EXTENT_TYPE CdCheckForXAExtent ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PRAW_DIRENT  RawDirent,
_Inout_ PDIRENT  Dirent 
)

Definition at line 1790 of file dirsup.c.

1817 {
1819  PSYSTEM_USE_XA SystemUseArea;
1820 
1821  PAGED_CODE();
1822 
1823  UNREFERENCED_PARAMETER( IrpContext );
1824 
1825  //
1826  // Check if there is enough space for the XA system use area.
1827  //
1828 
1829  if (Dirent->DirentLength - Dirent->SystemUseOffset >= sizeof( SYSTEM_USE_XA )) {
1830 
1831  SystemUseArea = Add2Ptr( RawDirent, Dirent->SystemUseOffset, PSYSTEM_USE_XA );
1832 
1833  //
1834  // Check for a valid signature.
1835  //
1836 
1837  if (SystemUseArea->Signature == SYSTEM_XA_SIGNATURE) {
1838 
1839  //
1840  // Check for an audio track.
1841  //
1842 
1843  if (FlagOn( SystemUseArea->Attributes, SYSTEM_USE_XA_DA )) {
1844 
1845  ExtentType = CDAudio;
1846 
1847  } else if (FlagOn( SystemUseArea->Attributes, SYSTEM_USE_XA_FORM2 )) {
1848 
1849  //
1850  // Check for XA data. Note that a number of discs (video CDs)
1851  // have files marked as type XA Mode 2 Form 1 (2048 bytes of
1852  // user data), but actually record these sectors as Mode2 Form 2
1853  // (2352). We will fail to read these files, since for M2F1,
1854  // a normal read CD command is issued (as per SCSI specs).
1855  //
1856 
1858  }
1859 
1860  Dirent->XAAttributes = SystemUseArea->Attributes;
1861  Dirent->XAFileNumber = SystemUseArea->FileNumber;
1862  }
1863  }
1864 
1865  Dirent->ExtentType = ExtentType;
1866  return ExtentType;
1867 }
#define SYSTEM_USE_XA_FORM2
Definition: cd.h:517
USHORT Attributes
Definition: cd.h:493
#define Add2Ptr(PTR, INC)
Dirent ExtentType
Definition: dirsup.c:520
Definition: cd.h:524
#define SYSTEM_USE_XA_DA
Definition: cd.h:518
USHORT Signature
Definition: cd.h:499
PAGED_CODE()
#define SYSTEM_XA_SIGNATURE
Definition: cd.h:520
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
UCHAR XAFileNumber
Definition: cdstruc.h:995
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425
Definition: cd.h:526
UNREFERENCED_PARAMETER(Fcb)
enum _XA_EXTENT_TYPE XA_EXTENT_TYPE
UCHAR FileNumber
Definition: cd.h:505
USHORT XAAttributes
Definition: cdstruc.h:989

Referenced by CdLookupLastFileDirent().

◆ CdCheckRawDirentBounds()

ULONG CdCheckRawDirentBounds ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PDIRENT_ENUM_CONTEXT  DirContext 
)

Definition at line 1688 of file dirsup.c.

1718 {
1719  ULONG NextDirentOffset;
1720  PRAW_DIRENT RawDirent;
1721 
1722  PAGED_CODE();
1723 
1724  UNREFERENCED_PARAMETER( IrpContext );
1725 
1726  //
1727  // We should always have at least a byte still available in the
1728  // current buffer.
1729  //
1730 
1731  NT_ASSERT( (DirContext->DataLength - DirContext->SectorOffset) >= 1 );
1732 
1733  //
1734  // Get a pointer to the current dirent.
1735  //
1736 
1737  RawDirent = CdRawDirent( IrpContext, DirContext );
1738 
1739  //
1740  // If the dirent length is non-zero then look at the current dirent.
1741  //
1742 
1743  if (RawDirent->DirLen != 0) {
1744 
1745  //
1746  // Check the following bound for the dirent length.
1747  //
1748  // - Fits in the available bytes in the sector.
1749  // - Is at least the minimal dirent size.
1750  // - Is large enough to hold the file name.
1751  //
1752 
1753  if ((RawDirent->DirLen > (DirContext->DataLength - DirContext->SectorOffset)) ||
1754  (RawDirent->DirLen < MIN_RAW_DIRENT_LEN) ||
1755  (RawDirent->DirLen < (MIN_RAW_DIRENT_LEN - 1 + RawDirent->FileIdLen))) {
1756 
1758  }
1759 
1760  //
1761  // Copy the dirent length field.
1762  //
1763 
1764  NextDirentOffset = RawDirent->DirLen;
1765 
1766  //
1767  // If we are exactly at the next sector then tell our caller by
1768  // returning zero.
1769  //
1770 
1771  if (NextDirentOffset == (DirContext->DataLength - DirContext->SectorOffset)) {
1772 
1773  NextDirentOffset = 0;
1774  }
1775 
1776  } else {
1777 
1778  NextDirentOffset = 0;
1779  }
1780 
1781  return NextDirentOffset;
1782 }
#define CdRawDirent(IC, DC)
Definition: dirsup.c:88
UCHAR DirLen
Definition: cd.h:332
#define STATUS_FILE_CORRUPT_ERROR
Definition: udferr_usr.h:168
UCHAR FileIdLen
Definition: cd.h:345
PAGED_CODE()
#define MIN_RAW_DIRENT_LEN
Definition: cd.h:360
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1869
unsigned int ULONG
Definition: retypes.h:1
UNREFERENCED_PARAMETER(Fcb)
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext
Definition: dirsup.c:398
#define NT_ASSERT
Definition: rtlfuncs.h:3312

Referenced by CdLookupDirent(), and CdLookupNextDirent().

◆ CdCleanupFileContext()

VOID CdCleanupFileContext ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFILE_ENUM_CONTEXT  FileContext 
)

Definition at line 1636 of file dirsup.c.

1659 {
1660  PCOMPOUND_DIRENT CurrentCompoundDirent;
1661  ULONG Count = 2;
1662 
1663  PAGED_CODE();
1664 
1665  UNREFERENCED_PARAMETER( IrpContext );
1666 
1667  //
1668  // Cleanup the individual compound dirents.
1669  //
1670 
1671  do {
1672 
1673  CurrentCompoundDirent = &FileContext->Dirents[ Count ];
1674  CdCleanupDirContext( IrpContext, &CurrentCompoundDirent->DirContext );
1675  CdCleanupDirent( IrpContext, &CurrentCompoundDirent->Dirent );
1676 
1677  } while (Count--);
1678 
1679  return;
1680 }
DIRENT_ENUM_CONTEXT DirContext
Definition: cdstruc.h:1689
#define CdCleanupDirContext(IC, DC)
Definition: cdprocs.h:553
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
PAGED_CODE()
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
unsigned int ULONG
Definition: retypes.h:1
UNREFERENCED_PARAMETER(Fcb)
#define CdCleanupDirent(IC, D)
Definition: cdprocs.h:547

Referenced by _Requires_lock_held_(), and CdInitializeEnumeration().

◆ CdFindDirectory()

BOOLEAN CdFindDirectory ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFCB  Fcb,
_In_ PCD_NAME  Name,
_In_ BOOLEAN  IgnoreCase,
_Inout_ PFILE_ENUM_CONTEXT  FileContext 
)

Definition at line 997 of file dirsup.c.

1031 {
1032  PDIRENT Dirent;
1033 
1034  BOOLEAN Found = FALSE;
1035 
1036  PAGED_CODE();
1037 
1038  //
1039  // Make sure there is a stream file for this Fcb.
1040  //
1041 
1042  CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
1043 
1044  //
1045  // Position ourselves at the first entry.
1046  //
1047 
1048  CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
1049 
1050  //
1051  // Loop while there are more entries in this directory.
1052  //
1053 
1054  do {
1055 
1056  Dirent = &FileContext->InitialDirent->Dirent;
1057 
1058  //
1059  // We only look for directories. Directories cannot have the
1060  // associated bit set.
1061  //
1062 
1063  if (FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
1064 
1065  //
1066  // Update the name in the current dirent.
1067  //
1068 
1069  CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
1070 
1071  //
1072  // Don't bother with constant entries.
1073  //
1074 
1076 
1077  continue;
1078  }
1079 
1080  //
1081  // Now check whether we have a name match.
1082  // We exit the loop if we have a match.
1083  //
1084 
1085  if (CdIsNameInExpression( IrpContext,
1086  &Dirent->CdCaseFileName,
1087  Name,
1088  0,
1089  TRUE )) {
1090 
1091  Found = TRUE;
1092  break;
1093  }
1094  }
1095 
1096  //
1097  // Go to the next initial dirent.
1098  //
1099 
1100  } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
1101 
1102  return Found;
1103 }
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
#define TRUE
Definition: types.h:120
BOOLEAN CdIsNameInExpression(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
Definition: namesup.c:844
CdLookupInitialFileDirent(IrpContext, Fcb, FileContext, Fcb->StreamOffset)
#define CD_ATTRIBUTE_DIRECTORY
Definition: cd.h:354
unsigned char BOOLEAN
PAGED_CODE()
return Found
Definition: dirsup.c:1270
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN IgnoreCase
Definition: dirsup.c:1110
#define DIRENT_FLAG_CONSTANT_ENTRY
Definition: cdstruc.h:1677
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
CdVerifyOrCreateDirStreamFile(IrpContext, Fcb)
ULONG Flags
Definition: ntfs.h:520
_In_ PFCB Fcb
Definition: dirsup.c:398
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425

◆ CdLookupDirent()

VOID CdLookupDirent ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFCB  Fcb,
_In_ ULONG  DirentOffset,
_Out_ PDIRENT_ENUM_CONTEXT  DirContext 
)

Definition at line 125 of file dirsup.c.

160 {
161  LONGLONG BaseOffset;
162 
163  PAGED_CODE();
164 
165  //
166  // Initialize the offset of the first dirent we want to map.
167  //
168 
169  DirContext->BaseOffset = SectorTruncate( DirentOffset );
170  BaseOffset = DirContext->BaseOffset;
171 
172  DirContext->DataLength = SECTOR_SIZE;
173 
174  DirContext->SectorOffset = SectorOffset( DirentOffset );
175 
176  //
177  // Truncate the data length if we are at the end of the file.
178  //
179 
180  if (DirContext->DataLength > (Fcb->FileSize.QuadPart - BaseOffset)) {
181 
182  DirContext->DataLength = (ULONG) (Fcb->FileSize.QuadPart - BaseOffset);
183  }
184 
185  //
186  // Now map the data at this offset.
187  //
188 
190  (PLARGE_INTEGER) &BaseOffset,
191  DirContext->DataLength,
192  TRUE,
193  &DirContext->Bcb,
194  &DirContext->Sector );
195 
196  //
197  // Verify the dirent bounds.
198  //
199 
200  DirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
201  DirContext );
202 
203  return;
204 }
#define TRUE
Definition: types.h:120
PFILE_OBJECT FileObject
Definition: ntfs.h:504
Dirent DirentOffset
Definition: dirsup.c:444
ULONG CdCheckRawDirentBounds(_In_ PIRP_CONTEXT IrpContext, _In_ PDIRENT_ENUM_CONTEXT DirContext)
Definition: dirsup.c:1688
#define SECTOR_SIZE
Definition: winldr.h:34
#define SectorOffset(L)
Definition: cdprocs.h:1632
PAGED_CODE()
int64_t LONGLONG
Definition: typedefs.h:66
BOOLEAN NTAPI CcMapData(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *BcbResult, OUT PVOID *Buffer)
Definition: pinsup.c:694
#define SectorTruncate(L)
Definition: cdprocs.h:1598
_In_ PFCB Fcb
Definition: dirsup.c:398
unsigned int ULONG
Definition: retypes.h:1
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext
Definition: dirsup.c:398

Referenced by _Requires_lock_held_(), and CdCreateInternalStream().

◆ CdLookupInitialFileDirent()

CdLookupInitialFileDirent ( IrpContext  ,
Fcb  ,
FileContext  ,
Fcb->  StreamOffset 
)

◆ CdLookupLastFileDirent()

VOID CdLookupLastFileDirent ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFCB  Fcb,
_In_ PFILE_ENUM_CONTEXT  FileContext 
)

Definition at line 1426 of file dirsup.c.

1460 {
1462  PCOMPOUND_DIRENT CurrentCompoundDirent;
1463  PDIRENT CurrentDirent = NULL;
1464 
1465  BOOLEAN FirstPass = TRUE;
1466  BOOLEAN FoundDirent;
1467 
1468  PAGED_CODE();
1469 
1470  //
1471  // The current dirent to look at is the initial dirent for the file.
1472  //
1473 
1474  CurrentCompoundDirent = FileContext->InitialDirent;
1475 
1476  //
1477  // Loop until we reach the last dirent for the file.
1478  //
1479 
1480  while (TRUE) {
1481 
1482  CurrentDirent = &CurrentCompoundDirent->Dirent;
1483 
1484  //
1485  // Check if this extent has XA sectors.
1486  //
1487 
1488  if ((CurrentDirent->SystemUseOffset != 0) &&
1490  CdCheckForXAExtent( IrpContext,
1491  CdRawDirent( IrpContext, &CurrentCompoundDirent->DirContext ),
1492  CurrentDirent )) {
1493 
1494  //
1495  // Any previous dirent must describe XA sectors as well.
1496  //
1497 
1498  if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
1499 
1501  }
1502 
1503  //
1504  // If there are XA sectors then the data on the disk must
1505  // be correctly aligned on sectors and be an integral number of
1506  // sectors. Only an issue if the logical block size is not
1507  // 2048.
1508  //
1509 
1510  if (Fcb->Vcb->BlockSize != SECTOR_SIZE) {
1511 
1512  //
1513  // We will do the following checks.
1514  //
1515  // Data must start on a sector boundary.
1516  // Data length must be integral number of sectors.
1517  //
1518 
1519  if ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->StartingOffset ) != 0) ||
1520  (SectorBlockOffset( Fcb->Vcb, CurrentDirent->DataLength ) != 0)) {
1521 
1523  }
1524 
1525  //
1526  // If interleaved then both the file unit and interleave
1527  // gap must be integral number of sectors.
1528  //
1529 
1530  if ((CurrentDirent->FileUnitSize != 0) &&
1531  ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->FileUnitSize ) != 0) ||
1532  (SectorBlockOffset( Fcb->Vcb, CurrentDirent->InterleaveGapSize ) != 0))) {
1533 
1535  }
1536  }
1537 
1538  //
1539  // If this is the first dirent then add the bytes for the RIFF
1540  // header.
1541  //
1542 
1543  if (FirstPass) {
1544 
1545  FileContext->FileSize = sizeof( RIFF_HEADER );
1546  }
1547 
1548  //
1549  // Add the size of the mode2-form2 sector for each sector
1550  // we have here.
1551  //
1552 
1553  FileContext->FileSize += Int32x32To64( CurrentDirent->DataLength >> SECTOR_SHIFT,
1554  XA_SECTOR_SIZE);
1555 
1556  } else {
1557 
1558  //
1559  // This extent does not have XA sectors. Any previous dirent
1560  // better not have XA sectors.
1561  //
1562 
1563  if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
1564 
1566  }
1567 
1568  //
1569  // Add these bytes to the file size.
1570  //
1571 
1572  FileContext->FileSize += CurrentDirent->DataLength;
1573  }
1574 
1575  //
1576  // If we are at the last dirent then exit.
1577  //
1578 
1579  if (!FlagOn( CurrentDirent->DirentFlags, CD_ATTRIBUTE_MULTI )) {
1580 
1581  break;
1582  }
1583 
1584  //
1585  // Remember the extent type of the current extent.
1586  //
1587 
1588  ExtentType = CurrentDirent->ExtentType;
1589 
1590  //
1591  // Look for the next dirent of the file.
1592  //
1593 
1594  FoundDirent = CdLookupNextDirent( IrpContext,
1595  Fcb,
1596  &CurrentCompoundDirent->DirContext,
1597  &FileContext->CurrentDirent->DirContext );
1598 
1599  //
1600  // If we didn't find the entry then this is a corrupt directory.
1601  //
1602 
1603  if (!FoundDirent) {
1604 
1606  }
1607 
1608  //
1609  // Remember the dirent we just found.
1610  //
1611 
1612  CurrentCompoundDirent = FileContext->CurrentDirent;
1613  FirstPass = FALSE;
1614 
1615  //
1616  // Look up all of the dirent information for the given dirent.
1617  //
1618 
1619  CdUpdateDirentFromRawDirent( IrpContext,
1620  Fcb,
1621  &CurrentCompoundDirent->DirContext,
1622  &CurrentCompoundDirent->Dirent );
1623 
1624  //
1625  // Set flag to show there were multiple extents.
1626  //
1627 
1629  }
1630 
1631  return;
1632 }
ULONG DataLength
Definition: cdstruc.h:1606
#define CdRawDirent(IC, DC)
Definition: dirsup.c:88
#define TRUE
Definition: types.h:120
Dirent ExtentType
Definition: dirsup.c:520
#define SectorBlockOffset(V, LB)
Definition: cdprocs.h:1636
ULONG InterleaveGapSize
Definition: cdstruc.h:1633
Definition: cd.h:524
#define SECTOR_SHIFT
Definition: cd.h:32
ULONG BlockSize
Definition: cdstruc.h:626
DIRENT_ENUM_CONTEXT DirContext
Definition: cdstruc.h:1689
ULONG FileUnitSize
Definition: cdstruc.h:1632
ULONG VcbState
Definition: cdstruc.h:546
#define FILE_CONTEXT_MULTIPLE_DIRENTS
Definition: cdstruc.h:1745
#define STATUS_FILE_CORRUPT_ERROR
Definition: udferr_usr.h:168
#define SECTOR_SIZE
Definition: winldr.h:34
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PAGED_CODE()
UCHAR DirentFlags
Definition: cdstruc.h:1619
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
#define CD_ATTRIBUTE_MULTI
Definition: cd.h:356
XA_EXTENT_TYPE ExtentType
Definition: cdstruc.h:1669
ULONG Flags
Definition: ntfs.h:520
_In_ PFCB Fcb
Definition: dirsup.c:398
ULONG SystemUseOffset
Definition: cdstruc.h:1639
struct _RIFF_HEADER RIFF_HEADER
XA_EXTENT_TYPE CdCheckForXAExtent(_In_ PIRP_CONTEXT IrpContext, _In_ PRAW_DIRENT RawDirent, _Inout_ PDIRENT Dirent)
Definition: dirsup.c:1790
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define VCB_STATE_CDXA
Definition: cdstruc.h:717
BOOLEAN CdLookupNextDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext)
Definition: dirsup.c:208
#define XA_SECTOR_SIZE
Definition: cd.h:35
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1869
ULONG StartingOffset
Definition: cdstruc.h:1599
PVCB Vcb
Definition: cdstruc.h:939
enum _XA_EXTENT_TYPE XA_EXTENT_TYPE
#define Int32x32To64(a, b)

Referenced by _Requires_lock_held_(), _Success_(), CdEnumerateIndex(), and if().

◆ CdLookupNextDirent()

BOOLEAN CdLookupNextDirent ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFCB  Fcb,
_In_ PDIRENT_ENUM_CONTEXT  CurrentDirContext,
_Inout_ PDIRENT_ENUM_CONTEXT  NextDirContext 
)

Definition at line 208 of file dirsup.c.

253 {
254  LONGLONG CurrentBaseOffset = CurrentDirContext->BaseOffset;
255  ULONG TempUlong;
256 
257  BOOLEAN FoundDirent = FALSE;
258 
259  PAGED_CODE();
260 
261  //
262  // Check if a different sector is mapped. If so then move our target
263  // enumeration context to the same sector.
264  //
265 
266  if ((CurrentDirContext->BaseOffset != NextDirContext->BaseOffset) ||
267  (NextDirContext->Bcb == NULL)) {
268 
269  //
270  // Unpin the current target Bcb and map the next sector.
271  //
272 
273  CdUnpinData( IrpContext, &NextDirContext->Bcb );
274 
276  (PLARGE_INTEGER) &CurrentBaseOffset,
277  CurrentDirContext->DataLength,
278  TRUE,
279  &NextDirContext->Bcb,
280  &NextDirContext->Sector );
281 
282  //
283  // Copy the data length and sector offset.
284  //
285 
286  NextDirContext->DataLength = CurrentDirContext->DataLength;
287  NextDirContext->BaseOffset = CurrentDirContext->BaseOffset;
288  }
289 
290  //
291  // Now move to the same offset in the sector.
292  //
293 
294  NextDirContext->SectorOffset = CurrentDirContext->SectorOffset;
295 
296  //
297  // If the value is zero then unmap the current sector and set up
298  // the base offset to the beginning of the next sector.
299  //
300 
301  if (CurrentDirContext->NextDirentOffset == 0) {
302 
303  CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
304 
305  //
306  // Unmap the current sector. We test the value of the Bcb in the
307  // loop below to see if we need to read in another sector.
308  //
309 
310  CdUnpinData( IrpContext, &NextDirContext->Bcb );
311 
312  //
313  // There is another possible dirent in the current sector. Update the
314  // enumeration context to reflect this.
315  //
316 
317  } else {
318 
319  NextDirContext->SectorOffset += CurrentDirContext->NextDirentOffset;
320  }
321 
322  //
323  // Now loop until we find the next possible dirent or walk off the directory.
324  //
325 
326  while (TRUE) {
327 
328  //
329  // If we don't currently have a sector mapped then map the
330  // directory at the current offset.
331  //
332 
333  if (NextDirContext->Bcb == NULL) {
334 
335  TempUlong = SECTOR_SIZE;
336 
337  if (TempUlong > (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset)) {
338 
339  TempUlong = (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset);
340 
341  //
342  // If the length is zero then there is no dirent.
343  //
344 
345  if (TempUlong == 0) {
346 
347  break;
348  }
349  }
350 
352  (PLARGE_INTEGER) &CurrentBaseOffset,
353  TempUlong,
354  TRUE,
355  &NextDirContext->Bcb,
356  &NextDirContext->Sector );
357 
358  NextDirContext->BaseOffset = (ULONG) CurrentBaseOffset;
359  NextDirContext->SectorOffset = 0;
360  NextDirContext->DataLength = TempUlong;
361  }
362 
363  //
364  // The CDFS spec allows for sectors in a directory to contain all zeroes.
365  // In this case we need to move to the next sector. So look at the
366  // current potential dirent for a zero length. Move to the next
367  // dirent if length is zero.
368  //
369 
370  if (*((PCHAR) CdRawDirent( IrpContext, NextDirContext )) != 0) {
371 
372  FoundDirent = TRUE;
373  break;
374  }
375 
376  CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
377  CdUnpinData( IrpContext, &NextDirContext->Bcb );
378  }
379 
380  //
381  // Check the dirent bounds if we found a dirent.
382  //
383 
384  if (FoundDirent) {
385 
386  NextDirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
387  NextDirContext );
388  }
389 
390  return FoundDirent;
391 }
signed char * PCHAR
Definition: retypes.h:7
#define CdRawDirent(IC, DC)
Definition: dirsup.c:88
#define TRUE
Definition: types.h:120
PFILE_OBJECT FileObject
Definition: ntfs.h:504
ULONG CdCheckRawDirentBounds(_In_ PIRP_CONTEXT IrpContext, _In_ PDIRENT_ENUM_CONTEXT DirContext)
Definition: dirsup.c:1688
#define SECTOR_SIZE
Definition: winldr.h:34
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PAGED_CODE()
int64_t LONGLONG
Definition: typedefs.h:66
BOOLEAN NTAPI CcMapData(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *BcbResult, OUT PVOID *Buffer)
Definition: pinsup.c:694
_In_ PFCB Fcb
Definition: dirsup.c:398
unsigned int ULONG
Definition: retypes.h:1
#define CdUnpinData(IC, B)
Definition: cdprocs.h:261

Referenced by _Requires_lock_held_(), CdInitializeFcbFromFileContext(), CdLookupLastFileDirent(), and CdLookupNextInitialFileDirent().

◆ CdLookupNextInitialFileDirent()

BOOLEAN CdLookupNextInitialFileDirent ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PFCB  Fcb,
_Inout_ PFILE_ENUM_CONTEXT  FileContext 
)

Definition at line 1275 of file dirsup.c.

1310 {
1311  PRAW_DIRENT RawDirent;
1312 
1313  PDIRENT_ENUM_CONTEXT CurrentDirContext;
1314  PDIRENT_ENUM_CONTEXT TargetDirContext;
1315  PCOMPOUND_DIRENT TempDirent;
1316 
1317  BOOLEAN FoundDirent = FALSE;
1318  BOOLEAN FoundLastDirent;
1319 
1320  PAGED_CODE();
1321 
1322  //
1323  // Start by saving the initial dirent of the current file as the
1324  // previous file.
1325  //
1326 
1327  TempDirent = FileContext->PriorDirent;
1328  FileContext->PriorDirent = FileContext->InitialDirent;
1329  FileContext->InitialDirent = TempDirent;
1330 
1331  //
1332  // We will use the initial dirent of the prior file unless the
1333  // previous search returned multiple extents.
1334  //
1335 
1336  CurrentDirContext = &FileContext->PriorDirent->DirContext;
1337 
1339 
1340  CurrentDirContext = &FileContext->CurrentDirent->DirContext;
1341  }
1342 
1343  //
1344  // Clear all of the flags and file size for the next file.
1345  //
1346 
1347  FileContext->Flags = 0;
1348  FileContext->FileSize = 0;
1349 
1350  FileContext->ShortName.FileName.Length = 0;
1351 
1352  //
1353  // We always want to store the result into the updated initial dirent
1354  // context.
1355  //
1356 
1357  TargetDirContext = &FileContext->InitialDirent->DirContext;
1358 
1359  //
1360  // Loop until we find the first dirent after the last dirent of the
1361  // current file. We may not be at the last dirent for the current file yet
1362  // so we may walk forward looking for the last and then find the
1363  // initial dirent for the next file after that.
1364  //
1365 
1366  while (TRUE) {
1367 
1368  //
1369  // Remember if the last dirent we visited was the last dirent for
1370  // a file.
1371  //
1372 
1373  RawDirent = CdRawDirent( IrpContext, CurrentDirContext );
1374 
1375  FoundLastDirent = !FlagOn( CdRawDirentFlags( IrpContext, RawDirent ), CD_ATTRIBUTE_MULTI );
1376 
1377  //
1378  // Try to find another dirent.
1379  //
1380 
1381  FoundDirent = CdLookupNextDirent( IrpContext,
1382  Fcb,
1383  CurrentDirContext,
1384  TargetDirContext );
1385 
1386  //
1387  // Exit the loop if no entry found.
1388  //
1389 
1390  if (!FoundDirent) {
1391 
1392  break;
1393 
1394  }
1395 
1396  //
1397  // Update the in-memory dirent.
1398  //
1399 
1400  CdUpdateDirentFromRawDirent( IrpContext,
1401  Fcb,
1402  TargetDirContext,
1403  &FileContext->InitialDirent->Dirent );
1404 
1405  //
1406  // Exit the loop if we had the end for the previous file.
1407  //
1408 
1409  if (FoundLastDirent) {
1410 
1411  break;
1412  }
1413 
1414  //
1415  // Always use a single dirent from this point on.
1416  //
1417 
1418  CurrentDirContext = TargetDirContext;
1419  }
1420 
1421  return FoundDirent;
1422 }
#define CdRawDirentFlags(IC, RD)
Definition: cd.h:370
#define CdRawDirent(IC, DC)
Definition: dirsup.c:88
#define TRUE
Definition: types.h:120
#define FILE_CONTEXT_MULTIPLE_DIRENTS
Definition: cdstruc.h:1745
unsigned char BOOLEAN
PAGED_CODE()
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
#define CD_ATTRIBUTE_MULTI
Definition: cd.h:356
ULONG Flags
Definition: ntfs.h:520
_In_ PFCB Fcb
Definition: dirsup.c:398
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
BOOLEAN CdLookupNextDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext)
Definition: dirsup.c:208
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1111

Referenced by _Requires_lock_held_(), _Success_(), CdEnumerateIndex(), CdFindDirectory(), and CdInitializeEnumeration().

◆ CdUpdateDirentName()

VOID CdUpdateDirentName ( _In_ PIRP_CONTEXT  IrpContext,
_Inout_ PDIRENT  Dirent,
_In_ ULONG  IgnoreCase 
)

Definition at line 534 of file dirsup.c.

562 {
563  UCHAR DirectoryValue;
564  ULONG Length;
565 
567 
568  PAGED_CODE();
569 
570  //
571  // Check if this is a self or parent entry. There is no version number
572  // in these cases. We use a fixed string for these.
573  //
574  // Self-Entry - Length is 1, value is 0.
575  // Parent-Entry - Length is 1, value is 1.
576  //
577 
578  if ((Dirent->FileNameLen == 1) &&
579  FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
580 
581  DirectoryValue = *((PCHAR) Dirent->FileName);
582 
583  if ((DirectoryValue == 0) || (DirectoryValue == 1)) {
584 
585  //
586  // We should not have allocated a name by the time we see these cases.
587  // If we have, this means that the image is in violation of ISO 9660 7.6.2,
588  // which states that the ./.. entries must be the first two in the directory.
589  //
590 
592 
594  }
595 
596  //
597  // Now use one of the hard coded directory names.
598  //
599 
600  Dirent->CdFileName.FileName = CdUnicodeDirectoryNames[DirectoryValue];
601 
602  //
603  // Show that there is no version number.
604  //
605 
606  Dirent->CdFileName.VersionString.Length = 0;
607 
608  //
609  // The case name is the same as the exact name.
610  //
611 
612  Dirent->CdCaseFileName = Dirent->CdFileName;
613 
614  //
615  // Mark this as a constant value entry.
616  //
617 
619 
620  //
621  // Return now.
622  //
623 
624  return;
625  }
626  }
627 
628  //
629  // Mark this as a non-constant value entry.
630  //
631 
633 
634  //
635  // Compute how large a buffer we will need. If this is an ignore
636  // case operation then we will want a double size buffer. If the disk is not
637  // a Joliet disk then we might need two bytes for each byte in the name.
638  //
639 
640  Length = Dirent->FileNameLen;
641 
642  if (IgnoreCase) {
643 
644  Length *= 2;
645  }
646 
647  if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
648 
649  Length *= sizeof( WCHAR );
650  }
651 
652  //
653  // Now decide if we need to allocate a new buffer. We will if
654  // this name won't fit in the embedded name buffer and it is
655  // larger than the current allocated buffer. We always use the
656  // allocated buffer if present.
657  //
658  // If we haven't allocated a buffer then use the embedded buffer if the data
659  // will fit. This is the typical case.
660  //
661 
663  (Length <= sizeof( Dirent->NameBuffer ))) {
664 
665  Dirent->CdFileName.FileName.MaximumLength = sizeof( Dirent->NameBuffer );
666  Dirent->CdFileName.FileName.Buffer = Dirent->NameBuffer;
667 
668  } else {
669 
670  //
671  // We need to use an allocated buffer. Check if the current buffer
672  // is large enough.
673  //
674 
675  if (Length > Dirent->CdFileName.FileName.MaximumLength) {
676 
677  //
678  // Free any allocated buffer.
679  //
680 
682 
683  CdFreePool( &Dirent->CdFileName.FileName.Buffer );
685  }
686 
687  Dirent->CdFileName.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
688  Length,
689  TAG_DIRENT_NAME );
690 
692 
693  Dirent->CdFileName.FileName.MaximumLength = (USHORT) Length;
694  }
695  }
696 
697  //
698  // We now have a buffer for the name. We need to either convert the on-disk bigendian
699  // to little endian or covert the name to Unicode.
700  //
701 
702  if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
703 
704  Status = RtlOemToUnicodeN( Dirent->CdFileName.FileName.Buffer,
705  Dirent->CdFileName.FileName.MaximumLength,
706  &Length,
707  Dirent->FileName,
708  Dirent->FileNameLen );
709 
710  __analysis_assert( Status == STATUS_SUCCESS );
712  Dirent->CdFileName.FileName.Length = (USHORT) Length;
713 
714  } else {
715 
716  //
717  // Convert this string to little endian.
718  //
719 
720  CdConvertBigToLittleEndian( IrpContext,
721  Dirent->FileName,
722  Dirent->FileNameLen,
723  (PCHAR) Dirent->CdFileName.FileName.Buffer );
724 
725  Dirent->CdFileName.FileName.Length = (USHORT) Dirent->FileNameLen;
726  }
727 
728  //
729  // Split the name into name and version strings.
730  //
731 
732  CdConvertNameToCdName( IrpContext,
733  &Dirent->CdFileName );
734 
735  //
736  // The name length better be non-zero.
737  //
738 
739  if (Dirent->CdFileName.FileName.Length == 0) {
740 
742  }
743 
744  //
745  // If the filename ends with a period then back up one character.
746  //
747 
748  if (Dirent->CdFileName.FileName.Buffer[(Dirent->CdFileName.FileName.Length - sizeof( WCHAR )) / 2] == L'.') {
749 
750  //
751  // Slide the version string down.
752  //
753 
754  if (Dirent->CdFileName.VersionString.Length != 0) {
755 
756  PWCHAR NewVersion;
757 
758  //
759  // Start from the position currently containing the separator.
760  //
761 
762  NewVersion = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
763  Dirent->CdFileName.FileName.Length,
764  PWCHAR );
765 
766  //
767  // Now overwrite the period.
768  //
769 
770  RtlMoveMemory( NewVersion - 1,
771  NewVersion,
772  Dirent->CdFileName.VersionString.Length + sizeof( WCHAR ));
773 
774  //
775  // Now point to the new version string.
776  //
777 
778  Dirent->CdFileName.VersionString.Buffer = NewVersion;
779  }
780 
781  //
782  // Shrink the filename length.
783  //
784 
785  Dirent->CdFileName.FileName.Length -= sizeof( WCHAR );
786  }
787 
788  if (!CdIsLegalName( IrpContext, &Dirent->CdFileName.FileName )) {
789 
791  }
792 
793  //
794  // If this an exact case operation then use the filename exactly.
795  //
796 
797  if (!IgnoreCase) {
798 
799  Dirent->CdCaseFileName = Dirent->CdFileName;
800 
801  //
802  // Otherwise perform our upcase operation. We already have guaranteed the buffers are
803  // there.
804  //
805 
806  } else {
807 
808  Dirent->CdCaseFileName.FileName.Buffer = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
809  Dirent->CdFileName.FileName.MaximumLength / 2,
810  PWCHAR);
811 
812  Dirent->CdCaseFileName.FileName.MaximumLength = Dirent->CdFileName.FileName.MaximumLength / 2;
813 
814  CdUpcaseName( IrpContext,
815  &Dirent->CdFileName,
816  &Dirent->CdCaseFileName );
817  }
818 
819  return;
820 }
signed char * PCHAR
Definition: retypes.h:7
#define VCB_STATE_JOLIET
Definition: cdstruc.h:714
#define Add2Ptr(PTR, INC)
PVOID NTAPI FsRtlAllocatePoolWithTag(IN POOL_TYPE PoolType, IN ULONG NumberOfBytes, IN ULONG Tag)
Definition: filter.c:229
VOID CdUpcaseName(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME Name, _Inout_ PCD_NAME UpcaseName)
Definition: namesup.c:194
LONG NTSTATUS
Definition: precomp.h:26
NTSYSAPI NTSTATUS WINAPI RtlOemToUnicodeN(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD)
uint16_t * PWCHAR
Definition: typedefs.h:54
VOID CdConvertBigToLittleEndian(_In_ PIRP_CONTEXT IrpContext, _In_reads_bytes_(ByteCount) PCHAR BigEndian, _In_ ULONG ByteCount, _Out_writes_bytes_(ByteCount) PCHAR LittleEndian)
Definition: namesup.c:110
#define DIRENT_FLAG_ALLOC_BUFFER
Definition: cdstruc.h:1676
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_FILE_CORRUPT_ERROR
Definition: udferr_usr.h:168
#define CD_ATTRIBUTE_DIRECTORY
Definition: cd.h:354
PAGED_CODE()
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN IgnoreCase
Definition: dirsup.c:1110
#define DIRENT_FLAG_CONSTANT_ENTRY
Definition: cdstruc.h:1677
#define PCHAR
Definition: match.c:90
BOOLEAN CdIsLegalName(_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName)
Definition: namesup.c:377
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define CdPagedPool
Definition: cdprocs.h:1385
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ULONG Flags
Definition: ntfs.h:520
#define TAG_DIRENT_NAME
Definition: cdprocs.h:79
unsigned char UCHAR
Definition: xmlstorage.h:181
static const WCHAR L[]
Definition: oid.c:1250
UNICODE_STRING CdUnicodeDirectoryNames[]
Definition: cddata.c:52
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
Status
Definition: gdiplustypes.h:24
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define CdFreePool(x)
Definition: cdprocs.h:2200
unsigned short USHORT
Definition: pedump.c:61
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1869
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:2725
#define NT_ASSERT
Definition: rtlfuncs.h:3312

Referenced by _Success_(), CdCreateInternalStream(), CdEnumerateIndex(), CdFindDirectory(), CdInitializeEnumeration(), and if().

◆ CdVerifyOrCreateDirStreamFile()

CdVerifyOrCreateDirStreamFile ( IrpContext  ,
Fcb   
)

◆ ClearFlag()

ClearFlag ( Dirent->  Flags,
DIRENT_FLAG_NOT_PERSISTENT   
)

Referenced by _At_(), _Function_class_(), _Requires_lock_held_(), CcSetAdditionalCacheAttributes(), CdCleanupIrpContext(), CdFindActiveVolDescriptor(), CdInitializeEnumeration(), CdQueryFsAttributeInfo(), CdReMountOldVcb(), CdRemovePrefix(), CdUnlockVolumeInternal(), CdUpdateDirentName(), CdUpdatePathEntryName(), DriverEntry(), Ext2BuildExtents(), Ext2CheckDismount(), Ext2Cleanup(), Ext2CreateFile(), Ext2DropBH(), Ext2ExpandBlock(), Ext2ExpandExtent(), Ext2ExpandLast(), Ext2Flush(), Ext2FlushFile(), Ext2InitializeVcb(), Ext2InitializeZone(), Ext2LookupFile(), Ext2MediaEjectControl(), Ext2MountVolume(), Ext2OplockRequest(), Ext2ParseRegistryVolumeParams(), Ext2ProcessEntry(), Ext2ProcessVolumeProperty(), Ext2PurgeFile(), Ext2PutGroup(), Ext2QueryFileInformation(), Ext2ReadFile(), Ext2ReadVolume(), Ext2SetFileInformation(), Ext2TearDownStream(), Ext2TruncateBlock(), Ext2TruncateExtent(), Ext2TruncateIndirectFast(), Ext2UnlockVcb(), Ext2VerifyVolume(), Ext2WriteFile(), Ext2WriteSymlink(), Ext2WriteVolume(), FatAutoUnlock(), FatCheckDirtyBit(), FatCheckSystemSecurityAccess(), FatCleanVolumeDpc(), FatConstructNamesInFcb(), FatCreateFcb(), FatDeallocateCcbStrings(), FatMultiAsyncCompletionRoutine(), FatPrePostIrp(), FatRemoveNames(), FatSingleAsyncCompletionRoutine(), FatUnlockVolumeInternal(), FFSCheckDismount(), FFSCleanup(), FFSCreateFile(), FFSDeleteFile(), FFSDeleteMcbNode(), FFSFlush(), FFSFlushFile(), FFSFreeVcb(), FFSInitializeVcb(), FFSInvalidateVolumes(), FFSMediaEjectControl(), FFSMountVolume(), FFSPurgeFile(), FFSQueryParameters(), FFSReadFile(), FFSReadVolume(), FFSSetDispositionInfo(), FFSSetInformation(), FFSUnlockVcb(), FFSv1LookupFileName(), FFSv2LookupFileName(), FFSVerifyVolume(), FFSWriteFile(), FFSWriteVolume(), FltpAttachToFileSystemDevice(), FltpEnumerateFileSystemVolumes(), FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakToNone(), RfsdCheckDismount(), RfsdCleanup(), RfsdCreateFile(), RfsdDeleteFile(), RfsdDeleteMcbNode(), RfsdFlush(), RfsdFlushFile(), RfsdFreeVcb(), RfsdInvalidateVolumes(), RfsdLookupFileName(), RfsdMediaEjectControl(), RfsdMountVolume(), RfsdPurgeFile(), RfsdQueryParameters(), RfsdReadFile(), RfsdReadVolume(), RfsdSetDispositionInfo(), RfsdSetInformation(), RfsdUnlockVcb(), RfsdVerifyVolume(), RfsdWriteFile(), RfsdWriteVolume(), RxCancelBlockingOperation(), RxCancelOperationInOverflowQueue(), RxChangeBufferingState(), RxCollapseOrCreateSrvOpen(), RxCommonCleanup(), RxCommonRead(), RxCommonSetInformation(), RxCommonWrite(), RxCreateFromNetRoot(), RxFinalizeConnection(), RxFinalizeNetFobx(), RxFinalizeSrvOpen(), RxMarkFobxOnClose(), RxpUndoScavengerFinalizationMarking(), RxPurgeChangeBufferingStateRequestsForSrvOpen(), RxRemoveOperationFromBlockingQueue(), RxRemoveOverflowEntry(), RxSearchForCollapsibleOpen(), RxSetBasicInfo(), RxSetDispositionInfo(), RxSetupNetFileObject(), RxVerifyOperationIsLegal(), VfatCheckForDismount(), VfatCleanupFile(), VfatCloseWorker(), VfatCommonCloseFile(), VfatDismountVolume(), VfatLockOrUnlockVolume(), VfatOpenFile(), vfatReleaseFCB(), and ViCreateDriveLetter().

◆ if() [1/6]

if ( RawDirent->IntLeaveSize !  = 0)

Definition at line 487 of file dirsup.c.

487  {
488 
489  Dirent->FileUnitSize = RawDirent->IntLeaveSize;
490  Dirent->InterleaveGapSize = RawDirent->IntLeaveSkip;
491  }
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425

◆ if() [2/6]

if ( RawDirent->  FileIdLen = = 0)

Definition at line 501 of file dirsup.c.

501  {
502 
504  }
#define STATUS_FILE_CORRUPT_ERROR
Definition: udferr_usr.h:168
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1869

◆ if() [3/6]

if ( FlagOnDirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY) &&(Dirent->DirentLength >((FIELD_OFFSET(RAW_DIRENT, FileId)+Dirent->FileNameLen)+1))

Definition at line 523 of file dirsup.c.

524  {
525 
526  Dirent->SystemUseOffset = WordAlign( FIELD_OFFSET( RAW_DIRENT, FileId ) + Dirent->FileNameLen );
527  }
#define WordAlign(Ptr)
Definition: cdprocs.h:1564
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425

◆ if() [4/6]

Definition at line 1186 of file dirsup.c.

1186  {
1187 
1188  break;
1189  }

◆ if() [5/6]

Definition at line 1196 of file dirsup.c.

1196  {
1197 
1198  //
1199  // If this is an associated file then get out.
1200  //
1201 
1202  if (FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_ASSOC )) {
1203 
1204  break;
1205  }
1206 
1207  //
1208  // Update the name in the dirent and check if it is not
1209  // an 8.3 name.
1210  //
1211 
1212  CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
1213 
1214  if (CdIs8dot3Name( IrpContext,
1215  Dirent->CdFileName.FileName )) {
1216 
1217  break;
1218  }
1219 
1220  //
1221  // Generate the 8.3 name see if it matches our input name.
1222  //
1223 
1224  CdGenerate8dot3Name( IrpContext,
1225  &Dirent->CdCaseFileName.FileName,
1226  Dirent->DirentOffset,
1227  FileContext->ShortName.FileName.Buffer,
1228  &FileContext->ShortName.FileName.Length );
1229 
1230  //
1231  // Check if this name matches.
1232  //
1233 
1234  if (CdIsNameInExpression( IrpContext,
1235  Name,
1237  0,
1238  FALSE )) {
1239 
1240  //
1241  // Let our caller know we found an entry.
1242  //
1243 
1244  Found = TRUE;
1245  }
1246 
1247  //
1248  // Break out of the loop.
1249  //
1250 
1251  break;
1252  }
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
#define TRUE
Definition: types.h:120
BOOLEAN CdIsNameInExpression(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
Definition: namesup.c:844
BOOLEAN CdIs8dot3Name(_In_ PIRP_CONTEXT IrpContext, _In_ UNICODE_STRING FileName)
Definition: namesup.c:429
return Found
Definition: dirsup.c:1270
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN IgnoreCase
Definition: dirsup.c:1110
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
VOID CdGenerate8dot3Name(_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName, _In_ ULONG DirentOffset, _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName, _Out_ PUSHORT ShortByteCount)
Definition: namesup.c:550
#define CD_ATTRIBUTE_ASSOC
Definition: cd.h:355
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1111

◆ if() [6/6]

if ( Found  )

Definition at line 1264 of file dirsup.c.

1264  {
1265 
1266  CdLookupLastFileDirent( IrpContext, Fcb, FileContext );
1267 
1268  }
VOID CdLookupLastFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1426
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
_In_ PFCB Fcb
Definition: dirsup.c:398

◆ PAGED_CODE()

◆ UNREFERENCED_PARAMETER()

UNREFERENCED_PARAMETER ( Fcb  )

◆ while()

while ( CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext )

Variable Documentation

◆ CdTime

Dirent CdTime = (PCHAR)RawDirent->RecordTime

Definition at line 471 of file dirsup.c.

Referenced by main().

◆ DirContext

Definition at line 398 of file dirsup.c.

Referenced by CdCheckRawDirentBounds(), and CdLookupDirent().

◆ Dirent

PDIRENT Dirent
Initial value:
{
PRAW_DIRENT RawDirent = CdRawDirent( IrpContext, DirContext )
#define CdRawDirent(IC, DC)
Definition: dirsup.c:88
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext
Definition: dirsup.c:398

Definition at line 425 of file dirsup.c.

Referenced by _Success_(), CdCheckForXAExtent(), CdFindDirectory(), CdUpdateDirentName(), FatComputeLfnChecksum(), FatConstructDirent(), FatConstructLabelDirent(), and if().

◆ DirentFlags

Dirent DirentFlags = CdRawDirentFlags( IrpContext, RawDirent )

Definition at line 477 of file dirsup.c.

Referenced by main().

◆ DirentLength

Dirent DirentLength = RawDirent->DirLen

Definition at line 450 of file dirsup.c.

Referenced by main().

◆ DirentOffset

◆ do

do
Initial value:
{
Dirent = &FileContext->InitialDirent->Dirent
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425

Definition at line 1173 of file dirsup.c.

◆ ExtentType

Dirent ExtentType = Form1Data

Definition at line 520 of file dirsup.c.

Referenced by CdCheckForXAExtent(), CdLookupLastFileDirent(), and main().

◆ Fcb

◆ FileContext

◆ FileName

Dirent FileName = (PCHAR)RawDirent->FileId

Definition at line 507 of file dirsup.c.

◆ FileNameLen

Dirent FileNameLen = RawDirent->FileIdLen

Definition at line 506 of file dirsup.c.

Referenced by FatXSearchDirectoryBufferForFile(), main(), and VfatCreateFile().

◆ FileUnitSize

Dirent FileUnitSize
Initial value:
=
Dirent->InterleaveGapSize = 0
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: dirsup.c:425

Definition at line 484 of file dirsup.c.

Referenced by main().

◆ Found

return Found

Definition at line 1270 of file dirsup.c.

Referenced by _Requires_lock_held_(), _Success_(), AcpiNsGetDeviceCallback(), AddrSearchNext(), BlockIoEfiGetDeviceInformation(), CcpFindBcb(), CdEnumerateIndex(), CdFindDirectory(), CdInitializeEnumeration(), CdRomFindProfileInProfiles(), cff_parser_run(), ChanMgrGetChannelByName(), CheckForCurrentHostname(), cid_parser_new(), CmpFindSubKeyByName(), CmpGetNameControlBlock(), CmSetValueKey(), DeviceTableCompare(), DGRemoveIRP(), FileTableCompareWithSameAttributes(), FileTableCompareWithSubsetAttributes(), CHString::Find(), FindAttribute(), FindCheckItemByIndex(), FindCheckItemIndexByAccessMask(), FindEntryInHosts(), FindFile(), DriveVolume::FindFreeRange(), FindLFNorSFN_U(), CHString::FindOneOf(), FsRtlCheckLockForReadAccess(), FsRtlCheckLockForWriteAccess(), FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), GetFontPenalty(), GetLongPathNameW(), GetNextDosSesId(), GetShortPathNameW(), gray_record_cell(), HalpRegisterPciDebuggingDeviceInfo(), HidParser_AddMainItem(), HidParser_UpdateCurrentCollectionReport(), if(), InterfacePciDevicePresent(), InterfacePciDevicePresentEx(), IopHandleDeviceRemoval(), IsBatteryAlreadyOnList(), KdbInitialize(), KsFilterFactoryUpdateCacheData(), KspValidateConnectRequest(), LookupSidCache(), LsarEnumerateAccountsWithUserRight(), MainWndMenuHint(), CDeviceManager::MainWndMenuHint(), MiQueryMemoryBasicInformation(), MmGetSystemRoutineAddress(), MountMgrVolumeMountPointCreated(), NdisOpenAdapter(), NetGroupSetUsers(), NSP_GetServiceByNameHeapAllocW(), pfr_face_get_kerning(), ProcessRelocations(), CCabinet::ReadString(), RouterRemoveRoute(), RtlFindCharInUnicodeString(), RtlpDphRemoveFromAvailableList(), RxIsMemberOfTopLevelIrpAllocatedContextsList(), SamrLookupDomainInSamServer(), CUSBDevice::SelectConfiguration(), CUSBDevice::SelectInterface(), SpiCreatePortConfig(), SpQueryDeviceCallout(), START_TEST(), SubstituteFontRecurse(), T1_Get_Private_Dict(), T1_Set_MM_Design(), TCPAbortListenForSocket(), TCPRemoveIRP(), test_tcp(), test_udp(), tt_face_get_kerning(), UDFLoadPartDesc(), UDFVerifyPartDesc(), USBAudioSelectAudioStreamingInterface(), USBD_ParseConfigurationDescriptorEx(), VideoPortScanRom(), and xHalIoAssignDriveLetters().

◆ IgnoreCase

Definition at line 1110 of file dirsup.c.

Referenced by _Success_(), CdFindDirectory(), CdUpdateDirentName(), and if().

◆ Name

Definition at line 1110 of file dirsup.c.

◆ return

◆ ShortNameDirentOffset

_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG ShortNameDirentOffset

Definition at line 1110 of file dirsup.c.

Referenced by _Success_().

◆ StartingOffset

Dirent StartingOffset = RawDirent->XarLen

Definition at line 459 of file dirsup.c.

◆ SystemUseOffset

Dirent SystemUseOffset = 0

Definition at line 521 of file dirsup.c.

Referenced by main().

◆ ThisShortNameDirentOffset

ThisShortNameDirentOffset = Dirent->DirentOffset >> SHORT_NAME_SHIFT

Definition at line 1152 of file dirsup.c.

◆ XAAttributes

Dirent XAAttributes = 0

Definition at line 518 of file dirsup.c.

Referenced by main().

◆ XAFileNumber

Dirent XAFileNumber = 0

Definition at line 519 of file dirsup.c.

Referenced by main().