ReactOS  0.4.13-dev-482-ge57f103
dirctrl.c File Reference
#include "cdprocs.h"
Include dependency graph for dirctrl.c:

Go to the source code of this file.

Macros

#define BugCheckFileId   (CDFS_BUG_CHECK_DIRCTRL)
 

Functions

 _Requires_lock_held_ (_Global_critical_region_)
 
VOID CdInitializeEnumeration (_In_ PIRP_CONTEXT IrpContext, _In_ PIO_STACK_LOCATION IrpSp, _In_ PFCB Fcb, _Inout_ PCCB Ccb, _Inout_ PFILE_ENUM_CONTEXT FileContext, _Out_ PBOOLEAN ReturnNextEntry, _Out_ PBOOLEAN ReturnSingleEntry, _Out_ PBOOLEAN InitialQuery)
 
BOOLEAN CdEnumerateIndex (_In_ PIRP_CONTEXT IrpContext, _In_ PCCB Ccb, _Inout_ PFILE_ENUM_CONTEXT FileContext, _In_ BOOLEAN ReturnNextEntry)
 

Macro Definition Documentation

◆ BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_DIRCTRL)

Definition at line 23 of file dirctrl.c.

Function Documentation

◆ _Requires_lock_held_()

_Requires_lock_held_ ( _Global_critical_region_  )

Definition at line 29 of file dirctrl.c.

103 {
106 
107  PFCB Fcb;
108  PCCB Ccb;
109 
110  PAGED_CODE();
111 
112  //
113  // Decode the user file object and fail this request if it is not
114  // a user directory.
115  //
116 
117  if (CdDecodeFileObject( IrpContext,
118  IrpSp->FileObject,
119  &Fcb,
120  &Ccb ) != UserDirectoryOpen) {
121 
124  }
125 
126  //
127  // We know this is a directory control so we'll case on the
128  // minor function, and call a internal worker routine to complete
129  // the irp.
130  //
131 
132  switch (IrpSp->MinorFunction) {
133 
135 
136  Status = CdQueryDirectory( IrpContext, Irp, IrpSp, Fcb, Ccb );
137  break;
138 
140 
141  Status = CdNotifyChangeDirectory( IrpContext, Irp, IrpSp, Ccb );
142  break;
143 
144  default:
145 
148  break;
149  }
150 
151  return Status;
152 }
#define IRP_MN_NOTIFY_CHANGE_DIRECTORY
Definition: rdpdr.c:56
_In_ PIRP Irp
Definition: csq.h:116
Definition: cdstruc.h:908
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Definition: cdstruc.h:1073
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define IRP_MN_QUERY_DIRECTORY
Definition: rdpdr.c:55
#define PAGED_CODE()
Definition: video.h:57
VOID CdCompleteRequest(_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
Definition: cddata.c:914
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:593
Status
Definition: gdiplustypes.h:24
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
PFILE_OBJECT FileObject
Definition: iotypes.h:2812
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4157
_In_ PFCB Fcb
Definition: cdprocs.h:151

◆ CdEnumerateIndex()

BOOLEAN CdEnumerateIndex ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PCCB  Ccb,
_Inout_ PFILE_ENUM_CONTEXT  FileContext,
_In_ BOOLEAN  ReturnNextEntry 
)

Definition at line 1358 of file dirctrl.c.

1391 {
1392  PDIRENT PreviousDirent = NULL;
1393  PDIRENT ThisDirent = &FileContext->InitialDirent->Dirent;
1394 
1395  BOOLEAN Found = FALSE;
1396 
1397  PAGED_CODE();
1398 
1399  //
1400  // Loop until we find a match or exaust the directory.
1401  //
1402 
1403  while (TRUE) {
1404 
1405  //
1406  // Move to the next entry unless we want to consider the current
1407  // entry.
1408  //
1409 
1410  if (ReturnNextEntry) {
1411 
1412  if (!CdLookupNextInitialFileDirent( IrpContext, Ccb->Fcb, FileContext )) {
1413 
1414  break;
1415  }
1416 
1417  PreviousDirent = ThisDirent;
1418  ThisDirent = &FileContext->InitialDirent->Dirent;
1419 
1420  CdUpdateDirentName( IrpContext, ThisDirent, FlagOn( Ccb->Flags, CCB_FLAG_IGNORE_CASE ));
1421 
1422  } else {
1423 
1424  ReturnNextEntry = TRUE;
1425  }
1426 
1427  //
1428  // Don't bother if we have a constant entry and are ignoring them.
1429  //
1430 
1431  if (FlagOn( ThisDirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY ) &&
1433 
1434  continue;
1435  }
1436 
1437  //
1438  // Look at the current entry if it is not an associated file
1439  // and the name doesn't match the previous file if the version
1440  // name is not part of the search.
1441  //
1442 
1443  if (!FlagOn( ThisDirent->DirentFlags, CD_ATTRIBUTE_ASSOC )) {
1444 
1445  //
1446  // Check if this entry matches the previous entry except
1447  // for version number and whether we should return the
1448  // entry in that case. Go directly to the name comparison
1449  // if:
1450  //
1451  // There is no previous entry.
1452  // The search expression has a version component.
1453  // The name length doesn't match the length of the previous entry.
1454  // The base name strings don't match.
1455  //
1456 
1457  if ((PreviousDirent == NULL) ||
1458  (Ccb->SearchExpression.VersionString.Length != 0) ||
1459  (PreviousDirent->CdCaseFileName.FileName.Length != ThisDirent->CdCaseFileName.FileName.Length) ||
1460  FlagOn( PreviousDirent->DirentFlags, CD_ATTRIBUTE_ASSOC ) ||
1461  !RtlEqualMemory( PreviousDirent->CdCaseFileName.FileName.Buffer,
1462  ThisDirent->CdCaseFileName.FileName.Buffer,
1463  ThisDirent->CdCaseFileName.FileName.Length )) {
1464 
1465  //
1466  // If we match all names then return to our caller.
1467  //
1468 
1470 
1471  FileContext->ShortName.FileName.Length = 0;
1472  Found = TRUE;
1473  break;
1474  }
1475 
1476  //
1477  // Check if the long name matches the search expression.
1478  //
1479 
1480  if (CdIsNameInExpression( IrpContext,
1481  &ThisDirent->CdCaseFileName,
1482  &Ccb->SearchExpression,
1483  Ccb->Flags,
1484  TRUE )) {
1485 
1486  //
1487  // Let our caller know we found an entry.
1488  //
1489 
1490  Found = TRUE;
1491  FileContext->ShortName.FileName.Length = 0;
1492  break;
1493  }
1494 
1495  //
1496  // The long name didn't match so we need to check for a
1497  // possible short name match. There is no match if the
1498  // long name is 8dot3 or the search expression has a
1499  // version component. Special case the self and parent
1500  // entries.
1501  //
1502 
1503  if ((Ccb->SearchExpression.VersionString.Length == 0) &&
1504  !FlagOn( ThisDirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY ) &&
1505  !CdIs8dot3Name( IrpContext,
1506  ThisDirent->CdFileName.FileName )) {
1507 
1508  CdGenerate8dot3Name( IrpContext,
1509  &ThisDirent->CdCaseFileName.FileName,
1510  ThisDirent->DirentOffset,
1511  FileContext->ShortName.FileName.Buffer,
1512  &FileContext->ShortName.FileName.Length );
1513 
1514  //
1515  // Check if this name matches.
1516  //
1517 
1518  if (CdIsNameInExpression( IrpContext,
1520  &Ccb->SearchExpression,
1521  Ccb->Flags,
1522  FALSE )) {
1523 
1524  //
1525  // Let our caller know we found an entry.
1526  //
1527 
1528  Found = TRUE;
1529  break;
1530  }
1531  }
1532  }
1533  }
1534  }
1535 
1536  //
1537  // If we found the entry then make sure we walk through all of the
1538  // file dirents.
1539  //
1540 
1541  if (Found) {
1542 
1543  CdLookupLastFileDirent( IrpContext, Ccb->Fcb, FileContext );
1544  }
1545 
1546  return Found;
1547 }
#define CCB_FLAG_ENUM_MATCH_ALL
Definition: cdstruc.h:1122
#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
CD_NAME CdCaseFileName
Definition: cdstruc.h:1663
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
#define PAGED_CODE()
Definition: video.h:57
UCHAR Flags
Definition: cdstruc.h:1625
#define CCB_FLAG_IGNORE_CASE
Definition: cdstruc.h:1111
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define CCB_FLAG_ENUM_NOMATCH_CONSTANT_ENTRY
Definition: cdstruc.h:1126
return Found
Definition: dirsup.c:1270
UCHAR DirentFlags
Definition: cdstruc.h:1619
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: cdprocs.h:444
#define DIRENT_FLAG_CONSTANT_ENTRY
Definition: cdstruc.h:1677
VOID CdLookupLastFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1426
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
NTSYSAPI ULONG NTAPI RtlEqualMemory(CONST VOID *Source1, CONST VOID *Source2, ULONG Length)
#define CD_ATTRIBUTE_ASSOC
Definition: cd.h:355
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
ULONG Flags
Definition: ntfs.h:520
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:593
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
struct _FCB::@691::@694 Fcb
ULONG DirentOffset
Definition: cdstruc.h:1591
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1111
UNICODE_STRING FileName
Definition: cdstruc.h:250
CD_NAME CdFileName
Definition: cdstruc.h:1662

◆ CdInitializeEnumeration()

VOID CdInitializeEnumeration ( _In_ PIRP_CONTEXT  IrpContext,
_In_ PIO_STACK_LOCATION  IrpSp,
_In_ PFCB  Fcb,
_Inout_ PCCB  Ccb,
_Inout_ PFILE_ENUM_CONTEXT  FileContext,
_Out_ PBOOLEAN  ReturnNextEntry,
_Out_ PBOOLEAN  ReturnSingleEntry,
_Out_ PBOOLEAN  InitialQuery 
)

Definition at line 893 of file dirctrl.c.

939 {
941 
943  CD_NAME WildCardName;
944  CD_NAME SearchExpression;
945 
946  ULONG CcbFlags;
947 
949  ULONG LastDirentOffset;
950  BOOLEAN KnownOffset;
951 
952  BOOLEAN Found;
953 
954  PAGED_CODE();
955 
956  //
957  // If the user has specified that the scan be restarted, and has specicified
958  // a new query pattern, reinitialize the CCB.
959  //
960 
961  if (FlagOn( IrpSp->Flags, SL_RESTART_SCAN )) {
962 
963  CdLockFcb( IrpContext, Fcb );
964 
965  FileName = (PUNICODE_STRING) IrpSp->Parameters.QueryDirectory.FileName;
966  if (FileName && FileName->Length > 0) {
967 
969 
970  CdFreePool( &Ccb->SearchExpression.FileName.Buffer );
971  }
972 
976  }
977 
978  CdUnlockFcb( IrpContext, Fcb );
979  }
980 
981  //
982  // If this is the initial query then build a search expression from the input
983  // file name.
984  //
985 
987 
988  FileName = IrpSp->Parameters.QueryDirectory.FileName;
989 
990  CcbFlags = 0;
991 
992  //
993  // If the filename is not specified or is a single '*' then we will
994  // match all names.
995  //
996 
997  if ((FileName == NULL) ||
998  (FileName->Buffer == NULL) ||
999  (FileName->Length == 0) ||
1000  ((FileName->Length == sizeof( WCHAR )) &&
1001  (FileName->Buffer[0] == L'*'))) {
1002 
1003  SetFlag( CcbFlags, CCB_FLAG_ENUM_MATCH_ALL );
1004  RtlZeroMemory( &SearchExpression, sizeof( SearchExpression ));
1005 
1006  //
1007  // Otherwise build the CdName from the name in the stack location.
1008  // This involves building both the name and version portions and
1009  // checking for wild card characters. We also upcase the string if
1010  // this is a case-insensitive search.
1011  //
1012 
1013  } else {
1014 
1015  //
1016  // Create a CdName to check for wild cards.
1017  //
1018 
1019  WildCardName.FileName = *FileName;
1020 
1021  CdConvertNameToCdName( IrpContext, &WildCardName );
1022 
1023  //
1024  // The name better have at least one character.
1025  //
1026 
1027  if (WildCardName.FileName.Length == 0) {
1028 
1029  CdRaiseStatus( IrpContext, STATUS_INVALID_PARAMETER );
1030  }
1031 
1032  //
1033  // Check for wildcards in the separate components.
1034  //
1035 
1036  if (FsRtlDoesNameContainWildCards( &WildCardName.FileName)) {
1037 
1039  }
1040 
1041  if ((WildCardName.VersionString.Length != 0) &&
1042  (FsRtlDoesNameContainWildCards( &WildCardName.VersionString ))) {
1043 
1045 
1046  //
1047  // Check if this is a wild card only and match all version
1048  // strings.
1049  //
1050 
1051  if ((WildCardName.VersionString.Length == sizeof( WCHAR )) &&
1052  (WildCardName.VersionString.Buffer[0] == L'*')) {
1053 
1055  }
1056  }
1057 
1058  //
1059  // Now create the search expression to store in the Ccb.
1060  //
1061 
1063  FileName->Length,
1065 
1066  SearchExpression.FileName.MaximumLength = FileName->Length;
1067 
1068  //
1069  // Either copy the name directly or perform the upcase.
1070  //
1071 
1072  if (FlagOn( Ccb->Flags, CCB_FLAG_IGNORE_CASE )) {
1073 
1074  Status = RtlUpcaseUnicodeString( (PUNICODE_STRING) &SearchExpression.FileName,
1075  FileName,
1076  FALSE );
1077 
1078  //
1079  // This should never fail.
1080  //
1081  __analysis_assert( Status == STATUS_SUCCESS );
1083 
1084  } else {
1085 
1086  RtlCopyMemory( SearchExpression.FileName.Buffer,
1087  FileName->Buffer,
1088  FileName->Length );
1089  }
1090 
1091  //
1092  // Now split into the separate name and version components.
1093  //
1094 
1095  SearchExpression.FileName.Length = WildCardName.FileName.Length;
1096  SearchExpression.VersionString.Length = WildCardName.VersionString.Length;
1097  SearchExpression.VersionString.MaximumLength = WildCardName.VersionString.MaximumLength;
1098 
1099  SearchExpression.VersionString.Buffer = Add2Ptr( SearchExpression.FileName.Buffer,
1100  SearchExpression.FileName.Length + sizeof( WCHAR ),
1101  PWCHAR );
1102  }
1103 
1104  //
1105  // But we do not want to return the constant "." and ".." entries for
1106  // the root directory, for consistency with the rest of Microsoft's
1107  // filesystems.
1108  //
1109 
1110  if (Fcb == Fcb->Vcb->RootIndexFcb) {
1111 
1113  }
1114 
1115  //
1116  // Now lock the Fcb in order to update the Ccb with the inital
1117  // enumeration values.
1118  //
1119 
1120  CdLockFcb( IrpContext, Fcb );
1121 
1122  //
1123  // Check again that this is the initial search.
1124  //
1125 
1127 
1128  //
1129  // Update the values in the Ccb.
1130  //
1131 
1132  Ccb->CurrentDirentOffset = Fcb->StreamOffset;
1133  Ccb->SearchExpression = SearchExpression;
1134 
1135  //
1136  // Set the appropriate flags in the Ccb.
1137  //
1138 
1139  SetFlag( Ccb->Flags, CcbFlags | CCB_FLAG_ENUM_INITIALIZED );
1140 
1141  //
1142  // Otherwise cleanup any buffer allocated here.
1143  //
1144 
1145  } else {
1146 
1147  if (!FlagOn( CcbFlags, CCB_FLAG_ENUM_MATCH_ALL )) {
1148 
1149  CdFreePool( &SearchExpression.FileName.Buffer );
1150  }
1151  }
1152 
1153  //
1154  // Otherwise lock the Fcb so we can read the current enumeration values.
1155  //
1156 
1157  } else {
1158 
1159  CdLockFcb( IrpContext, Fcb );
1160  }
1161 
1162  //
1163  // Capture the current state of the enumeration.
1164  //
1165  // If the user specified an index then use his offset. We always
1166  // return the next entry in this case.
1167  //
1168 
1169  if (FlagOn( IrpSp->Flags, SL_INDEX_SPECIFIED )) {
1170 
1171  KnownOffset = FALSE;
1172  DirentOffset = IrpSp->Parameters.QueryDirectory.FileIndex;
1173  *ReturnNextEntry = TRUE;
1174 
1175  //
1176  // If we are restarting the scan then go from the self entry.
1177  //
1178 
1179  } else if (FlagOn( IrpSp->Flags, SL_RESTART_SCAN )) {
1180 
1181  KnownOffset = TRUE;
1182  DirentOffset = Fcb->StreamOffset;
1183  *ReturnNextEntry = FALSE;
1184 
1185  //
1186  // Otherwise use the values from the Ccb.
1187  //
1188 
1189  } else {
1190 
1191  KnownOffset = TRUE;
1192  DirentOffset = Ccb->CurrentDirentOffset;
1193  *ReturnNextEntry = BooleanFlagOn( Ccb->Flags, CCB_FLAG_ENUM_RETURN_NEXT );
1194  }
1195 
1196  //
1197  // Unlock the Fcb.
1198  //
1199 
1200  CdUnlockFcb( IrpContext, Fcb );
1201 
1202  //
1203  // We have the starting offset in the directory and whether to return
1204  // that entry or the next. If we are at the beginning of the directory
1205  // and are returning that entry, then tell our caller this is the
1206  // initial query.
1207  //
1208 
1209  *InitialQuery = FALSE;
1210 
1211  if ((DirentOffset == Fcb->StreamOffset) &&
1212  !(*ReturnNextEntry)) {
1213 
1214  *InitialQuery = TRUE;
1215  }
1216 
1217  //
1218  // If there is no file object then create it now.
1219  //
1220 
1221  CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
1222 
1223  //
1224  // Determine the offset in the stream to position the FileContext and
1225  // whether this offset is known to be a file offset.
1226  //
1227  // If this offset is known to be safe then go ahead and position the
1228  // file context. This handles the cases where the offset is the beginning
1229  // of the stream, the offset is from a previous search or this is the
1230  // initial query.
1231  //
1232 
1233  if (KnownOffset) {
1234 
1236 
1237  //
1238  // Otherwise we walk through the directory from the beginning until
1239  // we reach the entry which contains this offset.
1240  //
1241 
1242  } else {
1243 
1244  LastDirentOffset = Fcb->StreamOffset;
1245  Found = TRUE;
1246 
1247  CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, LastDirentOffset );
1248 
1249  //
1250  // If the requested offset is prior to the beginning offset in the stream
1251  // then don't return the next entry.
1252  //
1253 
1254  if (DirentOffset < LastDirentOffset) {
1255 
1256  *ReturnNextEntry = FALSE;
1257 
1258  //
1259  // Else look for the last entry which ends past the desired index.
1260  //
1261 
1262  } else {
1263 
1264  //
1265  // Keep walking through the directory until we run out of
1266  // entries or we find an entry which ends beyond the input
1267  // index value.
1268  //
1269 
1270  do {
1271 
1272  //
1273  // If we have passed the index value then exit.
1274  //
1275 
1276  if (FileContext->InitialDirent->Dirent.DirentOffset > DirentOffset) {
1277 
1278  Found = FALSE;
1279  break;
1280  }
1281 
1282  //
1283  // Remember the current position in case we need to go back.
1284  //
1285 
1286  LastDirentOffset = FileContext->InitialDirent->Dirent.DirentOffset;
1287 
1288  //
1289  // Exit if the next entry is beyond the desired index value.
1290  //
1291 
1292  if (LastDirentOffset + FileContext->InitialDirent->Dirent.DirentLength > DirentOffset) {
1293 
1294  break;
1295  }
1296 
1298 
1299  } while (Found);
1300 
1301  //
1302  // If we didn't find the entry then go back to the last known entry.
1303  // This can happen if the index lies in the unused range at the
1304  // end of a sector.
1305  //
1306 
1307  if (!Found) {
1308 
1309  CdCleanupFileContext( IrpContext, FileContext );
1310  CdInitializeFileContext( IrpContext, FileContext );
1311 
1312  CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, LastDirentOffset );
1313  }
1314  }
1315  }
1316 
1317  //
1318  // Only update the dirent name if we will need it for some reason.
1319  // Don't update this name if we are returning the next entry and
1320  // the search string has a version component.
1321  //
1322 
1323  FileContext->ShortName.FileName.Length = 0;
1324 
1325  if (!(*ReturnNextEntry) ||
1326  (Ccb->SearchExpression.VersionString.Length == 0)) {
1327 
1328  //
1329  // Update the name in the dirent into filename and version components.
1330  //
1331 
1332  CdUpdateDirentName( IrpContext,
1333  &FileContext->InitialDirent->Dirent,
1335  }
1336 
1337  //
1338  // Look at the flag in the IrpSp indicating whether to return just
1339  // one entry.
1340  //
1341 
1343 
1345 
1347  }
1348 
1349  return;
1350 }
UNICODE_STRING VersionString
Definition: cdstruc.h:256
#define CCB_FLAG_ENUM_MATCH_ALL
Definition: cdstruc.h:1122
VOID CdCleanupFileContext(_In_ PIRP_CONTEXT IrpContext, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1636
#define CCB_FLAG_ENUM_RETURN_NEXT
Definition: cdstruc.h:1124
#define TAG_ENUM_EXPRESSION
Definition: cdprocs.h:80
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
NTSTATUS RtlUpcaseUnicodeString(PUNICODE_STRING dst, PUNICODE_STRING src, BOOLEAN Alloc)
Definition: string_lib.cpp:46
#define Add2Ptr(PTR, INC)
PVOID NTAPI FsRtlAllocatePoolWithTag(IN POOL_TYPE PoolType, IN ULONG NumberOfBytes, IN ULONG Tag)
Definition: filter.c:229
#define SL_INDEX_SPECIFIED
Definition: iotypes.h:1793
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
Dirent DirentOffset
Definition: dirsup.c:444
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN ReturnSingleEntry
Definition: fltkernel.h:2295
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
struct _FCB * RootIndexFcb
Definition: cdstruc.h:566
uint16_t * PWCHAR
Definition: typedefs.h:54
BOOLEAN NTAPI FsRtlDoesNameContainWildCards(IN PUNICODE_STRING Name)
Definition: name.c:464
#define PAGED_CODE()
Definition: video.h:57
#define CdUnlockFcb(IC, F)
Definition: cdprocs.h:1065
#define CCB_FLAG_ENUM_VERSION_EXP_HAS_WILD
Definition: cdstruc.h:1121
#define CCB_FLAG_ENUM_VERSION_MATCH_ALL
Definition: cdstruc.h:1123
#define CCB_FLAG_ENUM_INITIALIZED
Definition: cdstruc.h:1125
CdLookupInitialFileDirent(IrpContext, Fcb, FileContext, Fcb->StreamOffset)
#define CCB_FLAG_IGNORE_CASE
Definition: cdstruc.h:1111
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define CCB_FLAG_ENUM_NOMATCH_CONSTANT_ENTRY
Definition: cdstruc.h:1126
return Found
Definition: dirsup.c:1270
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: cdprocs.h:444
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
CdVerifyOrCreateDirStreamFile(IrpContext, Fcb)
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
#define CdPagedPool
Definition: cdprocs.h:1385
#define CCB_FLAG_ENUM_NAME_EXP_HAS_WILD
Definition: cdstruc.h:1120
ULONG Flags
Definition: ntfs.h:520
static const WCHAR L[]
Definition: oid.c:1250
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:593
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
Status
Definition: gdiplustypes.h:24
#define CdLockFcb(IC, F)
Definition: cdprocs.h:1049
struct _FileName FileName
Definition: fatprocs.h:884
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define SL_RETURN_SINGLE_ENTRY
Definition: iotypes.h:1792
#define CdFreePool(x)
Definition: cdprocs.h:2200
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1869
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4157
#define SL_RESTART_SCAN
Definition: iotypes.h:1791
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
PVCB Vcb
Definition: cdstruc.h:939
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2771
_In_ PFCB Fcb
Definition: cdprocs.h:151
return STATUS_SUCCESS
Definition: btrfs.c:2777
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1111
UNICODE_STRING FileName
Definition: cdstruc.h:250
#define CdInitializeFileContext(IC, FC)
Definition: cdprocs.h:532
#define NT_ASSERT
Definition: rtlfuncs.h:3312