ReactOS 0.4.16-dev-250-g3ecd236
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,
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}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define PAGED_CODE()
LONG NTSTATUS
Definition: precomp.h:26
VOID CdCompleteRequest(_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
Definition: cddata.c:914
@ UserDirectoryOpen
Definition: cdprocs.h:576
_In_ PFCB Fcb
Definition: cdprocs.h:159
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:592
_In_ PIRP Irp
Definition: csq.h:116
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
Status
Definition: gdiplustypes.h:25
#define IRP_MN_QUERY_DIRECTORY
Definition: rdpdr.c:55
#define IRP_MN_NOTIFY_CHANGE_DIRECTORY
Definition: rdpdr.c:56
Definition: cdstruc.h:1067
Definition: cdstruc.h:902
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

◆ 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
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}
unsigned char BOOLEAN
#define CD_ATTRIBUTE_ASSOC
Definition: cd.h:355
return Found
Definition: dirsup.c:1270
VOID CdLookupLastFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1426
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: cdprocs.h:442
BOOLEAN CdIsNameInExpression(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
Definition: namesup.c:844
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
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
BOOLEAN CdIs8dot3Name(_In_ PIRP_CONTEXT IrpContext, _In_ UNICODE_STRING FileName)
Definition: namesup.c:429
#define CCB_FLAG_IGNORE_CASE
Definition: cdstruc.h:1105
#define DIRENT_FLAG_CONSTANT_ENTRY
Definition: cdstruc.h:1671
#define CCB_FLAG_ENUM_MATCH_ALL
Definition: cdstruc.h:1116
#define CCB_FLAG_ENUM_NOMATCH_CONSTANT_ENTRY
Definition: cdstruc.h:1120
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
UNICODE_STRING FileName
Definition: cdstruc.h:244
UCHAR DirentFlags
Definition: cdstruc.h:1613
CD_NAME CdFileName
Definition: cdstruc.h:1656
UCHAR Flags
Definition: cdstruc.h:1619
ULONG DirentOffset
Definition: cdstruc.h:1585
CD_NAME CdCaseFileName
Definition: cdstruc.h:1657
ULONG Flags
Definition: ntfs.h:536
struct _FCB::@729::@732 Fcb
FILE_NAME_NODE ShortName
Definition: fatstruc.h:1115

◆ 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
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
962
963 CdLockFcb( IrpContext, Fcb );
964
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
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
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
1073
1075 FileName,
1076 FALSE );
1077
1078 //
1079 // This should never fail.
1080 //
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
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
1170
1171 KnownOffset = FALSE;
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}
Dirent DirentOffset
Definition: dirsup.c:444
static INLINE VOID CdVerifyOrCreateDirStreamFile(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)
Definition: cdprocs.h:242
#define CdLockFcb(IC, F)
Definition: cdprocs.h:1044
#define CdInitializeFileContext(IC, FC)
Definition: cdprocs.h:527
#define TAG_ENUM_EXPRESSION
Definition: cdprocs.h:88
#define CdLookupInitialFileDirent(IC, F, FC, DO)
Definition: cdprocs.h:551
#define CdFreePool(x)
Definition: cdprocs.h:2190
#define CdPagedPool
Definition: cdprocs.h:1380
VOID CdCleanupFileContext(_In_ PIRP_CONTEXT IrpContext, _In_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1636
#define CdUnlockFcb(IC, F)
Definition: cdprocs.h:1060
#define CdRaiseStatus(IC, S)
Definition: cdprocs.h:1859
#define CCB_FLAG_ENUM_RETURN_NEXT
Definition: cdstruc.h:1118
#define CCB_FLAG_ENUM_NAME_EXP_HAS_WILD
Definition: cdstruc.h:1114
#define CCB_FLAG_ENUM_INITIALIZED
Definition: cdstruc.h:1119
#define CCB_FLAG_ENUM_VERSION_EXP_HAS_WILD
Definition: cdstruc.h:1115
#define CCB_FLAG_ENUM_VERSION_MATCH_ALL
Definition: cdstruc.h:1117
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
NTSTATUS RtlUpcaseUnicodeString(PUNICODE_STRING dst, PUNICODE_STRING src, BOOLEAN Alloc)
Definition: string_lib.cpp:46
#define ClearFlag(_F, _SF)
Definition: ext2fs.h:191
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
struct _FileName FileName
Definition: fatprocs.h:897
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ BOOLEAN ReturnSingleEntry
Definition: fltkernel.h:2295
#define Add2Ptr(PTR, INC)
if(dx< 0)
Definition: linetemp.h:194
PVOID NTAPI FsRtlAllocatePoolWithTag(IN POOL_TYPE PoolType, IN ULONG NumberOfBytes, IN ULONG Tag)
Definition: filter.c:229
BOOLEAN NTAPI FsRtlDoesNameContainWildCards(IN PUNICODE_STRING Name)
Definition: name.c:464
#define L(x)
Definition: ntvdm.h:50
#define STATUS_SUCCESS
Definition: shellext.h:65
#define __analysis_assert(e)
Definition: specstrings.h:259
UNICODE_STRING VersionString
Definition: cdstruc.h:250
PVCB Vcb
Definition: cdstruc.h:933
union _IO_STACK_LOCATION::@1579 Parameters
struct _IO_STACK_LOCATION::@3978::@3984 QueryDirectory
USHORT MaximumLength
Definition: env_spec_w32.h:370
struct _FCB * RootIndexFcb
Definition: cdstruc.h:560
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define SL_INDEX_SPECIFIED
Definition: iotypes.h:1837
#define SL_RETURN_SINGLE_ENTRY
Definition: iotypes.h:1836
#define SL_RESTART_SCAN
Definition: iotypes.h:1835
#define NT_ASSERT
Definition: rtlfuncs.h:3327
__wchar_t WCHAR
Definition: xmlstorage.h:180