FSRTL_ADVANCED_FCB_HEADER structure

The FSRTL_ADVANCED_FCB_HEADER structure contains context information that a file system maintains about a file.

Syntax

typedef struct _FSRTL_ADVANCED_FCB_HEADER {
  struct {
    FSRTL_COMMON_FCB_HEADER DUMMYSTRUCTNAME;
    PFAST_MUTEX             FastMutex;
    LIST_ENTRY              FilterContexts;
    EX_PUSH_LOCK            PushLock;
    PVOID                   *FileContextSupportPointer;
    union {
      OPLOCK Oplock;
      PVOID  ReservedForRemote;
    };
    PVOID                   ReservedContext;
  } _FSRTL_ADVANCED_FCB_HEADER;
  struct {
    LIST_ENTRY EofWaitLinks;
    KEVENT     Event;
  } _EOF_WAIT_BLOCK;
  BOOLEAN                                          FsRtlCopyRead( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, BOOLEAN          Wait, ULONG            LockKey, PVOID            Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT   DeviceObject);
  BOOLEAN                                          FsRtlCopyWrite( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, BOOLEAN          Wait, ULONG            LockKey, PVOID            Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT   DeviceObject);
  NTSTATUS                                         FsRtlMdlReadEx( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, ULONG            LockKey, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus);
  BOOLEAN                                          FsRtlMdlReadDev( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, ULONG            LockKey, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT   DeviceObject);
  BOOLEAN                                          FsRtlMdlReadCompleteDev( PFILE_OBJECT   FileObject, PMDL           MdlChain, PDEVICE_OBJECT DeviceObject);
  NTSTATUS                                         FsRtlPrepareMdlWriteEx( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, ULONG            LockKey, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus);
  BOOLEAN                                          FsRtlPrepareMdlWriteDev( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, ULONG            LockKey, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT   DeviceObject);
  BOOLEAN                                          FsRtlMdlWriteCompleteDev( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, PMDL           MdlChain, PDEVICE_OBJECT DeviceObject);
  struct {
    PVOID Buffer;
    ULONG Length;
    ULONG Flags;
    PMDL  Mdl;
  } _FSRTL_AUXILIARY_BUFFER;
  void                                             FsRtlAcquireFileExclusive( PFILE_OBJECT FileObject);
  void                                             FsRtlReleaseFile( PFILE_OBJECT FileObject);
  NTSTATUS                                         FsRtlGetFileSize( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileSize);
  BOOLEAN                                          FsRtlIsTotalDeviceFailure( NTSTATUS Status);
  struct {
    LARGE_INTEGER StartingByte;
    LARGE_INTEGER Length;
    BOOLEAN       ExclusiveLock;
    ULONG         Key;
    PFILE_OBJECT  FileObject;
    PVOID         ProcessId;
    LARGE_INTEGER EndingByte;
  } _FILE_LOCK_INFO;
  struct {
    PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine;
    PUNLOCK_ROUTINE            UnlockRoutine;
    BOOLEAN                    FastIoIsQuestionable;
    BOOLEAN                    SpareC[3];
    PVOID                      LockInformation;
    FILE_LOCK_INFO             LastReturnedLockInfo;
    PVOID                      LastReturnedLock;
    LONG                       LockRequestsInProgress;
  } _FILE_LOCK;
  PFILE_LOCK                                       FsRtlAllocateFileLock( PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine, PUNLOCK_ROUTINE            UnlockRoutine);
  void                                             FsRtlFreeFileLock( PFILE_LOCK FileLock);
  void                                             FsRtlInitializeFileLock( PFILE_LOCK                 FileLock, PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine, PUNLOCK_ROUTINE            UnlockRoutine);
  void                                             FsRtlUninitializeFileLock( PFILE_LOCK FileLock);
  NTSTATUS                                         FsRtlProcessFileLock( PFILE_LOCK FileLock, PIRP       Irp, PVOID      Context);
  BOOLEAN                                          FsRtlCheckLockForReadAccess( PFILE_LOCK FileLock, PIRP       Irp);
  BOOLEAN                                          FsRtlCheckLockForWriteAccess( PFILE_LOCK FileLock, PIRP       Irp);
  BOOLEAN                                          FsRtlCheckLockForOplockRequest( PFILE_LOCK     FileLock, PLARGE_INTEGER AllocationSize);
  BOOLEAN                                          FsRtlFastCheckLockForRead( PFILE_LOCK     FileLock, PLARGE_INTEGER StartingByte, PLARGE_INTEGER Length, ULONG          Key, PFILE_OBJECT   FileObject, PVOID          ProcessId);
  BOOLEAN                                          FsRtlFastCheckLockForWrite( PFILE_LOCK     FileLock, PLARGE_INTEGER StartingByte, PLARGE_INTEGER Length, ULONG          Key, PVOID          FileObject, PVOID          ProcessId);
  PFILE_LOCK_INFO                                  FsRtlGetNextFileLock( PFILE_LOCK FileLock, BOOLEAN    Restart);
  BOOLEAN                                          FsRtlAreThereCurrentOrInProgressFileLocks( PFILE_LOCK FileLock);
  BOOLEAN                                          FsRtlAreThereWaitingFileLocks( PFILE_LOCK FileLock);
  NTSTATUS                                         FsRtlFastUnlockSingle( PFILE_LOCK     FileLock, PFILE_OBJECT   FileObject, LARGE_INTEGER  *FileOffset, PLARGE_INTEGER Length, PEPROCESS      ProcessId, ULONG          Key, PVOID          Context, BOOLEAN        AlreadySynchronized);
  NTSTATUS                                         FsRtlFastUnlockAll( PFILE_LOCK   FileLock, PFILE_OBJECT FileObject, PEPROCESS    ProcessId, PVOID        Context);
  NTSTATUS                                         FsRtlFastUnlockAllByKey( PFILE_LOCK   FileLock, PFILE_OBJECT FileObject, PEPROCESS    ProcessId, ULONG        Key, PVOID        Context);
  BOOLEAN                                          FsRtlPrivateLock( PFILE_LOCK             FileLock, PFILE_OBJECT           FileObject, PLARGE_INTEGER         FileOffset, PLARGE_INTEGER         Length, PEPROCESS              ProcessId, ULONG                  Key, BOOLEAN                FailImmediately, BOOLEAN                ExclusiveLock, PIO_STATUS_BLOCK       Iosb, PIRP                   Irp, __drv_aliasesMem PVOID Context, BOOLEAN                AlreadySynchronized);
  struct {
    FAST_MUTEX       Mutex;
    PRTL_SPLAY_LINKS Cache;
    LIST_ENTRY       TimerQueue;
    USHORT           NumEntries;
  };
  void                                             FsRtlInitializeTunnelCache( TUNNEL *Cache);
  void                                             FsRtlAddToTunnelCache( TUNNEL         *Cache, ULONGLONG      DirectoryKey, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, BOOLEAN        KeyByShortName, ULONG          DataLength, VOID           *Data);
  BOOLEAN                                          FsRtlFindInTunnelCache( TUNNEL         *Cache, ULONGLONG      DirectoryKey, UNICODE_STRING *Name, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG          *DataLength, VOID           *Data);
  void                                             FsRtlAddToTunnelCacheEx( TUNNEL         *Cache, ULONGLONG      DirectoryKey, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG          Flags, ULONG          DataLength, VOID           *Data);
  BOOLEAN                                          FsRtlFindInTunnelCacheEx( TUNNEL         *Cache, ULONGLONG      DirectoryKey, UNICODE_STRING *Name, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG          Flags, ULONG          *DataLength, VOID           *Data);
  void                                             FsRtlDeleteKeyFromTunnelCache( TUNNEL    *Cache, ULONGLONG DirectoryKey);
  void                                             FsRtlDeleteTunnelCache( TUNNEL *Cache);
  UCHAR const                                      *LEGAL_ANSI_CHARACTER_ARRAY;
  PUSHORT                                          NLS_OEM_LEAD_BYTE_INFO;
  void                                             FsRtlDissectDbcs( ANSI_STRING  Path, PANSI_STRING FirstName, PANSI_STRING RemainingName);
  BOOLEAN                                          FsRtlDoesDbcsContainWildCards( PANSI_STRING Name);
  BOOLEAN                                          FsRtlIsDbcsInExpression( PANSI_STRING Expression, PANSI_STRING Name);
  BOOLEAN                                          FsRtlIsFatDbcsLegal( ANSI_STRING DbcsName, BOOLEAN     WildCardsPermissible, BOOLEAN     PathNamePermissible, BOOLEAN     LeadingBackslashPermissible);
  BOOLEAN                                          FsRtlIsHpfsDbcsLegal( ANSI_STRING DbcsName, BOOLEAN     WildCardsPermissible, BOOLEAN     PathNamePermissible, BOOLEAN     LeadingBackslashPermissible);
  NTSTATUS                                         FsRtlNormalizeNtstatus( NTSTATUS Exception, NTSTATUS GenericException);
  BOOLEAN                                          FsRtlIsNtstatusExpected( NTSTATUS Exception);
  PERESOURCE                                       FsRtlAllocateResource( VOID );
  struct {
    ULONG  MaximumPairCount;
    ULONG  PairCount;
    USHORT PoolType;
    USHORT Flags;
    PVOID  Mapping;
  } _BASE_MCB;
  struct {
    PKGUARDED_MUTEX GuardedMutex;
    BASE_MCB        BaseMcb;
  } _LARGE_MCB;
  void                                             FsRtlInitializeLargeMcb( PLARGE_MCB Mcb, POOL_TYPE  PoolType);
  void                                             FsRtlUninitializeLargeMcb( PLARGE_MCB Mcb);
  void                                             FsRtlResetLargeMcb( PLARGE_MCB Mcb, BOOLEAN    SelfSynchronized);
  void                                             FsRtlTruncateLargeMcb( PLARGE_MCB Mcb, LONGLONG   Vbn);
  BOOLEAN                                          FsRtlAddLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG   Vbn, LONGLONG   Lbn, LONGLONG   SectorCount);
  void                                             FsRtlRemoveLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG   Vbn, LONGLONG   SectorCount);
  BOOLEAN                                          FsRtlLookupLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG   Vbn, PLONGLONG  Lbn, PLONGLONG  SectorCountFromLbn, PLONGLONG  StartingLbn, PLONGLONG  SectorCountFromStartingLbn, PULONG     Index);
  BOOLEAN                                          FsRtlLookupLastLargeMcbEntry( PLARGE_MCB Mcb, PLONGLONG  Vbn, PLONGLONG  Lbn);
  BOOLEAN                                          FsRtlLookupLastLargeMcbEntryAndIndex( PLARGE_MCB OpaqueMcb, PLONGLONG  LargeVbn, PLONGLONG  LargeLbn, PULONG     Index);
  ULONG                                            FsRtlNumberOfRunsInLargeMcb( PLARGE_MCB Mcb);
  BOOLEAN                                          FsRtlGetNextLargeMcbEntry( PLARGE_MCB Mcb, ULONG      RunIndex, PLONGLONG  Vbn, PLONGLONG  Lbn, PLONGLONG  SectorCount);
  BOOLEAN                                          FsRtlSplitLargeMcb( PLARGE_MCB Mcb, LONGLONG   Vbn, LONGLONG   Amount);
  void                                             FsRtlInitializeBaseMcb( PBASE_MCB Mcb, POOL_TYPE PoolType);
  BOOLEAN                                          FsRtlInitializeBaseMcbEx( PBASE_MCB Mcb, POOL_TYPE PoolType, USHORT    Flags);
  void                                             FsRtlUninitializeBaseMcb( PBASE_MCB Mcb);
  void                                             FsRtlResetBaseMcb( PBASE_MCB Mcb);
  void                                             FsRtlTruncateBaseMcb( PBASE_MCB Mcb, LONGLONG  Vbn);
  BOOLEAN                                          FsRtlAddBaseMcbEntry( PBASE_MCB Mcb, LONGLONG  Vbn, LONGLONG  Lbn, LONGLONG  SectorCount);
  NTSTATUS                                         FsRtlAddBaseMcbEntryEx( PBASE_MCB Mcb, LONGLONG  Vbn, LONGLONG  Lbn, LONGLONG  SectorCount);
  BOOLEAN                                          FsRtlRemoveBaseMcbEntry( PBASE_MCB Mcb, LONGLONG  Vbn, LONGLONG  SectorCount);
  BOOLEAN                                          FsRtlLookupBaseMcbEntry( PBASE_MCB Mcb, LONGLONG  Vbn, PLONGLONG Lbn, PLONGLONG SectorCountFromLbn, PLONGLONG StartingLbn, PLONGLONG SectorCountFromStartingLbn, PULONG    Index);
  BOOLEAN                                          FsRtlLookupLastBaseMcbEntry( PBASE_MCB Mcb, PLONGLONG Vbn, PLONGLONG Lbn);
  BOOLEAN                                          FsRtlLookupLastBaseMcbEntryAndIndex( PBASE_MCB OpaqueMcb, PLONGLONG LargeVbn, PLONGLONG LargeLbn, PULONG    Index);
  ULONG                                            FsRtlNumberOfRunsInBaseMcb( PBASE_MCB Mcb);
  BOOLEAN                                          FsRtlGetNextBaseMcbEntry( PBASE_MCB Mcb, ULONG     RunIndex, PLONGLONG Vbn, PLONGLONG Lbn, PLONGLONG SectorCount);
  BOOLEAN                                          FsRtlSplitBaseMcb( PBASE_MCB Mcb, LONGLONG  Vbn, LONGLONG  Amount);
  struct {
    LARGE_MCB DummyFieldThatSizesThisStructureCorrectly;
  } _MCB;
  void                                             FsRtlInitializeMcb( PMCB      Mcb, POOL_TYPE PoolType);
  void                                             FsRtlUninitializeMcb( PMCB Mcb);
  void                                             FsRtlTruncateMcb( PMCB Mcb, VBN  Vbn);
  BOOLEAN                                          FsRtlAddMcbEntry( PMCB  Mcb, VBN   Vbn, LBN   Lbn, ULONG SectorCount);
  void                                             FsRtlRemoveMcbEntry( PMCB  Mcb, VBN   Vbn, ULONG SectorCount);
  BOOLEAN                                          FsRtlLookupMcbEntry( PMCB   Mcb, VBN    Vbn, PLBN   Lbn, PULONG SectorCount, PULONG Index);
  BOOLEAN                                          FsRtlLookupLastMcbEntry( PMCB Mcb, PVBN Vbn, PLBN Lbn);
  ULONG                                            FsRtlNumberOfRunsInMcb( PMCB Mcb);
  BOOLEAN                                          FsRtlGetNextMcbEntry( PMCB   Mcb, ULONG  RunIndex, PVBN   Vbn, PLBN   Lbn, PULONG SectorCount);
  NTSTATUS                                         FsRtlBalanceReads( PDEVICE_OBJECT TargetDevice);
  void                                             FsRtlInitializeOplock( POPLOCK Oplock);
  void                                             FsRtlUninitializeOplock( POPLOCK Oplock);
  NTSTATUS                                         FsRtlOplockFsctrl( POPLOCK Oplock, PIRP    Irp, ULONG   OpenCount);
  NTSTATUS                                         FsRtlCheckOplock( POPLOCK                       Oplock, PIRP                          Irp, PVOID                         Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PostIrpRoutine);
  NTSTATUS                                         FsRtlCheckOplockEx( POPLOCK                       Oplock, PIRP                          Irp, ULONG                         Flags, PVOID                         Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PostIrpRoutine);
  NTSTATUS                                         FsRtlCheckUpperOplock( POPLOCK                       Oplock, ULONG                         NewLowerOplockState, PVOID                         CompletionRoutineContext, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PrePendRoutine, ULONG                         Flags);
  NTSTATUS                                         FsRtlUpperOplockFsctrl( POPLOCK Oplock, PIRP    Irp, ULONG   OpenCount, ULONG   LowerOplockState, ULONG   Flags);
  BOOLEAN                                          FsRtlOplockIsFastIoPossible( POPLOCK Oplock);
  BOOLEAN                                          FsRtlCurrentBatchOplock( POPLOCK Oplock);
  BOOLEAN                                          FsRtlCurrentOplock( POPLOCK Oplock);
  NTSTATUS                                         FsRtlOplockBreakToNone( POPLOCK                       Oplock, PIO_STACK_LOCATION            IrpSp, PIRP                          Irp, PVOID                         Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PostIrpRoutine);
  struct {
    GUID  OplockKey;
    ULONG Reserved;
  } _OPLOCK_KEY_ECP_CONTEXT;
  GUID                                             GUID_ECP_OPLOCK_KEY;
  BOOLEAN                                          FsRtlOplockIsSharedRequest( PIRP Irp);
  NTSTATUS                                         FsRtlOplockBreakH( POPLOCK                       Oplock, PIRP                          Irp, ULONG                         Flags, PVOID                         Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PostIrpRoutine);
  BOOLEAN                                          FsRtlCurrentOplockH( POPLOCK Oplock);
  NTSTATUS                                         FsRtlOplockBreakToNoneEx( POPLOCK                       Oplock, PIRP                          Irp, ULONG                         Flags, PVOID                         Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP        PostIrpRoutine);
  NTSTATUS                                         FsRtlOplockFsctrlEx( POPLOCK Oplock, PIRP    Irp, ULONG   OpenCount, ULONG   Flags);
  BOOLEAN                                          FsRtlOplockKeysEqual( PFILE_OBJECT Fo1, PFILE_OBJECT Fo2);
  struct {
    GUID    ParentOplockKey;
    GUID    TargetOplockKey;
    BOOLEAN ParentOplockKeySet;
    BOOLEAN TargetOplockKeySet;
  } _DUAL_OPLOCK_KEY_ECP_CONTEXT;
  GUID                                             GUID_ECP_DUAL_OPLOCK_KEY;
  NTSTATUS                                         FsRtlNotifyVolumeEvent( PFILE_OBJECT FileObject, ULONG        EventCode);
  NTSTATUS                                         FsRtlNotifyVolumeEventEx( PFILE_OBJECT                       FileObject, ULONG                              EventCode, PTARGET_DEVICE_CUSTOM_NOTIFICATION Event);
  struct                                           _REAL_NOTIFY_SYNC;
  void                                             FsRtlNotifyInitializeSync( PNOTIFY_SYNC *NotifySync);
  void                                             FsRtlNotifyUninitializeSync( PNOTIFY_SYNC *NotifySync);
  void                                             FsRtlNotifyFullChangeDirectory( PNOTIFY_SYNC               NotifySync, PLIST_ENTRY                NotifyList, PVOID                      FsContext, PSTRING                    FullDirectoryName, BOOLEAN                    WatchTree, BOOLEAN                    IgnoreBuffer, ULONG                      CompletionFilter, PIRP                       NotifyIrp, PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback, PSECURITY_SUBJECT_CONTEXT  SubjectContext);
  void                                             FsRtlNotifyFilterChangeDirectory( PNOTIFY_SYNC               NotifySync, PLIST_ENTRY                NotifyList, PVOID                      FsContext, PSTRING                    FullDirectoryName, BOOLEAN                    WatchTree, BOOLEAN                    IgnoreBuffer, ULONG                      CompletionFilter, PIRP                       NotifyIrp, PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback, PSECURITY_SUBJECT_CONTEXT  SubjectContext, PFILTER_REPORT_CHANGE      FilterCallback);
  void                                             FsRtlNotifyFilterReportChange( PNOTIFY_SYNC NotifySync, PLIST_ENTRY  NotifyList, PSTRING      FullTargetName, USHORT       TargetNameOffset, PSTRING      StreamName, PSTRING      NormalizedParentName, ULONG        FilterMatch, ULONG        Action, PVOID        TargetContext, PVOID        FilterContext);
  void                                             FsRtlNotifyFullReportChange( PNOTIFY_SYNC NotifySync, PLIST_ENTRY  NotifyList, PSTRING      FullTargetName, USHORT       TargetNameOffset, PSTRING      StreamName, PSTRING      NormalizedParentName, ULONG        FilterMatch, ULONG        Action, PVOID        TargetContext);
  void                                             FsRtlNotifyCleanup( PNOTIFY_SYNC NotifySync, PLIST_ENTRY  NotifyList, PVOID        FsContext);
  void                                             FsRtlNotifyCleanupAll( PNOTIFY_SYNC NotifySync, PLIST_ENTRY  NotifyList);
  void                                             FsRtlDissectName( UNICODE_STRING  Path, PUNICODE_STRING FirstName, PUNICODE_STRING RemainingName);
  BOOLEAN                                          FsRtlDoesNameContainWildCards( PUNICODE_STRING Name);
  BOOLEAN                                          FsRtlAreNamesEqual( PCUNICODE_STRING ConstantNameA, PCUNICODE_STRING ConstantNameB, BOOLEAN          IgnoreCase, PCWCH            UpcaseTable);
  BOOLEAN                                          FsRtlIsNameInExpression( PUNICODE_STRING Expression, PUNICODE_STRING Name, BOOLEAN         IgnoreCase, PWCH            UpcaseTable);
  BOOLEAN                                          FsRtlIsNameInUnUpcasedExpression( PUNICODE_STRING Expression, PUNICODE_STRING Name, BOOLEAN         IgnoreCase, PWCH            UpcaseTable);
  void                                             FsRtlPostStackOverflow( PVOID                         Context, PKEVENT                       Event, PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine);
  void                                             FsRtlPostPagingFileStackOverflow( PVOID                         Context, PKEVENT                       Event, PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine);
  NTSTATUS                                         FsRtlRegisterUncProvider( PHANDLE          MupHandle, PCUNICODE_STRING RedirectorDeviceName, BOOLEAN          MailslotsSupported);
  NTSTATUS                                         FsRtlRegisterUncProviderEx( PHANDLE                  MupHandle, PCUNICODE_STRING         RedirDevName, PDEVICE_OBJECT           DeviceObject, FSRTL_UNC_PROVIDER_FLAGS Flags);
  struct {
    USHORT Size;
    USHORT Version;
    union {
      FSRTL_UNC_PROVIDER_FLAGS ProviderFlags;
      struct {
        ULONG MailslotsSupported : 1;
        ULONG CscEnabled : 1;
        ULONG DomainSvcAware : 1;
        ULONG ContainersAware : 1;
      } DUMMYSTRUCTNAME;
    } DUMMYUNIONNAME;
    union {
      FSRTL_UNC_HARDENING_CAPABILITIES HardeningCapabilities;
      struct {
        ULONG SupportsMutualAuth : 1;
        ULONG SupportsIntegrity : 1;
        ULONG SupportsPrivacy : 1;
      } DUMMYSTRUCTNAME;
    } DUMMYUNIONNAME2;
  } _FSRTL_UNC_PROVIDER_REGISTRATION;
  NTSTATUS                                         FsRtlRegisterUncProviderEx2( PCUNICODE_STRING                      RedirDevName, PDEVICE_OBJECT                        DeviceObject, const FSRTL_UNC_PROVIDER_REGISTRATION *Registration, PHANDLE                               MupHandle);
  void                                             FsRtlDeregisterUncProvider( HANDLE Handle);
  NTSTATUS                                         FsRtlCancellableWaitForSingleObject( PVOID          Object, PLARGE_INTEGER Timeout, PIRP           Irp);
  NTSTATUS                                         FsRtlCancellableWaitForMultipleObjects( ULONG          Count, PVOID []       ObjectArray, WAIT_TYPE      WaitType, PLARGE_INTEGER Timeout, PKWAIT_BLOCK   WaitBlockArray, PIRP           Irp);
  NTSTATUS                                         FsRtlMupGetProviderInfoFromFileObject( PFILE_OBJECT pFileObject, ULONG        Level, PVOID        pBuffer, PULONG       pBufferSize);
  struct {
    ULONG32 ProviderId;
  } _FSRTL_MUP_PROVIDER_INFO_LEVEL_1;
  struct {
    ULONG32        ProviderId;
    UNICODE_STRING ProviderName;
  } _FSRTL_MUP_PROVIDER_INFO_LEVEL_2;
  NTSTATUS                                         FsRtlMupGetProviderIdFromName( PCUNICODE_STRING pProviderName, PULONG32         pProviderId);
  struct {
    LIST_ENTRY     Links;
    PVOID          OwnerId;
    PVOID          InstanceId;
    PFREE_FUNCTION FreeCallback;
  } _FSRTL_PER_FILE_CONTEXT;
  NTSTATUS                                         FsRtlInsertPerFileContext( PVOID                   *PerFileContextPointer, PFSRTL_PER_FILE_CONTEXT Ptr);
  PFSRTL_PER_FILE_CONTEXT                          FsRtlLookupPerFileContext( PVOID *PerFileContextPointer, PVOID OwnerId, PVOID InstanceId);
  PFSRTL_PER_FILE_CONTEXT                          FsRtlRemovePerFileContext( PVOID *PerFileContextPointer, PVOID OwnerId, PVOID InstanceId);
  void                                             FsRtlTeardownPerFileContexts( PVOID *PerFileContextPointer);
  struct {
    LIST_ENTRY     Links;
    PVOID          OwnerId;
    PVOID          InstanceId;
    PFREE_FUNCTION FreeCallback;
  } _FSRTL_PER_STREAM_CONTEXT;
  NTSTATUS                                         FsRtlInsertPerStreamContext( PFSRTL_ADVANCED_FCB_HEADER PerStreamContext, PFSRTL_PER_STREAM_CONTEXT  Ptr);
  PFSRTL_PER_STREAM_CONTEXT                        FsRtlLookupPerStreamContextInternal( PFSRTL_ADVANCED_FCB_HEADER StreamContext, PVOID                      OwnerId, PVOID                      InstanceId);
  PFSRTL_PER_STREAM_CONTEXT                        FsRtlRemovePerStreamContext( PFSRTL_ADVANCED_FCB_HEADER StreamContext, PVOID                      OwnerId, PVOID                      InstanceId);
  void                                             FsRtlSetupAdvancedHeader( PVOID       AdvHdr, PFAST_MUTEX FMutex);
  void                                             FsRtlTeardownPerStreamContexts( PFSRTL_ADVANCED_FCB_HEADER AdvancedHeader);
  struct {
    LIST_ENTRY Links;
    PVOID      OwnerId;
    PVOID      InstanceId;
  } _FSRTL_PER_FILEOBJECT_CONTEXT;
  NTSTATUS                                         FsRtlInsertPerFileObjectContext( PFILE_OBJECT                  FileObject, PFSRTL_PER_FILEOBJECT_CONTEXT Ptr);
  PFSRTL_PER_FILEOBJECT_CONTEXT                    FsRtlLookupPerFileObjectContext( PFILE_OBJECT FileObject, PVOID        OwnerId, PVOID        InstanceId);
  PFSRTL_PER_FILEOBJECT_CONTEXT                    FsRtlRemovePerFileObjectContext( PFILE_OBJECT FileObject, PVOID        OwnerId, PVOID        InstanceId);
  void                                             FsRtlIncrementCcFastReadNotPossible( VOID );
  void                                             FsRtlIncrementCcFastReadWait( VOID );
  void                                             FsRtlIncrementCcFastReadNoWait( VOID );
  void                                             FsRtlIncrementCcFastReadResourceMiss( VOID );
  void                                             FsRtlIncrementCcFastMdlReadWait( VOID );
  LOGICAL                                          FsRtlIsPagingFile( PFILE_OBJECT FileObject);
  LOGICAL                                          FsRtlIsSystemPagingFile( PFILE_OBJECT FileObject);
  NTSTATUS                                         FsRtlCreateSectionForDataScan( PHANDLE            SectionHandle, PVOID              *SectionObject, PLARGE_INTEGER     SectionFileSize, PFILE_OBJECT       FileObject, ACCESS_MASK        DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER     MaximumSize, ULONG              SectionPageProtection, ULONG              AllocationAttributes, ULONG              Flags);
  NTSTATUS                                         FsRtlValidateReparsePointBuffer( ULONG                BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer);
  NTSTATUS                                         FsRtlRemoveDotsFromPath( PWSTR  OriginalString, USHORT PathLength, USHORT *NewLength);
  BOOLEAN                                          FsRtlIsNonEmptyDirectoryReparsePointAllowed( ULONG ReparseTag);
  struct                                           _ECP_LIST;
  struct                                           _ECP_HEADER;
  NTSTATUS                                         FsRtlAllocateExtraCreateParameterList( FSRTL_ALLOCATE_ECPLIST_FLAGS Flags, PECP_LIST                    *EcpList);
  void                                             FsRtlFreeExtraCreateParameterList( PECP_LIST EcpList);
  NTSTATUS                                         FsRtlInitializeExtraCreateParameterList( PECP_LIST EcpList);
  NTSTATUS                                         FsRtlAllocateExtraCreateParameter( LPCGUID                                        EcpType, ULONG                                          SizeOfContext, FSRTL_ALLOCATE_ECP_FLAGS                       Flags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, ULONG                                          PoolTag, PVOID                                          *EcpContext);
  void                                             FsRtlFreeExtraCreateParameter( PVOID EcpContext);
  void                                             FsRtlInitializeExtraCreateParameter( PECP_HEADER                                    Ecp, ULONG                                          EcpFlags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, ULONG                                          TotalSize, LPCGUID                                        EcpType, PVOID                                          ListAllocatedFrom);
  void                                             FsRtlInitExtraCreateParameterLookasideList( PVOID                     Lookaside, FSRTL_ECP_LOOKASIDE_FLAGS Flags, SIZE_T                    Size, ULONG                     Tag);
  void                                             FsRtlDeleteExtraCreateParameterLookasideList( PVOID                     Lookaside, FSRTL_ECP_LOOKASIDE_FLAGS Flags);
  NTSTATUS                                         FsRtlAllocateExtraCreateParameterFromLookasideList( LPCGUID                                        EcpType, ULONG                                          SizeOfContext, FSRTL_ALLOCATE_ECP_FLAGS                       Flags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, PVOID                                          LookasideList, PVOID                                          *EcpContext);
  NTSTATUS                                         FsRtlInsertExtraCreateParameter( PECP_LIST EcpList, PVOID     EcpContext);
  NTSTATUS                                         FsRtlFindExtraCreateParameter( PECP_LIST EcpList, LPCGUID   EcpType, PVOID     *EcpContext, ULONG     *EcpContextSize);
  NTSTATUS                                         FsRtlRemoveExtraCreateParameter( PECP_LIST EcpList, LPCGUID   EcpType, PVOID     *EcpContext, ULONG     *EcpContextSize);
  NTSTATUS                                         FsRtlGetEcpListFromIrp( PIRP      Irp, PECP_LIST *EcpList);
  NTSTATUS                                         FsRtlSetEcpListIntoIrp( PIRP      Irp, PECP_LIST EcpList);
  NTSTATUS                                         FsRtlGetNextExtraCreateParameter( PECP_LIST EcpList, PVOID     CurrentEcpContext, LPGUID    NextEcpType, PVOID     *NextEcpContext, ULONG     *NextEcpContextSize);
  void                                             FsRtlAcknowledgeEcp( PVOID EcpContext);
  void                                             FsRtlPrepareToReuseEcp( PVOID EcpContext);
  BOOLEAN                                          FsRtlIsEcpAcknowledged( PVOID EcpContext);
  BOOLEAN                                          FsRtlIsEcpFromUserMode( PVOID EcpContext);
#if ...
  struct {
    USHORT Size;
    USHORT Reserved;
    struct {
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
        NETWORK_OPEN_IN_FLAGS            Flags;
      } in;
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
        NETWORK_OPEN_OUT_FLAGS           Flags;
      } out;
    } DUMMYSTRUCTNAME;
  } _NETWORK_OPEN_ECP_CONTEXT;
  struct {
    USHORT Size;
    USHORT Reserved;
    struct {
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
      } in;
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
      } out;
    } DUMMYSTRUCTNAME;
  } _NETWORK_OPEN_ECP_CONTEXT_V0;
#else
  struct {
    USHORT Size;
    USHORT Reserved;
    struct {
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
      } in;
      struct {
        NETWORK_OPEN_LOCATION_QUALIFIER  Location;
        NETWORK_OPEN_INTEGRITY_QUALIFIER Integrity;
      } out;
    } DUMMYSTRUCTNAME;
  } _NETWORK_OPEN_ECP_CONTEXT;
#endif
  GUID                                             GUID_ECP_NETWORK_OPEN_CONTEXT;
  struct {
    USHORT Size;
    USHORT Reserved;
    GUID   AppInstanceID;
  } _NETWORK_APP_INSTANCE_ECP_CONTEXT;
  GUID                                             GUID_ECP_NETWORK_APP_INSTANCE;
  struct {
    USHORT Size;
    USHORT Reserved;
    UINT64 VersionHigh;
    UINT64 VersionLow;
  } _NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT;
  GUID                                             GUID_ECP_NETWORK_APP_INSTANCE_VERSION;
  struct {
    PVOID Context;
  } _PREFETCH_OPEN_ECP_CONTEXT;
  GUID                                             GUID_ECP_PREFETCH_OPEN;
  struct                                           sockaddr_storage;
  GUID                                             GUID_ECP_NFS_OPEN;
  struct {
    PUNICODE_STRING       ExportAlias;
    PSOCKADDR_STORAGE_NFS ClientSocketAddress;
  } _NFS_OPEN_ECP_CONTEXT;
  GUID                                             GUID_ECP_SRV_OPEN;
  struct {
    PUNICODE_STRING       ShareName;
    PSOCKADDR_STORAGE_NFS SocketAddress;
    BOOLEAN               OplockBlockState;
    BOOLEAN               OplockAppState;
    BOOLEAN               OplockFinalState;
    USHORT                Version;
    SRV_INSTANCE_TYPE     InstanceType;
  } _SRV_OPEN_ECP_CONTEXT;
  GUID                                             GUID_ECP_RKF_BYPASS;
  struct {
    INT Reserved;
    INT Version;
  } _RKF_BYPASS_ECP_CONTEXT;
  GUID                                             GUID_ECP_IO_DEVICE_HINT;
  struct {
    PDEVICE_OBJECT TargetDevice;
    UNICODE_STRING RemainingName;
  } _IO_DEVICE_HINT_ECP_CONTEXT;
  GUID                                             GUID_ECP_CSV_DOWN_LEVEL_OPEN;
  struct {
    ULONG                    Version;
    BOOLEAN                  IsResume;
    CSV_DOWN_LEVEL_FILE_TYPE FileType;
    ULONG                    SourceNodeId;
    ULONG                    DestinationNodeId;
  } _CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT;
  GUID                                             GUID_ECP_CSV_QUERY_FILE_REVISION;
  struct {
    LONGLONG FileId;
    LONGLONG FileRevision[3];
  } _CSV_QUERY_FILE_REVISION_ECP_CONTEXT;
  GUID                                             GUID_ECP_CSV_QUERY_FILE_REVISION_FILE_ID_128;
  struct {
    FILE_ID_128 FileId;
    LONGLONG    FileRevision[3];
  } _CSV_QUERY_FILE_REVISION_ECP_CONTEXT_FILE_ID_128;
  GUID                                             GUID_ECP_CSV_SET_HANDLE_PROPERTIES;
  struct {
    SIZE_T Size;
    ULONG  PauseTimeoutInSeconds;
    ULONG  Flags;
  } _CSV_SET_HANDLE_PROPERTIES_ECP_CONTEXT;
  struct {
    LIST_ENTRY OpenReparseListEntry;
    ULONG      ReparseTag;
    ULONG      Flags;
    GUID       ReparseGuid;
    USHORT     Size;
    USHORT     RemainingLength;
  } _OPEN_REPARSE_LIST_ENTRY;
  struct {
    LIST_ENTRY OpenReparseList;
  } _OPEN_REPARSE_LIST;
  GUID                                             ECP_TYPE_OPEN_REPARSE_GUID;
  struct {
    struct {
      ULONG ReparseCount;
      ULONG RemainingPathLength;
    } Out;
  } _IO_STOP_ON_SYMLINK_FILTER_ECP_v0;
  GUID                                             ECP_TYPE_IO_STOP_ON_SYMLINK_FILTER_GUID;
  GUID                                             ECP_TYPE_CLFS_CREATE_CONTAINER;
  GUID                                             GUID_ECP_CREATE_REDIRECTION;
  struct {
    USHORT      Size;
    USHORT      Flags;
    FILE_ID_128 FileId;
    GUID        VolumeGuid;
  } _CREATE_REDIRECTION_ECP_CONTEXT;
  struct {
    LARGE_INTEGER CreationTime;
    LARGE_INTEGER LastAccessTime;
    LARGE_INTEGER LastWriteTime;
    LARGE_INTEGER ChangeTime;
  } _FILE_TIMESTAMPS;
  struct {
    USHORT               Size;
    USHORT               InFlags;
    USHORT               OutFlags;
    USHORT               ReparseBufferLength;
    PREPARSE_DATA_BUFFER ReparseBuffer;
    LONGLONG             FileSize;
    LONGLONG             ValidDataLength;
    PFILE_TIMESTAMPS     FileTimestamps;
    ULONG                FileAttributes;
    ULONG                UsnSourceInfo;
    USN                  Usn;
    ULONG                SuppressFileAttributeInheritanceMask;
    ULONG                InOpFlags;
    ULONG                OutOpFlags;
    ULONG                InGenFlags;
    ULONG                OutGenFlags;
    ULONG                CaseSensitiveFlagsMask;
    ULONG                InCaseSensitiveFlags;
    ULONG                OutCaseSensitiveFlags;
  } _ATOMIC_CREATE_ECP_CONTEXT;
  GUID                                             GUID_ECP_ATOMIC_CREATE;
  struct {
    USHORT Size;
    USHORT Reserved;
    ULONG  Flags;
  } _ECP_OPEN_PARAMETERS;
  GUID                                             GUID_ECP_OPEN_PARAMETERS;
  struct {
    LARGE_INTEGER FileId;
    LARGE_INTEGER CreationTime;
    LARGE_INTEGER LastAccessTime;
    LARGE_INTEGER LastWriteTime;
    LARGE_INTEGER ChangeTime;
    LARGE_INTEGER AllocationSize;
    LARGE_INTEGER EndOfFile;
    ULONG         FileAttributes;
    ULONG         ReparseTag;
    ULONG         NumberOfLinks;
  } _QUERY_ON_CREATE_FILE_STAT_INFORMATION;
  struct {
    ACCESS_MASK EffectiveAccess;
    ULONG       LxFlags;
    ULONG       LxUid;
    ULONG       LxGid;
    ULONG       LxMode;
    ULONG       LxDeviceIdMajor;
    ULONG       LxDeviceIdMinor;
  } _QUERY_ON_CREATE_FILE_LX_INFORMATION;
  struct {
    ULONG                                 Flags;
    QUERY_ON_CREATE_FILE_STAT_INFORMATION StatInformation;
    QUERY_ON_CREATE_FILE_LX_INFORMATION   LxInformation;
  } _QUERY_ON_CREATE_ECP_CONTEXT;
  GUID                                             GUID_ECP_QUERY_ON_CREATE;
  NTSTATUS                                         FsRtlChangeBackingFileObject( PFILE_OBJECT              CurrentFileObject, PFILE_OBJECT              NewFileObject, FSRTL_CHANGE_BACKING_TYPE ChangeBackingType, ULONG                     Flags);
  NTSTATUS                                         FsRtlLogCcFlushError( PUNICODE_STRING          FileName, PDEVICE_OBJECT           DeviceObject, PSECTION_OBJECT_POINTERS SectionObjectPointer, NTSTATUS                 FlushError, ULONG                    Flags);
  BOOLEAN                                          FsRtlAreVolumeStartupApplicationsComplete( VOID );
  ULONG                                            FsRtlQueryMaximumVirtualDiskNestingLevel( VOID );
  NTSTATUS                                         FsRtlGetVirtualDiskNestingLevel( PDEVICE_OBJECT DeviceObject, PULONG         NestingLevel, PULONG         NestingFlags);
  NTSTATUS                                         FsRtlVolumeDeviceToCorrelationId( PDEVICE_OBJECT VolumeDeviceObject, GUID           *Guid);
  NTSTATUS                                         FsRtlIssueDeviceIoControl( PDEVICE_OBJECT DeviceObject, ULONG          IoCtl, UCHAR          Flags, PVOID          InputBuffer, ULONG          InputBufferLength, PVOID          OutputBuffer, ULONG          OutputBufferLength, PULONG_PTR     IosbInformation);
  NTSTATUS                                         FsRtlGetSectorSizeInformation( PDEVICE_OBJECT                   DeviceObject, PFILE_FS_SECTOR_SIZE_INFORMATION SectorSizeInfo);
  NTSTATUS                                         FsRtlGetSupportedFeatures( PDEVICE_OBJECT DeviceObject, PULONG         SupportedFeatures);
  NTSTATUS                                         FsRtlKernelFsControlFile( PFILE_OBJECT FileObject, ULONG        FsControlCode, PVOID        InputBuffer, ULONG        InputBufferLength, PVOID        OutputBuffer, ULONG        OutputBufferLength, PULONG       RetOutputBufferSize);
  NTSTATUS                                         FsRtlQueryKernelEaFile( PFILE_OBJECT FileObject, PVOID        ReturnedEaData, ULONG        Length, BOOLEAN      ReturnSingleEntry, PVOID        EaList, ULONG        EaListLength, PULONG       EaIndex, BOOLEAN      RestartScan, PULONG       LengthReturned);
  NTSTATUS                                         FsRtlSetKernelEaFile( PFILE_OBJECT FileObject, PVOID        EaBuffer, ULONG        Length);
  NTSTATUS                                         FsRtlQueryInformationFile( PFILE_OBJECT           FileObject, PVOID                  FileInformation, ULONG                  Length, FILE_INFORMATION_CLASS FileInformationClass, PULONG                 RetFileInformationSize);
  NTSTATUS                                         FsRtlQueryCachedVdl( PFILE_OBJECT FileObject, PLONGLONG    Vdl);
  void                                             FsRtlUpdateDiskCounters( ULONG64 BytesRead, ULONG64 BytesWritten);
  void                                             FsRtlDismountComplete( PDEVICE_OBJECT DeviceObject, NTSTATUS       DismountStatus);
  NTSTATUS                                         FsRtlSetDriverBacking( PDRIVER_OBJECT DriverObj, ULONG          Flags);
  BOOLEAN                                          FsRtlIsMobileOS();
  PFN_NUMBER                                       FsRtlIsExtentDangling( PFN_NUMBER StartPage, PFN_NUMBER NumberOfPages, ULONG      Flags);
  BOOLEAN                                          FsRtlIsDaxVolume( PFILE_OBJECT FileObject);
  struct {
    CSHORT        NodeTypeCode;
    CSHORT        NodeByteSize;
    ULONG         MappedLength;
    LARGE_INTEGER MappedFileOffset;
  } _PUBLIC_BCB;
  struct {
    LARGE_INTEGER AllocationSize;
    LARGE_INTEGER FileSize;
    LARGE_INTEGER ValidDataLength;
  } _CC_FILE_SIZES;
  struct {
    CSHORT NodeByteSize;
    ULONG  Granularity;
    ULONG  PipelinedRequestSize;
    ULONG  ReadAheadGrowthPercentage;
  } _READ_AHEAD_PARAMETERS;
  struct {
    PACQUIRE_FOR_LAZY_WRITE  AcquireForLazyWrite;
    PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite;
    PACQUIRE_FOR_READ_AHEAD  AcquireForReadAhead;
    PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead;
  } _CACHE_MANAGER_CALLBACKS;
  struct {
    struct _CACHE_UNINITIALIZE_EVENT *Next;
    KEVENT                           Event;
  } _CACHE_UNINITIALIZE_EVENT;
  ULONG                                            CcFastMdlReadWait;
  struct {
    PASYNC_READ_COMPLETION_CALLBACK CompletionRoutine;
    PVOID                           Context;
    PMDL                            Mdl;
    KPROCESSOR_MODE                 RequestorMode;
    ULONG                           NestingLevel;
  } _CC_ASYNC_READ_CONTEXT;
  void                                             CcInitializeCacheMap( PFILE_OBJECT             FileObject, PCC_FILE_SIZES           FileSizes, BOOLEAN                  PinAccess, PCACHE_MANAGER_CALLBACKS Callbacks, PVOID                    LazyWriteContext);
  BOOLEAN                                          CcUninitializeCacheMap( PFILE_OBJECT              FileObject, PLARGE_INTEGER            TruncateSize, PCACHE_UNINITIALIZE_EVENT UninitializeEvent);
  void                                             CcSetFileSizes( PFILE_OBJECT   FileObject, PCC_FILE_SIZES FileSizes);
  NTSTATUS                                         CcSetFileSizesEx( PFILE_OBJECT   FileObject, PCC_FILE_SIZES FileSizes);
  BOOLEAN                                          CcPurgeCacheSection( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER           FileOffset, ULONG                    Length, ULONG                    Flags);
  BOOLEAN                                          CcPurgeCacheSection( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER           FileOffset, ULONG                    Length, BOOLEAN                  UninitializeCacheMaps);
  void                                             CcCoherencyFlushAndPurgeCache( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER           FileOffset, ULONG                    Length, PIO_STATUS_BLOCK         IoStatus, ULONG                    Flags);
  void                                             CcSetDirtyPageThreshold( PFILE_OBJECT FileObject, ULONG        DirtyPageThreshold);
  void                                             CcFlushCache( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER           FileOffset, ULONG                    Length, PIO_STATUS_BLOCK         IoStatus);
  LARGE_INTEGER                                    CcGetFlushedValidData( PSECTION_OBJECT_POINTERS SectionObjectPointer, BOOLEAN                  BcbListHeld);
  BOOLEAN                                          CcZeroData( PFILE_OBJECT   FileObject, PLARGE_INTEGER StartOffset, PLARGE_INTEGER EndOffset, BOOLEAN        Wait);
  PVOID                                            CcRemapBcb( PVOID Bcb);
  void                                             CcRepinBcb( PVOID Bcb);
  void                                             CcUnpinRepinnedBcb( PVOID            Bcb, BOOLEAN          WriteThrough, PIO_STATUS_BLOCK IoStatus);
  PFILE_OBJECT                                     CcGetFileObjectFromSectionPtrs( PSECTION_OBJECT_POINTERS SectionObjectPointer);
  PFILE_OBJECT                                     CcGetFileObjectFromSectionPtrsRef( PSECTION_OBJECT_POINTERS SectionObjectPointer);
  PFILE_OBJECT                                     CcGetFileObjectFromBcb( PVOID Bcb);
  BOOLEAN                                          CcCopyWriteWontFlush( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length);
  BOOLEAN                                          CcCanIWrite( PFILE_OBJECT FileObject, ULONG        BytesToWrite, BOOLEAN      Wait, UCHAR        Retrying);
  void                                             CcDeferWrite( PFILE_OBJECT            FileObject, PCC_POST_DEFERRED_WRITE PostRoutine, PVOID                   Context1, PVOID                   Context2, ULONG                   BytesToWrite, BOOLEAN                 Retrying);
  BOOLEAN                                          CcCopyRead( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, BOOLEAN          Wait, PVOID            Buffer, PIO_STATUS_BLOCK IoStatus);
  void                                             CcFastCopyRead( PFILE_OBJECT     FileObject, ULONG            FileOffset, ULONG            Length, ULONG            PageCount, PVOID            Buffer, PIO_STATUS_BLOCK IoStatus);
  BOOLEAN                                          CcCopyWrite( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, BOOLEAN        Wait, PVOID          Buffer);
  void                                             CcFastCopyWrite( PFILE_OBJECT FileObject, ULONG        FileOffset, ULONG        Length, PVOID        Buffer);
  void                                             CcMdlRead( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus);
  void                                             CcMdlReadComplete( PFILE_OBJECT FileObject, PMDL         MdlChain);
  void                                             CcPrepareMdlWrite( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, PMDL             *MdlChain, PIO_STATUS_BLOCK IoStatus);
  void                                             CcMdlWriteComplete( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, PMDL           MdlChain);
  void                                             CcMdlWriteAbort( PFILE_OBJECT FileObject, PMDL         MdlChain);
  void                                             CcScheduleReadAhead( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length);
  NTSTATUS                                         CcWaitForCurrentLazyWriterActivity( VOID );
  void                                             CcSetReadAheadGranularity( PFILE_OBJECT FileObject, ULONG        Granularity);
  BOOLEAN                                          CcCopyWriteEx( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, BOOLEAN        Wait, PVOID          Buffer, PETHREAD       IoIssuerThread);
  BOOLEAN                                          CcCopyReadEx( PFILE_OBJECT     FileObject, PLARGE_INTEGER   FileOffset, ULONG            Length, BOOLEAN          Wait, PVOID            Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD         IoIssuerThread);
  BOOLEAN                                          CcAsyncCopyRead( PFILE_OBJECT           FileObject, PLARGE_INTEGER         FileOffset, ULONG                  Length, BOOLEAN                Wait, PVOID                  Buffer, PIO_STATUS_BLOCK       IoStatus, PETHREAD               IoIssuerThread, PCC_ASYNC_READ_CONTEXT AsyncReadContext);
  void                                             CcScheduleReadAheadEx( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, PETHREAD       IoIssuerThread);
  void                                             CcInitializeCacheMapEx( PFILE_OBJECT             FileObject, PCC_FILE_SIZES           FileSizes, BOOLEAN                  PinAccess, PCACHE_MANAGER_CALLBACKS Callbacks, PVOID                    LazyWriteContext, ULONG                    Flags);
  BOOLEAN                                          CcPinRead( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, ULONG          Flags, PVOID          *Bcb, PVOID          *Buffer);
  BOOLEAN                                          CcMapData( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, ULONG          Flags, PVOID          *Bcb, PVOID          *Buffer);
  BOOLEAN                                          CcMapData( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, BOOLEAN        Wait, PVOID          *Bcb, PVOID          *Buffer);
  BOOLEAN                                          CcPinMappedData( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, ULONG          Flags, PVOID          *Bcb);
  BOOLEAN                                          CcPreparePinWrite( PFILE_OBJECT   FileObject, PLARGE_INTEGER FileOffset, ULONG          Length, BOOLEAN        Zero, ULONG          Flags, PVOID          *Bcb, PVOID          *Buffer);
  void                                             CcSetDirtyPinnedData( PVOID          BcbVoid, PLARGE_INTEGER Lsn);
  void                                             CcUnpinData( PVOID Bcb);
  void                                             CcSetBcbOwnerPointer( PVOID Bcb, PVOID OwnerPointer);
  void                                             CcUnpinDataForThread( PVOID            Bcb, ERESOURCE_THREAD ResourceThreadId);
  void                                             CcSetAdditionalCacheAttributes( PFILE_OBJECT FileObject, BOOLEAN      DisableReadAhead, BOOLEAN      DisableWriteBehind);
  void                                             CcSetAdditionalCacheAttributesEx( PFILE_OBJECT FileObject, ULONG        Flags);
  void                                             CcSetParallelFlushFile( PFILE_OBJECT FileObject, BOOLEAN      EnableParallelFlush);
  void                                             CcSetLogHandleForFile( PFILE_OBJECT  FileObject, PVOID         LogHandle, PFLUSH_TO_LSN FlushToLsnRoutine);
  LARGE_INTEGER                                    CcGetDirtyPages( PVOID               LogHandle, PDIRTY_PAGE_ROUTINE DirtyPageRoutine, PVOID               Context1, PVOID               Context2);
  BOOLEAN                                          CcIsThereDirtyData( PVPB Vpb);
  BOOLEAN                                          CcIsThereDirtyDataEx( PVPB   Vpb, PULONG NumberOfDirtyPages);
  struct {
    ULONG_PTR dwLower;
    ULONG_PTR dwUpper;
  } _SecHandle;
  struct {
    unsigned long  fCapabilities;
    unsigned short wVersion;
    unsigned short wRPCID;
    unsigned long  cbMaxToken;
    SEC_WCHAR      *Name;
    SEC_WCHAR      *Comment;
  } _SecPkgInfoW;
  struct {
    unsigned long cbBuffer;
    unsigned long BufferType;
#if ...
    char          *pvBuffer;
#else
    void SEC_FAR  *pvBuffer;
#endif
  } _SecBuffer;
  struct {
    unsigned long ulVersion;
    unsigned long cBuffers;
    PSecBuffer    pBuffers;
  } _SecBufferDesc;
  struct {
    unsigned long Size;
    unsigned long NameLength;
    SEC_WCHAR     *Name;
    void          *Reserved;
  } _SEC_NEGOTIATION_INFO;
  struct {
    unsigned long dwInitiatorAddrType;
    unsigned long cbInitiatorLength;
    unsigned long dwInitiatorOffset;
    unsigned long dwAcceptorAddrType;
    unsigned long cbAcceptorLength;
    unsigned long dwAcceptorOffset;
    unsigned long cbApplicationDataLength;
    unsigned long dwApplicationDataOffset;
  } _SEC_CHANNEL_BINDINGS;
  struct {
    SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT ProtoNegoExt;
    unsigned short                           ProtocolListSize;
    unsigned char                            ProtocolList[ANYSIZE_ARRAY];
  } _SEC_APPLICATION_PROTOCOL_LIST;
  struct {
    unsigned long                 ProtocolListsSize;
    SEC_APPLICATION_PROTOCOL_LIST ProtocolLists[ANYSIZE_ARRAY];
  } _SEC_APPLICATION_PROTOCOLS;
  struct {
    unsigned short ProfilesSize;
    unsigned short ProfilesList[ANYSIZE_ARRAY];
  } _SEC_SRTP_PROTECTION_PROFILES;
  struct {
    unsigned char MasterKeyIdentifierSize;
    unsigned char MasterKeyIdentifier[ANYSIZE_ARRAY];
  } _SEC_SRTP_MASTER_KEY_IDENTIFIER;
  struct {
    unsigned char  MajorVersion;
    unsigned char  MinorVersion;
    unsigned short KeyParametersSize;
    unsigned char  KeyParameters[ANYSIZE_ARRAY];
  } _SEC_TOKEN_BINDING;
  struct {
    unsigned short KeySize;
    unsigned char  Key[ANYSIZE_ARRAY];
  } _SEC_PRESHAREDKEY;
  struct {
    unsigned short KeyIdentitySize;
    unsigned char  KeyIdentity[ANYSIZE_ARRAY];
  } _SEC_PRESHAREDKEY_IDENTITY;
  struct {
    unsigned short PathMTU;
  } _SEC_DTLS_MTU;
  struct {
    SEC_WCHAR *sUserName;
  } _SecPkgCredentials_NamesW;
  struct {
    SEC_WCHAR     *sProviderName;
    unsigned long ProviderInfoLength;
    char          *ProviderInfo;
  } _SecPkgCredentials_SSIProviderW;
  struct {
    ULONG  Version;
    ULONG  Flags;
    USHORT ProxyServerOffset;
    USHORT ProxyServerLength;
    USHORT ClientTlsCredOffset;
    USHORT ClientTlsCredLength;
  } _SecPkgCredentials_KdcProxySettingsW;
  struct {
    unsigned long EncodedCertSize;
    unsigned char *EncodedCert;
  } _SecPkgCredentials_Cert;
  struct {
    void *AttributeInfo;
  } _SecPkgContext_SubjectAttributes;
  struct {
    SECPKG_CRED_CLASS CredClass;
    unsigned long     IsPromptingNeeded;
  } _SecPkgContext_CredInfo;
  struct {
    unsigned long PackageMask;
  } _SecPkgContext_NegoPackageInfo;
  struct {
    unsigned long LastStatus;
  } _SecPkgContext_NegoStatus;
  struct {
    unsigned long cbMaxToken;
    unsigned long cbMaxSignature;
    unsigned long cbBlockSize;
    unsigned long cbSecurityTrailer;
  } _SecPkgContext_Sizes;
  struct {
    unsigned long cbHeader;
    unsigned long cbTrailer;
    unsigned long cbMaximumMessage;
    unsigned long cBuffers;
    unsigned long cbBlockSize;
  } _SecPkgContext_StreamSizes;
  struct {
    SEC_WCHAR *sUserName;
  } _SecPkgContext_NamesW;
  struct {
    TimeStamp tsStart;
    TimeStamp tsExpiry;
  } _SecPkgContext_Lifespan;
  struct {
    unsigned long AuthzSvc;
    void          *pPac;
  } _SecPkgContext_DceInfo;
  struct {
    SEC_WCHAR     *sSignatureAlgorithmName;
    SEC_WCHAR     *sEncryptAlgorithmName;
    unsigned long KeySize;
    unsigned long SignatureAlgorithm;
    unsigned long EncryptAlgorithm;
  } _SecPkgContext_KeyInfoW;
  struct {
    SEC_WCHAR *sAuthorityName;
  } _SecPkgContext_AuthorityW;
  struct {
    SEC_WCHAR     *sProtocolName;
    unsigned long majorVersion;
    unsigned long minorVersion;
  } _SecPkgContext_ProtoInfoW;
  struct {
    TimeStamp tsPasswordExpires;
  } _SecPkgContext_PasswordExpiry;
  struct {
    TimeStamp tsLogoffTime;
  } _SecPkgContext_LogoffTime;
  struct {
    unsigned long SessionKeyLength;
    unsigned char *SessionKey;
  } _SecPkgContext_SessionKey;
  struct {
    unsigned long  KeyType;
    unsigned short KeyLength;
    unsigned char  *KeyValue;
    unsigned long  VerifyKeyType;
    unsigned short VerifyKeyLength;
    unsigned char  *VerifyKeyValue;
  } _SecPkgContext_NegoKeys;
  struct {
    PSecPkgInfoW PackageInfo;
  } _SecPkgContext_PackageInfoW;
  struct {
    unsigned long UserFlags;
  } _SecPkgContext_UserFlags;
  struct {
    unsigned long Flags;
  } _SecPkgContext_Flags;
  struct {
    PSecPkgInfoW  PackageInfo;
    unsigned long NegotiationState;
  } _SecPkgContext_NegotiationInfoW;
  struct {
    unsigned long CredentialType;
    SEC_WCHAR     *sCredentialName;
  } _SecPkgContext_CredentialNameW;
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         AcquireCredentialsHandleW( PSECURITY_STRING pPrincipal, PSECURITY_STRING pPackage, LPWSTR           pszPrincipal, LPWSTR           pszPackage, unsigned long    fCredentialUse, void             *pvLogonId, void             *pAuthData, SEC_GET_KEY_FN   pGetKeyFn, void             *pvGetKeyArgument, PCredHandle      phCredential, PTimeStamp       ptsExpiry);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         FreeCredentialsHandle( PCredHandle phCredential);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         AddCredentialsW( PCredHandle      hCredentials, PSECURITY_STRING pPrincipal, PSECURITY_STRING pPackage, LPWSTR           pszPrincipal, LPWSTR           pszPackage, unsigned long    fCredentialUse, void             *pAuthData, SEC_GET_KEY_FN   pGetKeyFn, void             *pvGetKeyArgument, PTimeStamp       ptsExpiry);
  SECURITY_STATUS SEC_ENTRY                        AddCredentialsA( PCredHandle    hCredentials, LPSTR          pszPrincipal, LPSTR          pszPackage, unsigned long  fCredentialUse, void           *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void           *pvGetKeyArgument, PTimeStamp     ptsExpiry);
  struct                                           _SspiAsyncContext;
  SspiAsyncContext *                                 SspiCreateAsyncContext();
  void                                             SspiFreeAsyncContext( SspiAsyncContext *Handle);
  NTSTATUS                                         SspiReinitAsyncContext( SspiAsyncContext *Handle);
  SECURITY_STATUS                                  SspiSetAsyncNotifyCallback( SspiAsyncContext        *Context, SspiAsyncNotifyCallback Callback, void                    *CallbackData);
  BOOLEAN                                          SspiAsyncContextRequiresNotify( SspiAsyncContext *AsyncContext);
  SECURITY_STATUS                                  SspiGetAsyncCallStatus( SspiAsyncContext *Handle);
  SECURITY_STATUS                                  SspiAcquireCredentialsHandleAsyncW( SspiAsyncContext *AsyncContext, PSECURITY_STRING pszPrincipal, PSECURITY_STRING pszPackage, LPWSTR           pszPrincipal, LPWSTR           pszPackage, unsigned long    fCredentialUse, void             *pvLogonId, void             *pAuthData, SEC_GET_KEY_FN   pGetKeyFn, void             *pvGetKeyArgument, PCredHandle      phCredential, PTimeStamp       ptsExpiry);
  SECURITY_STATUS                                  SspiAcquireCredentialsHandleAsyncA( SspiAsyncContext *AsyncContext, LPSTR            pszPrincipal, LPSTR            pszPackage, unsigned long    fCredentialUse, void             *pvLogonId, void             *pAuthData, SEC_GET_KEY_FN   pGetKeyFn, void             *pvGetKeyArgument, PCredHandle      phCredential, PTimeStamp       ptsExpiry);
  SECURITY_STATUS                                  SspiInitializeSecurityContextAsyncW( SspiAsyncContext *AsyncContext, PCredHandle      phCredential, PCtxtHandle      phContext, PSECURITY_STRING pszTargetName, LPWSTR           pszTargetName, unsigned long    fContextReq, unsigned long    Reserved1, unsigned long    TargetDataRep, PSecBufferDesc   pInput, unsigned long    Reserved2, PCtxtHandle      phNewContext, PSecBufferDesc   pOutput, unsigned long    *pfContextAttr, PTimeStamp       ptsExpiry);
  SECURITY_STATUS                                  SspiInitializeSecurityContextAsyncA( SspiAsyncContext *AsyncContext, PCredHandle      phCredential, PCtxtHandle      phContext, LPSTR            pszTargetName, unsigned long    fContextReq, unsigned long    Reserved1, unsigned long    TargetDataRep, PSecBufferDesc   pInput, unsigned long    Reserved2, PCtxtHandle      phNewContext, PSecBufferDesc   pOutput, unsigned long    *pfContextAttr, PTimeStamp       ptsExpiry);
  SECURITY_STATUS                                  SspiAcceptSecurityContextAsync( SspiAsyncContext *AsyncContext, PCredHandle      phCredential, PCtxtHandle      phContext, PSecBufferDesc   pInput, unsigned long    fContextReq, unsigned long    TargetDataRep, PCtxtHandle      phNewContext, PSecBufferDesc   pOutput, unsigned long    *pfContextAttr, PTimeStamp       ptsExpiry);
  SECURITY_STATUS                                  SspiFreeCredentialsHandleAsync( SspiAsyncContext *AsyncContext, PCredHandle      phCredential);
  SECURITY_STATUS                                  SspiDeleteSecurityContextAsync( SspiAsyncContext *AsyncContext, PCtxtHandle      phContext);
  SECURITY_STATUS SEC_ENTRY                        ChangeAccountPasswordW( SEC_WCHAR      *pszPackageName, SEC_WCHAR      *pszDomainName, SEC_WCHAR      *pszAccountName, SEC_WCHAR      *pszOldPassword, SEC_WCHAR      *pszNewPassword, BOOLEAN        bImpersonating, unsigned long  dwReserved, PSecBufferDesc pOutput);
  SECURITY_STATUS SEC_ENTRY                        ChangeAccountPasswordA( SEC_CHAR       *pszPackageName, SEC_CHAR       *pszDomainName, SEC_CHAR       *pszAccountName, SEC_CHAR       *pszOldPassword, SEC_CHAR       *pszNewPassword, BOOLEAN        bImpersonating, unsigned long  dwReserved, PSecBufferDesc pOutput);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         InitializeSecurityContextW( PCredHandle      phCredential, PCtxtHandle      phContext, PSECURITY_STRING pTargetName, SEC_WCHAR        *pszTargetName, unsigned long    fContextReq, unsigned long    Reserved1, unsigned long    TargetDataRep, PSecBufferDesc   pInput, unsigned long    Reserved2, PCtxtHandle      phNewContext, PSecBufferDesc   pOutput, unsigned long    *pfContextAttr, PTimeStamp       ptsExpiry);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         AcceptSecurityContext( PCredHandle    phCredential, PCtxtHandle    phContext, PSecBufferDesc pInput, unsigned long  fContextReq, unsigned long  TargetDataRep, PCtxtHandle    phNewContext, PSecBufferDesc pOutput, unsigned long  *pfContextAttr, PTimeStamp     ptsExpiry);
  SECURITY_STATUS SEC_ENTRY                        CompleteAuthToken( PCtxtHandle    phContext, PSecBufferDesc pToken);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         ImpersonateSecurityContext( PCtxtHandle phContext);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         RevertSecurityContext( PCtxtHandle phContext);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         QuerySecurityContextToken( PCtxtHandle phContext, void        **Token);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         DeleteSecurityContext( PCtxtHandle phContext);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         ApplyControlToken( PCtxtHandle    phContext, PSecBufferDesc pInput);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         QueryContextAttributesW( PCtxtHandle   phContext, unsigned long ulAttribute, void          *pBuffer);
  SECURITY_STATUS SEC_ENTRY                        QueryContextAttributesExW( PCtxtHandle   phContext, unsigned long ulAttribute, void          *pBuffer, unsigned long cbBuffer);
  SECURITY_STATUS SEC_ENTRY                        SetContextAttributesW( PCtxtHandle   phContext, unsigned long ulAttribute, void          *pBuffer, unsigned long cbBuffer);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         QueryCredentialsAttributesW( PCredHandle   phCredential, unsigned long ulAttribute, void          *pBuffer);
  SECURITY_STATUS SEC_ENTRY                        QueryCredentialsAttributesExW( PCredHandle   phCredential, unsigned long ulAttribute, void          *pBuffer, unsigned long cbBuffer);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         SetCredentialsAttributesW( PCredHandle   phCredential, unsigned long ulAttribute, void          *pBuffer, unsigned long cbBuffer);
  SECURITY_STATUS SEC_ENTRY                        FreeContextBuffer( PVOID pvContextBuffer);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         MakeSignature( PCtxtHandle    phContext, unsigned long  fQOP, PSecBufferDesc pMessage, unsigned long  MessageSeqNo);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         VerifySignature( PCtxtHandle    phContext, PSecBufferDesc pMessage, unsigned long  MessageSeqNo, unsigned long  *pfQOP);
  SECURITY_STATUS SEC_ENTRY                        EncryptMessage( PCtxtHandle    phContext, unsigned long  fQOP, PSecBufferDesc pMessage, unsigned long  MessageSeqNo);
  SECURITY_STATUS SEC_ENTRY                        DecryptMessage( PCtxtHandle    phContext, PSecBufferDesc pMessage, unsigned long  MessageSeqNo, unsigned long  *pfQOP);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         EnumerateSecurityPackagesW( unsigned long *pcPackages, PSecPkgInfoW  *ppPackageInfo);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         QuerySecurityPackageInfoW( PSECURITY_STRING pPackageName, LPWSTR           pszPackageName, PSecPkgInfoW     *ppPackageInfo);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         ExportSecurityContext( PCtxtHandle phContext, ULONG       fFlags, PSecBuffer  pPackedContext, void        **pToken);
  KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY         ImportSecurityContextW( PSECURITY_STRING pszPackage, LPWSTR           pszPackage, PSecBuffer       pPackedContext, void             *Token, PCtxtHandle      phContext);
  KSECDDDECLSPEC NTSTATUS                          SecMakeSPN( IN PUNICODE_STRING     ServiceClass, IN PUNICODE_STRING     ServiceName, IN PUNICODE_STRING     InstanceName, IN USHORT              InstancePort, IN PUNICODE_STRING     Referrer, IN OUT PUNICODE_STRING Spn, OUT PULONG             Length, IN BOOLEAN             Allocate);
  KSECDDDECLSPEC NTSTATUS                          SecMakeSPNEx( IN PUNICODE_STRING     ServiceClass, IN PUNICODE_STRING     ServiceName, IN PUNICODE_STRING     InstanceName, IN USHORT              InstancePort, IN PUNICODE_STRING     Referrer, IN PUNICODE_STRING     TargetInfo, IN OUT PUNICODE_STRING Spn, OUT PULONG             Length, IN BOOLEAN             Allocate);
  KSECDDDECLSPEC NTSTATUS                          SecMakeSPNEx2( IN PUNICODE_STRING     ServiceClass, IN PUNICODE_STRING     ServiceName, IN PUNICODE_STRING     InstanceName, IN USHORT              InstancePort, IN PUNICODE_STRING     Referrer, IN PUNICODE_STRING     InTargetInfo, IN OUT PUNICODE_STRING Spn, OUT PULONG             TotalSize, IN BOOLEAN             Allocate, IN BOOLEAN             IsTargetInfoMarshaled);
  KSECDDDECLSPEC NTSTATUS SEC_ENTRY                SecLookupAccountSid( PSID            Sid, PULONG          NameSize, PUNICODE_STRING NameBuffer, PULONG          DomainSize, PUNICODE_STRING DomainBuffer, PSID_NAME_USE   NameUse);
  KSECDDDECLSPEC NTSTATUS SEC_ENTRY                SecLookupAccountName( PUNICODE_STRING Name, PULONG          SidSize, PSID            Sid, PSID_NAME_USE   NameUse, PULONG          DomainSize, PUNICODE_STRING ReferencedDomain);
  KSECDDDECLSPEC NTSTATUS SEC_ENTRY                SecLookupWellKnownSid( WELL_KNOWN_SID_TYPE SidType, PSID                Sid, ULONG               SidBufferSize, PULONG              SidSize);
  struct {
    unsigned long                        dwVersion;
    ENUMERATE_SECURITY_PACKAGES_FN_W     EnumerateSecurityPackagesW;
    QUERY_CREDENTIALS_ATTRIBUTES_FN_W    QueryCredentialsAttributesW;
    ACQUIRE_CREDENTIALS_HANDLE_FN_W      AcquireCredentialsHandleW;
    FREE_CREDENTIALS_HANDLE_FN           FreeCredentialsHandle;
    void                                 *Reserved2;
    INITIALIZE_SECURITY_CONTEXT_FN_W     InitializeSecurityContextW;
    ACCEPT_SECURITY_CONTEXT_FN           AcceptSecurityContext;
    COMPLETE_AUTH_TOKEN_FN               CompleteAuthToken;
    DELETE_SECURITY_CONTEXT_FN           DeleteSecurityContext;
    APPLY_CONTROL_TOKEN_FN               ApplyControlToken;
    QUERY_CONTEXT_ATTRIBUTES_FN_W        QueryContextAttributesW;
    IMPERSONATE_SECURITY_CONTEXT_FN      ImpersonateSecurityContext;
    REVERT_SECURITY_CONTEXT_FN           RevertSecurityContext;
    MAKE_SIGNATURE_FN                    MakeSignature;
    VERIFY_SIGNATURE_FN                  VerifySignature;
    FREE_CONTEXT_BUFFER_FN               FreeContextBuffer;
    QUERY_SECURITY_PACKAGE_INFO_FN_W     QuerySecurityPackageInfoW;
    void                                 *Reserved3;
    void                                 *Reserved4;
    EXPORT_SECURITY_CONTEXT_FN           ExportSecurityContext;
    IMPORT_SECURITY_CONTEXT_FN_W         ImportSecurityContextW;
    ADD_CREDENTIALS_FN_W                 AddCredentialsW;
    void                                 *Reserved8;
    QUERY_SECURITY_CONTEXT_TOKEN_FN      QuerySecurityContextToken;
    ENCRYPT_MESSAGE_FN                   EncryptMessage;
    DECRYPT_MESSAGE_FN                   DecryptMessage;
    SET_CONTEXT_ATTRIBUTES_FN_W          SetContextAttributesW;
    SET_CREDENTIALS_ATTRIBUTES_FN_W      SetCredentialsAttributesW;
    CHANGE_PASSWORD_FN_W                 ChangeAccountPasswordW;
    void                                 *Reserved9;
    QUERY_CONTEXT_ATTRIBUTES_EX_FN_W     QueryContextAttributesExW;
    QUERY_CREDENTIALS_ATTRIBUTES_EX_FN_W QueryCredentialsAttributesExW;
  } _SECURITY_FUNCTION_TABLE_W;
  KSECDDDECLSPEC PSecurityFunctionTableW SEC_ENTRY InitSecurityInterfaceW( void );
  struct {
    unsigned long  Version;
    unsigned short cbHeaderLength;
    unsigned long  cbStructureLength;
    unsigned long  UserOffset;
    unsigned short UserLength;
    unsigned long  DomainOffset;
    unsigned short DomainLength;
    unsigned long  PackedCredentialsOffset;
    unsigned short PackedCredentialsLength;
    unsigned long  Flags;
    unsigned long  PackageListOffset;
    unsigned short PackageListLength;
  } _SEC_WINNT_AUTH_IDENTITY_EX2;
  struct {
    unsigned short *User;
    unsigned long  UserLength;
    unsigned short *Domain;
    unsigned long  DomainLength;
    unsigned short *Password;
    unsigned long  PasswordLength;
    unsigned long  Flags;
  } _SEC_WINNT_AUTH_IDENTITY_W;
  struct {
    unsigned long  Version;
    unsigned long  Length;
    unsigned short *User;
    unsigned long  UserLength;
    unsigned short *Domain;
    unsigned long  DomainLength;
    unsigned short *Password;
    unsigned long  PasswordLength;
    unsigned long  Flags;
    unsigned short *PackageList;
    unsigned long  PackageListLength;
  } _SEC_WINNT_AUTH_IDENTITY_EXW;
  SECURITY_STATUS SEC_ENTRY                        SspiEncodeAuthIdentityAsStrings( PSEC_WINNT_AUTH_IDENTITY_OPAQUE pAuthIdentity, PCWSTR                          *ppszUserName, PCWSTR                          *ppszDomainName, PCWSTR                          *ppszPackedCredentialsString);
  SECURITY_STATUS SEC_ENTRY                        SspiValidateAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData);
  SECURITY_STATUS SEC_ENTRY                        SspiCopyAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *AuthDataCopy);
  VOID SEC_ENTRY                                   SspiFreeAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData);
  VOID SEC_ENTRY                                   SspiZeroAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData);
  VOID SEC_ENTRY                                   SspiLocalFree( PVOID DataBuffer);
  SECURITY_STATUS SEC_ENTRY                        SspiEncodeStringsAsAuthIdentity( PCWSTR                          pszUserName, PCWSTR                          pszDomainName, PCWSTR                          pszPackedCredentialsString, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppAuthIdentity);
  SECURITY_STATUS SEC_ENTRY                        SspiCompareAuthIdentities( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity1, PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity2, PBOOLEAN                        SameSuppliedUser, PBOOLEAN                        SameSuppliedIdentity);
  SECURITY_STATUS SEC_ENTRY                        SspiMarshalAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity, unsigned long                   *AuthIdentityLength, char                            **AuthIdentityByteArray);
  SECURITY_STATUS SEC_ENTRY                        SspiUnmarshalAuthIdentity( unsigned long                   AuthIdentityLength, char                            *AuthIdentityByteArray, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppAuthIdentity);
  BOOLEAN SEC_ENTRY                                SspiIsPromptingNeeded( unsigned long ErrorOrNtStatus);
  SECURITY_STATUS SEC_ENTRY                        SspiGetTargetHostName( PCWSTR pszTargetName, PWSTR  *pszHostName);
  SECURITY_STATUS SEC_ENTRY                        SspiExcludePackage( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity, PCWSTR                          pszPackageName, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppNewAuthIdentity);
  struct {
    SECURITY_STRING UserName;
    SECURITY_STRING LogonDomainName;
    SECURITY_STRING LogonServer;
    PSID            pSid;
  } _SECURITY_USER_DATA;
  NTSTATUS SEC_ENTRY                               GetSecurityUserInfo( PLUID             LogonId, ULONG             Flags, PSecurityUserData *UserInformation);
  NTSTATUS SEC_ENTRY                               MapSecurityError( SECURITY_STATUS SecStatus);
  struct {
    ULONG                PathNameLength;
    PIO_SECURITY_CONTEXT SecurityContext;
    WCHAR                FilePathName[1];
  } _QUERY_PATH_REQUEST;
  struct {
    PIO_SECURITY_CONTEXT pSecurityContext;
    ULONG                EaLength;
    PVOID                pEaBuffer;
    UNICODE_STRING       PathName;
    UNICODE_STRING       DomainServiceName;
    PECP_LIST            EcpList;
    PESILO               Silo;
#if ...
    ULONG_PTR            Reserved;
#else
    ULONG_PTR            Reserved[2];
#endif
  } _QUERY_PATH_REQUEST_EX;
  struct {
    ULONG LengthAccepted;
  } _QUERY_PATH_RESPONSE;
  NTSYSAPI NTSTATUS                                ZwQueryObject( HANDLE                   Handle, OBJECT_INFORMATION_CLASS ObjectInformationClass, PVOID                    ObjectInformation, ULONG                    ObjectInformationLength, PULONG                   ReturnLength);
  NTSYSAPI NTSTATUS                                ZwNotifyChangeKey( HANDLE           KeyHandle, HANDLE           Event, PIO_APC_ROUTINE  ApcRoutine, PVOID            ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG            CompletionFilter, BOOLEAN          WatchTree, PVOID            Buffer, ULONG            BufferSize, BOOLEAN          Asynchronous);
  NTSYSAPI NTSTATUS                                ZwCreateEvent( PHANDLE            EventHandle, ACCESS_MASK        DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, EVENT_TYPE         EventType, BOOLEAN            InitialState);
  NTSYSAPI NTSTATUS                                ZwDeleteFile( POBJECT_ATTRIBUTES ObjectAttributes);
  NTSYSAPI NTSTATUS                                ZwDeviceIoControlFile( HANDLE           FileHandle, HANDLE           Event, PIO_APC_ROUTINE  ApcRoutine, PVOID            ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG            IoControlCode, PVOID            InputBuffer, ULONG            InputBufferLength, PVOID            OutputBuffer, ULONG            OutputBufferLength);
  NTSYSAPI NTSTATUS                                ZwQueryDirectoryFile( HANDLE                 FileHandle, HANDLE                 Event, PIO_APC_ROUTINE        ApcRoutine, PVOID                  ApcContext, PIO_STATUS_BLOCK       IoStatusBlock, PVOID                  FileInformation, ULONG                  Length, FILE_INFORMATION_CLASS FileInformationClass, BOOLEAN                ReturnSingleEntry, PUNICODE_STRING        FileName, BOOLEAN                RestartScan);
  NTSYSAPI NTSTATUS                                ZwQueryDirectoryFileEx( HANDLE                 FileHandle, HANDLE                 Event, PIO_APC_ROUTINE        ApcRoutine, PVOID                  ApcContext, PIO_STATUS_BLOCK       IoStatusBlock, PVOID                  FileInformation, ULONG                  Length, FILE_INFORMATION_CLASS FileInformationClass, ULONG                  QueryFlags, PUNICODE_STRING        FileName);
  NTSYSAPI NTSTATUS                                ZwQueryVolumeInformationFile( HANDLE               FileHandle, PIO_STATUS_BLOCK     IoStatusBlock, PVOID                FsInformation, ULONG                Length, FS_INFORMATION_CLASS FsInformationClass);
  NTSYSAPI NTSTATUS                                ZwSetVolumeInformationFile( HANDLE               FileHandle, PIO_STATUS_BLOCK     IoStatusBlock, PVOID                FsInformation, ULONG                Length, FS_INFORMATION_CLASS FsInformationClass);
  NTSYSAPI NTSTATUS                                ZwFsControlFile( HANDLE           FileHandle, HANDLE           Event, PIO_APC_ROUTINE  ApcRoutine, PVOID            ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG            FsControlCode, PVOID            InputBuffer, ULONG            InputBufferLength, PVOID            OutputBuffer, ULONG            OutputBufferLength);
  NTSYSAPI NTSTATUS                                ZwDuplicateObject( HANDLE      SourceProcessHandle, HANDLE      SourceHandle, HANDLE      TargetProcessHandle, PHANDLE     TargetHandle, ACCESS_MASK DesiredAccess, ULONG       HandleAttributes, ULONG       Options);
  NTSYSAPI NTSTATUS                                ZwOpenDirectoryObject( PHANDLE            DirectoryHandle, ACCESS_MASK        DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes);
  NTSYSAPI NTSTATUS                                ZwAllocateVirtualMemory( HANDLE    ProcessHandle, PVOID     *BaseAddress, ULONG_PTR ZeroBits, PSIZE_T   RegionSize, ULONG     AllocationType, ULONG     Protect);
  NTSYSAPI NTSTATUS                                ZwAllocateVirtualMemoryEx( HANDLE                  ProcessHandle, PVOID                   *BaseAddress, PSIZE_T                 RegionSize, ULONG                   AllocationType, ULONG                   PageProtection, PMEM_EXTENDED_PARAMETER ExtendedParameters, ULONG                   ExtendedParameterCount);
  NTSYSAPI NTSTATUS                                ZwFreeVirtualMemory( HANDLE  ProcessHandle, PVOID   *BaseAddress, PSIZE_T RegionSize, ULONG   FreeType);
  NTSYSAPI NTSTATUS                                ZwQueryVirtualMemory( HANDLE                   ProcessHandle, PVOID                    BaseAddress, MEMORY_INFORMATION_CLASS MemoryInformationClass, PVOID                    MemoryInformation, SIZE_T                   MemoryInformationLength, PSIZE_T                  ReturnLength);
  NTSYSAPI NTSTATUS                                ZwSetInformationVirtualMemory( HANDLE                           ProcessHandle, VIRTUAL_MEMORY_INFORMATION_CLASS VmInformationClass, ULONG_PTR                        NumberOfEntries, PMEMORY_RANGE_ENTRY              VirtualAddresses, PVOID                            VmInformation, ULONG                            VmInformationLength);
  NTSYSAPI NTSTATUS                                ZwWaitForSingleObject( HANDLE         Handle, BOOLEAN        Alertable, PLARGE_INTEGER Timeout);
  NTSYSAPI NTSTATUS                                ZwSetEvent( HANDLE EventHandle, PLONG  PreviousState);
  NTSYSAPI NTSTATUS                                ZwFlushVirtualMemory( HANDLE           ProcessHandle, PVOID            *BaseAddress, PSIZE_T          RegionSize, PIO_STATUS_BLOCK IoStatus);
  NTSYSAPI NTSTATUS                                ZwOpenProcessTokenEx( HANDLE      ProcessHandle, ACCESS_MASK DesiredAccess, ULONG       HandleAttributes, PHANDLE     TokenHandle);
  NTSYSAPI NTSTATUS                                ZwOpenThreadTokenEx( HANDLE      ThreadHandle, ACCESS_MASK DesiredAccess, BOOLEAN     OpenAsSelf, ULONG       HandleAttributes, PHANDLE     TokenHandle);
  NTSYSAPI NTSTATUS                                ZwQueryInformationToken( HANDLE                  TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, PVOID                   TokenInformation, ULONG                   TokenInformationLength, PULONG                  ReturnLength);
  NTSYSAPI NTSTATUS                                ZwSetInformationToken( HANDLE                  TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, PVOID                   TokenInformation, ULONG                   TokenInformationLength);
  NTSYSAPI NTSTATUS                                ZwSetSecurityObject( HANDLE               Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor);
  NTSYSAPI NTSTATUS                                ZwQuerySecurityObject( HANDLE               Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG                Length, PULONG               LengthNeeded);
  NTSYSAPI NTSTATUS                                ZwLockFile( HANDLE           FileHandle, HANDLE           Event, PIO_APC_ROUTINE  ApcRoutine, PVOID            ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER   ByteOffset, PLARGE_INTEGER   Length, ULONG            Key, BOOLEAN          FailImmediately, BOOLEAN          ExclusiveLock);
  NTSYSAPI NTSTATUS                                ZwUnlockFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER   ByteOffset, PLARGE_INTEGER   Length, ULONG            Key);
  NTSYSAPI NTSTATUS                                ZwQueryQuotaInformationFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID            Buffer, ULONG            Length, BOOLEAN          ReturnSingleEntry, PVOID            SidList, ULONG            SidListLength, PSID             StartSid, BOOLEAN          RestartScan);
  NTSYSAPI NTSTATUS                                ZwSetQuotaInformationFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID            Buffer, ULONG            Length);
  NTSYSAPI NTSTATUS                                ZwFlushBuffersFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock);
  NTSYSAPI NTSTATUS                                ZwFlushBuffersFileEx( HANDLE           FileHandle, ULONG            FLags, PVOID            Parameters, ULONG            ParametersSize, PIO_STATUS_BLOCK IoStatusBlock);
  NTSTATUS                                         ZwQueryEaFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID            Buffer, ULONG            Length, BOOLEAN          ReturnSingleEntry, PVOID            EaList, ULONG            EaListLength, PULONG           EaIndex, BOOLEAN          RestartScan);
  NTSTATUS                                         ZwSetEaFile( HANDLE           FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID            Buffer, ULONG            Length);
  NTSYSAPI NTSTATUS                                ZwDuplicateToken( HANDLE             ExistingTokenHandle, ACCESS_MASK        DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, BOOLEAN            EffectiveOnly, TOKEN_TYPE         TokenType, PHANDLE            NewTokenHandle);
  base_class                                       FSRTL_COMMON_FCB_HEADER;
} FSRTL_ADVANCED_FCB_HEADER;

Members

_FSRTL_ADVANCED_FCB_HEADER

_FSRTL_ADVANCED_FCB_HEADER.DUMMYSTRUCTNAME

_FSRTL_ADVANCED_FCB_HEADER.FastMutex

_FSRTL_ADVANCED_FCB_HEADER.FilterContexts

_FSRTL_ADVANCED_FCB_HEADER.PushLock

_FSRTL_ADVANCED_FCB_HEADER.FileContextSupportPointer

_FSRTL_ADVANCED_FCB_HEADER.__unnamed_union_36

_FSRTL_ADVANCED_FCB_HEADER.__unnamed_union_36.Oplock

_FSRTL_ADVANCED_FCB_HEADER.__unnamed_union_36.ReservedForRemote

_FSRTL_ADVANCED_FCB_HEADER.ReservedContext

_EOF_WAIT_BLOCK

_EOF_WAIT_BLOCK.EofWaitLinks

_EOF_WAIT_BLOCK.Event

```cpp BOOLEAN FsRtlCopyRead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)

The FsRtlCopyRead routine copies data from a cached file to a user buffer.

```cpp BOOLEAN FsRtlCopyWrite( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)

The FsRtlCopyWrite routine copies data from a user buffer to a cached file.

```cpp NTSTATUS FsRtlMdlReadEx( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG LockKey, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus)

The FsRtlMdlReadEx routine performs a fast cached MDL read. If the requested data is not cached, the routine reverts to an IRP based MDL read operation.

```cpp BOOLEAN FsRtlMdlReadDev( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG LockKey, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)

The FltFastIoMdlRead routine returns a memory descriptor list (MDL) that points directly to the specified byte range in the file cache.

```cpp BOOLEAN FsRtlMdlReadCompleteDev( PFILE_OBJECT FileObject, PMDL MdlChain, PDEVICE_OBJECT DeviceObject)

The FltFastIoMdlReadComplete routine completes the read operation that the FltFastIoMdlRead routine initiated.

```cpp NTSTATUS FsRtlPrepareMdlWriteEx( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG LockKey, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus)

The FsRtlPrepareMdlWriteEx routine returns a linked list of memory descriptor lists (MDLs) that point to the specified range of cached file data to write data directly to the cache. If the cache support for the write is not available, the routine reverts to an IRP based MDL write operation.

```cpp BOOLEAN FsRtlPrepareMdlWriteDev( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG LockKey, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject)

The FltFastIoPrepareMdlWrite routine returns a linked list of memory descriptor lists (MDLs) that point to the specified range of cached file data to write data directly to the cache.

```cpp BOOLEAN FsRtlMdlWriteCompleteDev( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PMDL MdlChain, PDEVICE_OBJECT DeviceObject)

The FltFastIoMdlWriteComplete routine frees the resources that FltFastIoPrepareMdlWrite allocated.

_FSRTL_AUXILIARY_BUFFER

_FSRTL_AUXILIARY_BUFFER.Buffer

_FSRTL_AUXILIARY_BUFFER.Length

_FSRTL_AUXILIARY_BUFFER.Flags

_FSRTL_AUXILIARY_BUFFER.Mdl

```cpp void FsRtlAcquireFileExclusive( PFILE_OBJECT FileObject)

The FsRtlAcquireFileExclusive routine is reserved for system use. Do not use this routine in your driver. See FsRtlRegisterFileSystemFilterCallbacks.

```cpp void FsRtlReleaseFile( PFILE_OBJECT FileObject)

The FsRtlReleaseFile routine is reserved for system use. See FsRtlRegisterFileSystemFilterCallbacks.

```cpp NTSTATUS FsRtlGetFileSize( PFILE_OBJECT FileObject, PLARGE_INTEGER FileSize)

The FsRtlGetFileSize routine is used to get the size of a file.

```cpp BOOLEAN FsRtlIsTotalDeviceFailure( NTSTATUS Status)

The FsRtlIsTotalDeviceFailure routine determines whether a media or other hardware failure has occurred.

_FILE_LOCK_INFO

_FILE_LOCK_INFO.StartingByte

_FILE_LOCK_INFO.Length

_FILE_LOCK_INFO.ExclusiveLock

_FILE_LOCK_INFO.Key

_FILE_LOCK_INFO.FileObject

_FILE_LOCK_INFO.ProcessId

_FILE_LOCK_INFO.EndingByte

_FILE_LOCK

_FILE_LOCK.CompleteLockIrpRoutine

_FILE_LOCK.UnlockRoutine

_FILE_LOCK.FastIoIsQuestionable

_FILE_LOCK.SpareC

_FILE_LOCK.LockInformation

_FILE_LOCK.LastReturnedLockInfo

_FILE_LOCK.LastReturnedLock

_FILE_LOCK.LockRequestsInProgress

```cpp PFILE_LOCK FsRtlAllocateFileLock( PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine, PUNLOCK_ROUTINE UnlockRoutine)

The FsRtlAllocateFileLock routine allocates and initializes a new FILE_LOCK structure.

```cpp void FsRtlFreeFileLock( PFILE_LOCK FileLock)

The FsRtlFreeFileLock routine uninitializes and frees a file lock structure.

```cpp void FsRtlInitializeFileLock( PFILE_LOCK FileLock, PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine, PUNLOCK_ROUTINE UnlockRoutine)

The FsRtlInitializeFileLock routine initializes a FILE_LOCK structure.

```cpp void FsRtlUninitializeFileLock( PFILE_LOCK FileLock)

The FsRtlUninitializeFileLock routine uninitializes a FILE_LOCK structure.

```cpp NTSTATUS FsRtlProcessFileLock( PFILE_LOCK FileLock, PIRP Irp, PVOID Context)

The FsRtlProcessFileLock routine processes and completes an IRP for a file lock operation.

```cpp BOOLEAN FsRtlCheckLockForReadAccess( PFILE_LOCK FileLock, PIRP Irp)

The FsRtlCheckLockForReadAccess routine determines whether the process associated with a given IRP has read access to a locked region of a file.

```cpp BOOLEAN FsRtlCheckLockForWriteAccess( PFILE_LOCK FileLock, PIRP Irp)

The FsRtlCheckLockForWriteAccess routine determines whether the process associated with a given IRP has write access to a locked region of a file.

```cpp BOOLEAN FsRtlCheckLockForOplockRequest( PFILE_LOCK FileLock, PLARGE_INTEGER AllocationSize)

The FsRtlCheckLockForOplockRequest routine checks for locks within the allocation size of a file. The file lock object is checked for the presence of byte range locks that would prevent an oplock request from being granted.

```cpp BOOLEAN FsRtlFastCheckLockForRead( PFILE_LOCK FileLock, PLARGE_INTEGER StartingByte, PLARGE_INTEGER Length, ULONG Key, PFILE_OBJECT FileObject, PVOID ProcessId)

The FsRtlFastCheckLockForRead routine determines whether the specified process has read access to a locked byte range of a file.

```cpp BOOLEAN FsRtlFastCheckLockForWrite( PFILE_LOCK FileLock, PLARGE_INTEGER StartingByte, PLARGE_INTEGER Length, ULONG Key, PVOID FileObject, PVOID ProcessId)

The FsRtlFastCheckLockForWrite routine determines whether the specified process has write access to a locked byte range of a file.

```cpp PFILE_LOCK_INFO FsRtlGetNextFileLock( PFILE_LOCK FileLock, BOOLEAN Restart)

The FsRtlGetNextFileLock routine is used to enumerate the byte-range locks that currently exist for a specified file.

```cpp BOOLEAN FsRtlAreThereCurrentOrInProgressFileLocks( PFILE_LOCK FileLock)

TheFsRtlAreThereCurrentOrInProgressFileLocks routine determines if there are byte range locks assigned to a file or any lock operations in progress for that file.

```cpp BOOLEAN FsRtlAreThereWaitingFileLocks( PFILE_LOCK FileLock)

The FsRtlAreThereWaitingFileLocks routine checks a file lock queue for any waiting file locks.

```cpp NTSTATUS FsRtlFastUnlockSingle( PFILE_LOCK FileLock, PFILE_OBJECT FileObject, LARGE_INTEGER *FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, PVOID Context, BOOLEAN AlreadySynchronized)

The FsRtlFastUnlockSingle routine releases a byte-range lock that was acquired by the specified process, with the specified key value, file offset, and length, for a file.

```cpp NTSTATUS FsRtlFastUnlockAll( PFILE_LOCK FileLock, PFILE_OBJECT FileObject, PEPROCESS ProcessId, PVOID Context)

The FsRtlFastUnlockAll routine releases all byte-range locks that were acquired by the specified process for a file.

```cpp NTSTATUS FsRtlFastUnlockAllByKey( PFILE_LOCK FileLock, PFILE_OBJECT FileObject, PEPROCESS ProcessId, ULONG Key, PVOID Context)

The FsRtlFastUnlockAllByKey routine releases all byte-range locks that were acquired by the specified process, with the specified key value, for a file.

```cpp BOOLEAN FsRtlPrivateLock( PFILE_LOCK FileLock, PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock, PIO_STATUS_BLOCK Iosb, PIRP Irp, __drv_aliasesMem PVOID Context, BOOLEAN AlreadySynchronized)

The FsRtlPrivateLock routine is obsolete, but is exported to support existing driver binaries. Use FsRtlFastLock instead.

__unnamed_struct_0d46_95

__unnamed_struct_0d46_95.Mutex

__unnamed_struct_0d46_95.Cache

__unnamed_struct_0d46_95.TimerQueue

__unnamed_struct_0d46_95.NumEntries

```cpp void FsRtlInitializeTunnelCache( TUNNEL *Cache)

The FsRtlInitializeTunnelCache routine initializes a new tunnel cache for a volume.

```cpp void FsRtlAddToTunnelCache( TUNNEL *Cache, ULONGLONG DirectoryKey, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, BOOLEAN KeyByShortName, ULONG DataLength, VOID *Data)

The FsRtlAddToTunnelCache routine caches a file name that is removed from a directory when a file is renamed or deleted.

```cpp BOOLEAN FsRtlFindInTunnelCache( TUNNEL *Cache, ULONGLONG DirectoryKey, UNICODE_STRING *Name, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG *DataLength, VOID *Data)

The FsRtlFindInTunnelCache routine searches for a matching entry in the tunnel cache that matches the specified name.

```cpp void FsRtlAddToTunnelCacheEx( TUNNEL *Cache, ULONGLONG DirectoryKey, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG Flags, ULONG DataLength, VOID *Data)

```cpp BOOLEAN FsRtlFindInTunnelCacheEx( TUNNEL *Cache, ULONGLONG DirectoryKey, UNICODE_STRING *Name, UNICODE_STRING *ShortName, UNICODE_STRING *LongName, ULONG Flags, ULONG *DataLength, VOID *Data)

```cpp void FsRtlDeleteKeyFromTunnelCache( TUNNEL *Cache, ULONGLONG DirectoryKey)

The FsRtlDeleteKeyFromTunnelCache routine deletes any tunnel cache entries for files in a directory that is being deleted.

```cpp void FsRtlDeleteTunnelCache( TUNNEL *Cache)

The FsRtlDeleteTunnelCache routine deletes a tunnel cache.

LEGAL_ANSI_CHARACTER_ARRAY

NLS_OEM_LEAD_BYTE_INFO

```cpp void FsRtlDissectDbcs( ANSI_STRING Path, PANSI_STRING FirstName, PANSI_STRING RemainingName)

Given an ANSI or double-byte character set (DBCS) pathname string, the FsRtlDissectDbcs routine returns two strings: one containing the first file name found in the string, the other containing the remaining unparsed portion of the pathname string.

```cpp BOOLEAN FsRtlDoesDbcsContainWildCards( PANSI_STRING Name)

The FsRtlDoesDbcsContainWildCards routine determines whether an ANSI or double-byte character set (DBCS) string contains wildcard characters.

```cpp BOOLEAN FsRtlIsDbcsInExpression( PANSI_STRING Expression, PANSI_STRING Name)

The FsRtlIsDbcsInExpression routine determines whether an ANSI or double-byte character set (DBCS) string matches the specified pattern.

```cpp BOOLEAN FsRtlIsFatDbcsLegal( ANSI_STRING DbcsName, BOOLEAN WildCardsPermissible, BOOLEAN PathNamePermissible, BOOLEAN LeadingBackslashPermissible)

The FsRtlIsFatDbcsLegal routine determines whether the specified ANSI or double-byte character set (DBCS) string is a legal FAT file name.

```cpp BOOLEAN FsRtlIsHpfsDbcsLegal( ANSI_STRING DbcsName, BOOLEAN WildCardsPermissible, BOOLEAN PathNamePermissible, BOOLEAN LeadingBackslashPermissible)

The FsRtlIsHpfsDbcsLegal routine determines whether the specified ANSI or double-byte character set (DBCS) string is a legal HPFS file name.

```cpp NTSTATUS FsRtlNormalizeNtstatus( NTSTATUS Exception, NTSTATUS GenericException)

The FsRtlNormalizeNtstatus routine translates an arbitrary exception into a status value that is handled by the exception filter.

```cpp BOOLEAN FsRtlIsNtstatusExpected( NTSTATUS Exception)

The FsRtlIsNtstatusExpected routine determines whether the specified exception is handled by the exception filter.

```cpp PERESOURCE FsRtlAllocateResource( VOID )

The FsRtlAllocateResource routine is obsolete, but is exported to support existing driver binaries. Use ExAllocateFromNPagedLookasideList and ExInitializeResourceLite instead.

_BASE_MCB

_BASE_MCB.MaximumPairCount

_BASE_MCB.PairCount

_BASE_MCB.PoolType

_BASE_MCB.Flags

_BASE_MCB.Mapping

_LARGE_MCB

_LARGE_MCB.GuardedMutex

_LARGE_MCB.BaseMcb

```cpp void FsRtlInitializeLargeMcb( PLARGE_MCB Mcb, POOL_TYPE PoolType)

The FsRtlInitializeLargeMcb routine initializes a map control block (MCB) structure.

```cpp void FsRtlUninitializeLargeMcb( PLARGE_MCB Mcb)

The FsRtlUninitializeLargeMcb routine uninitializes a large map-control block (MCB).

```cpp void FsRtlResetLargeMcb( PLARGE_MCB Mcb, BOOLEAN SelfSynchronized)

The FsRtlResetLargeMcb routine truncates a map control block (MCB) structure to contain zero mapping pairs. It does not shrink the mapping pairs array.

```cpp void FsRtlTruncateLargeMcb( PLARGE_MCB Mcb, LONGLONG Vbn)

The FsRtlTruncateLargeMcb routine truncates a large map control block (MCB).

```cpp BOOLEAN FsRtlAddLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG Vbn, LONGLONG Lbn, LONGLONG SectorCount)

The FsRtlAddLargeMcbEntry routine adds a new mapping to an existing map control block (MCB).

```cpp void FsRtlRemoveLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG Vbn, LONGLONG SectorCount)

The FsRtlRemoveLargeMcbEntry routine removes one or more mappings from a map control block (MCB).

```cpp BOOLEAN FsRtlLookupLargeMcbEntry( PLARGE_MCB Mcb, LONGLONG Vbn, PLONGLONG Lbn, PLONGLONG SectorCountFromLbn, PLONGLONG StartingLbn, PLONGLONG SectorCountFromStartingLbn, PULONG Index)

Given a virtual block number (VBN) and a map control block (MCB), the FsRtlLookupLargeMcbEntry routine searches the MCB for mapping information corresponding to the specified VBN.

```cpp BOOLEAN FsRtlLookupLastLargeMcbEntry( PLARGE_MCB Mcb, PLONGLONG Vbn, PLONGLONG Lbn)

The FsRtlLookupLastLargeMcbEntry routine retrieves the last mapping entry stored in the map control block (MCB).

```cpp BOOLEAN FsRtlLookupLastLargeMcbEntryAndIndex( PLARGE_MCB OpaqueMcb, PLONGLONG LargeVbn, PLONGLONG LargeLbn, PULONG Index)

The FsRtlLookupLastLargeMcbEntryAndIndex routine retrieves the last mapping entry stored in a given map control block (MCB).

```cpp ULONG FsRtlNumberOfRunsInLargeMcb( PLARGE_MCB Mcb)

The FsRtlNumberOfRunsInLargeMcb routine returns the number of runs in a map control block (MCB).

```cpp BOOLEAN FsRtlGetNextLargeMcbEntry( PLARGE_MCB Mcb, ULONG RunIndex, PLONGLONG Vbn, PLONGLONG Lbn, PLONGLONG SectorCount)

The FsRtlGetNextLargeMcbEntry routine retrieves a mapping run from a map control block (MCB).

```cpp BOOLEAN FsRtlSplitLargeMcb( PLARGE_MCB Mcb, LONGLONG Vbn, LONGLONG Amount)

The FsRtlSplitLargeMcb routine inserts a hole into the mappings in a map control block (MCB).

```cpp void FsRtlInitializeBaseMcb( PBASE_MCB Mcb, POOL_TYPE PoolType)

This routine initializes a new map control block (MCB) structure. The caller must supply the memory for the Mcb structure. This call must precede all other calls that set/query the Mcb structure.

If pool is not available this routine will raise a status value indicating insufficient resources.

```cpp BOOLEAN FsRtlInitializeBaseMcbEx( PBASE_MCB Mcb, POOL_TYPE PoolType, USHORT Flags)

This routine initializes a new Mcb structure. The caller must supply the memory for the Mcb structure. This call must precede all other calls that set/query the Mcb structure.

If pool is not available this routine will raise a status value indicating insufficient resources or return false depending on the flags.

```cpp void FsRtlUninitializeBaseMcb( PBASE_MCB Mcb)

The FsRtlUninitializeBaseMcb function uninitializes a map control block (MCB) structure. After calling this routine the input Mcb structure must be re-initialized before being used again.

```cpp void FsRtlResetBaseMcb( PBASE_MCB Mcb)

```cpp void FsRtlTruncateBaseMcb( PBASE_MCB Mcb, LONGLONG Vbn)

```cpp BOOLEAN FsRtlAddBaseMcbEntry( PBASE_MCB Mcb, LONGLONG Vbn, LONGLONG Lbn, LONGLONG SectorCount)

```cpp NTSTATUS FsRtlAddBaseMcbEntryEx( PBASE_MCB Mcb, LONGLONG Vbn, LONGLONG Lbn, LONGLONG SectorCount)

The FsRtlAddBaseMcbEntryEx function is used to add a new mapping of virtual block numbers (VBN's) to logical block numbers (LBN's) to an existing map control block (MCB).

```cpp BOOLEAN FsRtlRemoveBaseMcbEntry( PBASE_MCB Mcb, LONGLONG Vbn, LONGLONG SectorCount)

The FsRtlRemoveBaseMcbEntry function is the work routine for removing a large map control block (MCB) entry. It does so without taking out the mcb GuardedMutex.

```cpp BOOLEAN FsRtlLookupBaseMcbEntry( PBASE_MCB Mcb, LONGLONG Vbn, PLONGLONG Lbn, PLONGLONG SectorCountFromLbn, PLONGLONG StartingLbn, PLONGLONG SectorCountFromStartingLbn, PULONG Index)

The FsRtlLookupBaseMcbEntry routine retrieves the mapping of a virtual block number (VBN) to a logical block number (LBN) from a map control block (MCB). It indicates if the mapping exists and the size of the run.

```cpp BOOLEAN FsRtlLookupLastBaseMcbEntry( PBASE_MCB Mcb, PLONGLONG Vbn, PLONGLONG Lbn)

```cpp BOOLEAN FsRtlLookupLastBaseMcbEntryAndIndex( PBASE_MCB OpaqueMcb, PLONGLONG LargeVbn, PLONGLONG LargeLbn, PULONG Index)

```cpp ULONG FsRtlNumberOfRunsInBaseMcb( PBASE_MCB Mcb)

```cpp BOOLEAN FsRtlGetNextBaseMcbEntry( PBASE_MCB Mcb, ULONG RunIndex, PLONGLONG Vbn, PLONGLONG Lbn, PLONGLONG SectorCount)

```cpp BOOLEAN FsRtlSplitBaseMcb( PBASE_MCB Mcb, LONGLONG Vbn, LONGLONG Amount)

_MCB

_MCB.DummyFieldThatSizesThisStructureCorrectly

```cpp void FsRtlInitializeMcb( PMCB Mcb, POOL_TYPE PoolType)

The FsRtlInitializeMcb routine is obsolete, but is exported to support existing driver binaries. Use FsRtlInitializeLargeMcb instead.

```cpp void FsRtlUninitializeMcb( PMCB Mcb)

The FsRtlUninitializeMcb routine is obsolete, but is exported to support existing driver binaries. Use FsRtlUninitializeLargeMcb instead.

```cpp void FsRtlTruncateMcb( PMCB Mcb, VBN Vbn)

The FsRtlTruncateMcb routine is obsolete, but is exported to support existing driver binaries. Use FsRtlTruncateLargeMcb instead.

```cpp BOOLEAN FsRtlAddMcbEntry( PMCB Mcb, VBN Vbn, LBN Lbn, ULONG SectorCount)

The FsRtlAddMcbEntry routine is obsolete, but is exported to support existing driver binaries. Use FsRtlAddLargeMcbEntry instead.

```cpp void FsRtlRemoveMcbEntry( PMCB Mcb, VBN Vbn, ULONG SectorCount)

The FsRtlRemoveMcbEntry routine is obsolete, but is exported to support existing driver binaries. Use FsRtlRemoveLargeMcbEntry instead.

```cpp BOOLEAN FsRtlLookupMcbEntry( PMCB Mcb, VBN Vbn, PLBN Lbn, PULONG SectorCount, PULONG Index)

FsRtlLookupMcbEntry is obsolete, but is exported to support existing driver binaries. Use FsRtlLookupLargeMcbEntry instead.

```cpp BOOLEAN FsRtlLookupLastMcbEntry( PMCB Mcb, PVBN Vbn, PLBN Lbn)

The FsRtlLookupLastMcbEntry routine is obsolete, but is exported to support existing driver binaries. Use FsRtlLookupLastLargeMcbEntry instead.

```cpp ULONG FsRtlNumberOfRunsInMcb( PMCB Mcb)

The FsRtlNumberOfRunsInMcb routine is obsolete, but is exported to support existing driver binaries. Use FsRtlNumberOfRunsInLargeMcb instead.

```cpp BOOLEAN FsRtlGetNextMcbEntry( PMCB Mcb, ULONG RunIndex, PVBN Vbn, PLBN Lbn, PULONG SectorCount)

The FsRtlGetNextMcbEntry routine is obsolete, but is exported to support existing driver binaries. Use FsRtlGetNextLargeMcbEntry instead.

```cpp NTSTATUS FsRtlBalanceReads( PDEVICE_OBJECT TargetDevice)

The FsRtlBalanceReads routine signals to a fault-tolerant disk driver that it is now safe to start balancing reads from a mirrored drive.

```cpp void FsRtlInitializeOplock( POPLOCK Oplock)

FsRtlInitializeOplock initializes an opportunistic lock (oplock) pointer.

```cpp void FsRtlUninitializeOplock( POPLOCK Oplock)

FsRtlUninitializeOplock uninitializes an opportunistic lock (oplock) pointer.

```cpp NTSTATUS FsRtlOplockFsctrl( POPLOCK Oplock, PIRP Irp, ULONG OpenCount)

FsRtlOplockFsctrl performs various opportunistic lock (oplock) operations on behalf of a file system or filter driver.

```cpp NTSTATUS FsRtlCheckOplock( POPLOCK Oplock, PIRP Irp, PVOID Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PostIrpRoutine)

The FsRtlCheckOplock routine synchronizes the IRP for a file I/O operation with the file's current opportunistic lock (oplock) state.

```cpp NTSTATUS FsRtlCheckOplockEx( POPLOCK Oplock, PIRP Irp, ULONG Flags, PVOID Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PostIrpRoutine)

The FsRtlCheckOplockEx routine synchronizes the IRP for a file I/O operation with the current opportunistic lock (oplock) state of the file.

```cpp NTSTATUS FsRtlCheckUpperOplock( POPLOCK Oplock, ULONG NewLowerOplockState, PVOID CompletionRoutineContext, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PrePendRoutine, ULONG Flags)

The FsRtlCheckUpperOplock routine provides opportunistic lock (oplock) checking in secondary, or layered, file systems when the oplocks they hold change state. Secondary file systems, such as network redirectors and clustering file services, call FsRtlCheckUpperOplock when an oplock held in a lower file system by the secondary file system, changes state. A state change can occur either by a break or an upgrade. FsRtlCheckUpperOplock will break the oplock of upper file system, if necessary, to confirm the new lower oplock state. The caller can also provide optional callbacks for notifications of break acknowledgment and pending status.

```cpp NTSTATUS FsRtlUpperOplockFsctrl( POPLOCK Oplock, PIRP Irp, ULONG OpenCount, ULONG LowerOplockState, ULONG Flags)

The FsRtlUpperOplockFsctrl routine processes opportunistic lock (oplock) requests and acknowledgments for secondary, or layered, file systems. The upper file system submits the state of the oplock held in the lower file system. FsRtlUpperOplockFsctrl will determine whether to grant or deny the upper file system oplock.

```cpp BOOLEAN FsRtlOplockIsFastIoPossible( POPLOCK Oplock)

FsRtlOplockIsFastIoPossible checks a file's opportunistic lock (oplock) state to determine whether fast I/O can be performed on the file.

```cpp BOOLEAN FsRtlCurrentBatchOplock( POPLOCK Oplock)

A file system or filter driver calls FsRtlCurrentBatchOplock to determine whether there are any batch or filter opportunistic locks (oplocks) on a file.

```cpp BOOLEAN FsRtlCurrentOplock( POPLOCK Oplock)

A file system or filter driver calls FsRtlCurrentOplock to determine whether there are any opportunistic locks (oplocks) on a file.

```cpp NTSTATUS FsRtlOplockBreakToNone( POPLOCK Oplock, PIO_STACK_LOCATION IrpSp, PIRP Irp, PVOID Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PostIrpRoutine)

The FsRtlOplockBreakToNone routine is obsolete, but is exported to support existing driver binaries. Use FsRtlOplockBreakToNoneEx instead.

_OPLOCK_KEY_ECP_CONTEXT

_OPLOCK_KEY_ECP_CONTEXT.OplockKey

_OPLOCK_KEY_ECP_CONTEXT.Reserved

GUID_ECP_OPLOCK_KEY

```cpp BOOLEAN FsRtlOplockIsSharedRequest( PIRP Irp)

The FsRtlOplockIsSharedRequest routine determines if a request for an opportunistic lock (oplock) wants a shared oplock.

```cpp NTSTATUS FsRtlOplockBreakH( POPLOCK Oplock, PIRP Irp, ULONG Flags, PVOID Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PostIrpRoutine)

The FsRtlOplockBreakH routine breaks CACHE_HANDLE_LEVEL opportunistic locks (oplocks).

```cpp BOOLEAN FsRtlCurrentOplockH( POPLOCK Oplock)

A file system or filter driver calls FsRtlCurrentOplockH to determine whether there are any CACHE_HANDLE_LEVEL opportunistic locks (oplocks) on a file.

```cpp NTSTATUS FsRtlOplockBreakToNoneEx( POPLOCK Oplock, PIRP Irp, ULONG Flags, PVOID Context, POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, POPLOCK_FS_PREPOST_IRP PostIrpRoutine)

The FsRtlOplockBreakToNoneEx routine breaks all opportunistic locks (oplocks) immediately without regard for any oplock key.

```cpp NTSTATUS FsRtlOplockFsctrlEx( POPLOCK Oplock, PIRP Irp, ULONG OpenCount, ULONG Flags)

The FsRtlOplockFsctrlEx routine performs various opportunistic lock (oplock) operations on behalf of a file system or filter driver.

```cpp BOOLEAN FsRtlOplockKeysEqual( PFILE_OBJECT Fo1, PFILE_OBJECT Fo2)

The FsRtlOplockKeysEqual routine compares the opportunistic lock (oplock) keys that are stored in the file object extensions of two file objects.

_DUAL_OPLOCK_KEY_ECP_CONTEXT

_DUAL_OPLOCK_KEY_ECP_CONTEXT.ParentOplockKey

_DUAL_OPLOCK_KEY_ECP_CONTEXT.TargetOplockKey

_DUAL_OPLOCK_KEY_ECP_CONTEXT.ParentOplockKeySet

_DUAL_OPLOCK_KEY_ECP_CONTEXT.TargetOplockKeySet

GUID_ECP_DUAL_OPLOCK_KEY

```cpp NTSTATUS FsRtlNotifyVolumeEvent( PFILE_OBJECT FileObject, ULONG EventCode)

The FsRtlNotifyVolumeEvent routine notifies any registered applications that a volume event is occurring.

```cpp NTSTATUS FsRtlNotifyVolumeEventEx( PFILE_OBJECT FileObject, ULONG EventCode, PTARGET_DEVICE_CUSTOM_NOTIFICATION Event)

The FsRtlNotifyVolumeEventEx routine notifies any registered applications that a volume event is occurring. Volume events include the volume being locked, unlocked, mounted, or made read-only.

_REAL_NOTIFY_SYNC

```cpp void FsRtlNotifyInitializeSync( PNOTIFY_SYNC *NotifySync)

The FsRtlNotifyInitializeSync routine allocates and initializes a synchronization object for a notify list.

```cpp void FsRtlNotifyUninitializeSync( PNOTIFY_SYNC *NotifySync)

The FsRtlNotifyUninitializeSync routine deallocates the synchronization object for a notify list.

```cpp void FsRtlNotifyFullChangeDirectory( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList, PVOID FsContext, PSTRING FullDirectoryName, BOOLEAN WatchTree, BOOLEAN IgnoreBuffer, ULONG CompletionFilter, PIRP NotifyIrp, PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback, PSECURITY_SUBJECT_CONTEXT SubjectContext)

The FsRtlNotifyFullChangeDirectory routine creates a notify structure for a notification request and adds it to the specified notify list.

```cpp void FsRtlNotifyFilterChangeDirectory( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList, PVOID FsContext, PSTRING FullDirectoryName, BOOLEAN WatchTree, BOOLEAN IgnoreBuffer, ULONG CompletionFilter, PIRP NotifyIrp, PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback, PSECURITY_SUBJECT_CONTEXT SubjectContext, PFILTER_REPORT_CHANGE FilterCallback)

The FsRtlNotifyFilterChangeDirectory routine creates a notify structure for an IRP_MN_NOTIFY_CHANGE_DIRECTORY request and adds it to the specified notify list.

```cpp void FsRtlNotifyFilterReportChange( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList, PSTRING FullTargetName, USHORT TargetNameOffset, PSTRING StreamName, PSTRING NormalizedParentName, ULONG FilterMatch, ULONG Action, PVOID TargetContext, PVOID FilterContext)

FsRtlNotifyFilterReportChange completes IRP_MN_NOTIFY_CHANGE_DIRECTORY requests that are pending in the specified notify list.

```cpp void FsRtlNotifyFullReportChange( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList, PSTRING FullTargetName, USHORT TargetNameOffset, PSTRING StreamName, PSTRING NormalizedParentName, ULONG FilterMatch, ULONG Action, PVOID TargetContext)

The FsRtlNotifyFullReportChange routine completes pending notify change IRPs.

```cpp void FsRtlNotifyCleanup( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList, PVOID FsContext)

When the last handle to a file object is released, the FsRtlNotifyCleanup routine removes the file object's notify structure, if present, from the specified notify list.

```cpp void FsRtlNotifyCleanupAll( PNOTIFY_SYNC NotifySync, PLIST_ENTRY NotifyList)

The FsRtlNotifyCleanupAll routine removes all members of the specified notification list.

```cpp void FsRtlDissectName( UNICODE_STRING Path, PUNICODE_STRING FirstName, PUNICODE_STRING RemainingName)

Given a Unicode pathname string, the FsRtlDissectName routine returns two strings, one containing the first file name found in the string, the other containing the remaining unparsed portion of the pathname string.

```cpp BOOLEAN FsRtlDoesNameContainWildCards( PUNICODE_STRING Name)

The FsRtlDoesNameContainWildCards routine determines whether a Unicode string contains wildcard characters.

```cpp BOOLEAN FsRtlAreNamesEqual( PCUNICODE_STRING ConstantNameA, PCUNICODE_STRING ConstantNameB, BOOLEAN IgnoreCase, PCWCH UpcaseTable)

The FsRtlAreNamesEqual routine determines whether two Unicode strings are equal.

```cpp BOOLEAN FsRtlIsNameInExpression( PUNICODE_STRING Expression, PUNICODE_STRING Name, BOOLEAN IgnoreCase, PWCH UpcaseTable)

The FsRtlIsNameInExpression routine determines whether a Unicode string matches the specified pattern.

```cpp BOOLEAN FsRtlIsNameInUnUpcasedExpression( PUNICODE_STRING Expression, PUNICODE_STRING Name, BOOLEAN IgnoreCase, PWCH UpcaseTable)

```cpp void FsRtlPostStackOverflow( PVOID Context, PKEVENT Event, PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)

The FsRtlPostStackOverflow routine posts a stack overflow item to the stack overflow thread.

```cpp void FsRtlPostPagingFileStackOverflow( PVOID Context, PKEVENT Event, PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)

The FsRtlPostPagingFileStackOverflow routine posts a paging file stack overflow item to the stack overflow thread.

```cpp NTSTATUS FsRtlRegisterUncProvider( PHANDLE MupHandle, PCUNICODE_STRING RedirectorDeviceName, BOOLEAN MailslotsSupported)

The FsRtlRegisterUncProvider routine registers a network redirector as a universal naming convention (UNC) provider with the system multiple UNC provider (MUP).

```cpp NTSTATUS FsRtlRegisterUncProviderEx( PHANDLE MupHandle, PCUNICODE_STRING RedirDevName, PDEVICE_OBJECT DeviceObject, FSRTL_UNC_PROVIDER_FLAGS Flags)

The FsRtlRegisterUncProviderEx routine registers a network redirector as a universal naming convention (UNC) provider with the system multiple UNC provider (MUP).

_FSRTL_UNC_PROVIDER_REGISTRATION

_FSRTL_UNC_PROVIDER_REGISTRATION.Size

_FSRTL_UNC_PROVIDER_REGISTRATION.Version

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.ProviderFlags

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.DUMMYSTRUCTNAME

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.DUMMYSTRUCTNAME.MailslotsSupported

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.DUMMYSTRUCTNAME.CscEnabled

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.DUMMYSTRUCTNAME.DomainSvcAware

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME.DUMMYSTRUCTNAME.ContainersAware

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2.HardeningCapabilities

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2.DUMMYSTRUCTNAME

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2.DUMMYSTRUCTNAME.SupportsMutualAuth

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2.DUMMYSTRUCTNAME.SupportsIntegrity

_FSRTL_UNC_PROVIDER_REGISTRATION.DUMMYUNIONNAME2.DUMMYSTRUCTNAME.SupportsPrivacy

```cpp NTSTATUS FsRtlRegisterUncProviderEx2( PCUNICODE_STRING RedirDevName, PDEVICE_OBJECT DeviceObject, const FSRTL_UNC_PROVIDER_REGISTRATION *Registration, PHANDLE MupHandle)

```cpp void FsRtlDeregisterUncProvider( HANDLE Handle)

```cpp NTSTATUS FsRtlCancellableWaitForSingleObject( PVOID Object, PLARGE_INTEGER Timeout, PIRP Irp)

```cpp NTSTATUS FsRtlCancellableWaitForMultipleObjects( ULONG Count, PVOID [] ObjectArray, WAIT_TYPE WaitType, PLARGE_INTEGER Timeout, PKWAIT_BLOCK WaitBlockArray, PIRP Irp)

```cpp NTSTATUS FsRtlMupGetProviderInfoFromFileObject( PFILE_OBJECT pFileObject, ULONG Level, PVOID pBuffer, PULONG pBufferSize)

_FSRTL_MUP_PROVIDER_INFO_LEVEL_1

_FSRTL_MUP_PROVIDER_INFO_LEVEL_1.ProviderId

_FSRTL_MUP_PROVIDER_INFO_LEVEL_2

_FSRTL_MUP_PROVIDER_INFO_LEVEL_2.ProviderId

_FSRTL_MUP_PROVIDER_INFO_LEVEL_2.ProviderName

```cpp NTSTATUS FsRtlMupGetProviderIdFromName( PCUNICODE_STRING pProviderName, PULONG32 pProviderId)

_FSRTL_PER_FILE_CONTEXT

_FSRTL_PER_FILE_CONTEXT.Links

_FSRTL_PER_FILE_CONTEXT.OwnerId

_FSRTL_PER_FILE_CONTEXT.InstanceId

_FSRTL_PER_FILE_CONTEXT.FreeCallback

```cpp NTSTATUS FsRtlInsertPerFileContext( PVOID *PerFileContextPointer, PFSRTL_PER_FILE_CONTEXT Ptr)

```cpp PFSRTL_PER_FILE_CONTEXT FsRtlLookupPerFileContext( PVOID *PerFileContextPointer, PVOID OwnerId, PVOID InstanceId)

```cpp PFSRTL_PER_FILE_CONTEXT FsRtlRemovePerFileContext( PVOID *PerFileContextPointer, PVOID OwnerId, PVOID InstanceId)

```cpp void FsRtlTeardownPerFileContexts( PVOID *PerFileContextPointer)

_FSRTL_PER_STREAM_CONTEXT

_FSRTL_PER_STREAM_CONTEXT.Links

_FSRTL_PER_STREAM_CONTEXT.OwnerId

_FSRTL_PER_STREAM_CONTEXT.InstanceId

_FSRTL_PER_STREAM_CONTEXT.FreeCallback

```cpp NTSTATUS FsRtlInsertPerStreamContext( PFSRTL_ADVANCED_FCB_HEADER PerStreamContext, PFSRTL_PER_STREAM_CONTEXT Ptr)

```cpp PFSRTL_PER_STREAM_CONTEXT FsRtlLookupPerStreamContextInternal( PFSRTL_ADVANCED_FCB_HEADER StreamContext, PVOID OwnerId, PVOID InstanceId)

```cpp PFSRTL_PER_STREAM_CONTEXT FsRtlRemovePerStreamContext( PFSRTL_ADVANCED_FCB_HEADER StreamContext, PVOID OwnerId, PVOID InstanceId)

```cpp void FsRtlSetupAdvancedHeader( PVOID AdvHdr, PFAST_MUTEX FMutex)

```cpp void FsRtlTeardownPerStreamContexts( PFSRTL_ADVANCED_FCB_HEADER AdvancedHeader)

_FSRTL_PER_FILEOBJECT_CONTEXT

_FSRTL_PER_FILEOBJECT_CONTEXT.Links

_FSRTL_PER_FILEOBJECT_CONTEXT.OwnerId

_FSRTL_PER_FILEOBJECT_CONTEXT.InstanceId

```cpp NTSTATUS FsRtlInsertPerFileObjectContext( PFILE_OBJECT FileObject, PFSRTL_PER_FILEOBJECT_CONTEXT Ptr)

```cpp PFSRTL_PER_FILEOBJECT_CONTEXT FsRtlLookupPerFileObjectContext( PFILE_OBJECT FileObject, PVOID OwnerId, PVOID InstanceId)

```cpp PFSRTL_PER_FILEOBJECT_CONTEXT FsRtlRemovePerFileObjectContext( PFILE_OBJECT FileObject, PVOID OwnerId, PVOID InstanceId)

```cpp void FsRtlIncrementCcFastReadNotPossible( VOID )

```cpp void FsRtlIncrementCcFastReadWait( VOID )

```cpp void FsRtlIncrementCcFastReadNoWait( VOID )

```cpp void FsRtlIncrementCcFastReadResourceMiss( VOID )

```cpp void FsRtlIncrementCcFastMdlReadWait( VOID )

```cpp LOGICAL FsRtlIsPagingFile( PFILE_OBJECT FileObject)

```cpp LOGICAL FsRtlIsSystemPagingFile( PFILE_OBJECT FileObject)

```cpp NTSTATUS FsRtlCreateSectionForDataScan( PHANDLE SectionHandle, PVOID *SectionObject, PLARGE_INTEGER SectionFileSize, PFILE_OBJECT FileObject, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, PLARGE_INTEGER MaximumSize, ULONG SectionPageProtection, ULONG AllocationAttributes, ULONG Flags)

```cpp NTSTATUS FsRtlValidateReparsePointBuffer( ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer)

```cpp NTSTATUS FsRtlRemoveDotsFromPath( PWSTR OriginalString, USHORT PathLength, USHORT *NewLength)

```cpp BOOLEAN FsRtlIsNonEmptyDirectoryReparsePointAllowed( ULONG ReparseTag)

_ECP_LIST

_ECP_HEADER

```cpp NTSTATUS FsRtlAllocateExtraCreateParameterList( FSRTL_ALLOCATE_ECPLIST_FLAGS Flags, PECP_LIST *EcpList)

```cpp void FsRtlFreeExtraCreateParameterList( PECP_LIST EcpList)

```cpp NTSTATUS FsRtlInitializeExtraCreateParameterList( PECP_LIST EcpList)

```cpp NTSTATUS FsRtlAllocateExtraCreateParameter( LPCGUID EcpType, ULONG SizeOfContext, FSRTL_ALLOCATE_ECP_FLAGS Flags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, ULONG PoolTag, PVOID *EcpContext)

```cpp void FsRtlFreeExtraCreateParameter( PVOID EcpContext)

```cpp void FsRtlInitializeExtraCreateParameter( PECP_HEADER Ecp, ULONG EcpFlags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, ULONG TotalSize, LPCGUID EcpType, PVOID ListAllocatedFrom)

```cpp void FsRtlInitExtraCreateParameterLookasideList( PVOID Lookaside, FSRTL_ECP_LOOKASIDE_FLAGS Flags, SIZE_T Size, ULONG Tag)

```cpp void FsRtlDeleteExtraCreateParameterLookasideList( PVOID Lookaside, FSRTL_ECP_LOOKASIDE_FLAGS Flags)

```cpp NTSTATUS FsRtlAllocateExtraCreateParameterFromLookasideList( LPCGUID EcpType, ULONG SizeOfContext, FSRTL_ALLOCATE_ECP_FLAGS Flags, PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK CleanupCallback, PVOID LookasideList, PVOID *EcpContext)

```cpp NTSTATUS FsRtlInsertExtraCreateParameter( PECP_LIST EcpList, PVOID EcpContext)

```cpp NTSTATUS FsRtlFindExtraCreateParameter( PECP_LIST EcpList, LPCGUID EcpType, PVOID *EcpContext, ULONG *EcpContextSize)

```cpp NTSTATUS FsRtlRemoveExtraCreateParameter( PECP_LIST EcpList, LPCGUID EcpType, PVOID *EcpContext, ULONG *EcpContextSize)

```cpp NTSTATUS FsRtlGetEcpListFromIrp( PIRP Irp, PECP_LIST *EcpList)

```cpp NTSTATUS FsRtlSetEcpListIntoIrp( PIRP Irp, PECP_LIST EcpList)

```cpp NTSTATUS FsRtlGetNextExtraCreateParameter( PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType, PVOID *NextEcpContext, ULONG *NextEcpContextSize)

```cpp void FsRtlAcknowledgeEcp( PVOID EcpContext)

```cpp void FsRtlPrepareToReuseEcp( PVOID EcpContext)

```cpp BOOLEAN FsRtlIsEcpAcknowledged( PVOID EcpContext)

```cpp BOOLEAN FsRtlIsEcpFromUserMode( PVOID EcpContext)

_NETWORK_OPEN_ECP_CONTEXT.#2538700096

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.Size

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.Reserved

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.in

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.in.Location

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.in.Integrity

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.in.Flags

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.out

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.out.Location

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.out.Integrity

_NETWORK_OPEN_ECP_CONTEXT.#2538700096.DUMMYSTRUCTNAME.out.Flags

_NETWORK_OPEN_ECP_CONTEXT_V0

_NETWORK_OPEN_ECP_CONTEXT_V0.Size

_NETWORK_OPEN_ECP_CONTEXT_V0.Reserved

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.in

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.in.Location

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.in.Integrity

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.out

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.out.Location

_NETWORK_OPEN_ECP_CONTEXT_V0.DUMMYSTRUCTNAME.out.Integrity

_NETWORK_OPEN_ECP_CONTEXT.#3724254340

_NETWORK_OPEN_ECP_CONTEXT.#3724254340.Size

_NETWORK_OPEN_ECP_CONTEXT.#3724254340.Reserved

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.in

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.in.Location

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.in.Integrity

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.out

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.out.Location

_NETWORK_OPEN_ECP_CONTEXT.DUMMYSTRUCTNAME.out.Integrity

GUID_ECP_NETWORK_OPEN_CONTEXT

_NETWORK_APP_INSTANCE_ECP_CONTEXT

_NETWORK_APP_INSTANCE_ECP_CONTEXT.Size

_NETWORK_APP_INSTANCE_ECP_CONTEXT.Reserved

_NETWORK_APP_INSTANCE_ECP_CONTEXT.AppInstanceID

GUID_ECP_NETWORK_APP_INSTANCE

_NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT

_NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT.Size

_NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT.Reserved

_NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT.VersionHigh

_NETWORK_APP_INSTANCE_VERSION_ECP_CONTEXT.VersionLow

GUID_ECP_NETWORK_APP_INSTANCE_VERSION

_PREFETCH_OPEN_ECP_CONTEXT

_PREFETCH_OPEN_ECP_CONTEXT.Context

GUID_ECP_PREFETCH_OPEN

sockaddr_storage

GUID_ECP_NFS_OPEN

_NFS_OPEN_ECP_CONTEXT

_NFS_OPEN_ECP_CONTEXT.ExportAlias

_NFS_OPEN_ECP_CONTEXT.ClientSocketAddress

GUID_ECP_SRV_OPEN

_SRV_OPEN_ECP_CONTEXT

_SRV_OPEN_ECP_CONTEXT.ShareName

_SRV_OPEN_ECP_CONTEXT.SocketAddress

_SRV_OPEN_ECP_CONTEXT.OplockBlockState

_SRV_OPEN_ECP_CONTEXT.OplockAppState

_SRV_OPEN_ECP_CONTEXT.OplockFinalState

_SRV_OPEN_ECP_CONTEXT.Version

_SRV_OPEN_ECP_CONTEXT.InstanceType

GUID_ECP_RKF_BYPASS

_RKF_BYPASS_ECP_CONTEXT

_RKF_BYPASS_ECP_CONTEXT.Reserved

_RKF_BYPASS_ECP_CONTEXT.Version

GUID_ECP_IO_DEVICE_HINT

_IO_DEVICE_HINT_ECP_CONTEXT

_IO_DEVICE_HINT_ECP_CONTEXT.TargetDevice

_IO_DEVICE_HINT_ECP_CONTEXT.RemainingName

GUID_ECP_CSV_DOWN_LEVEL_OPEN

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT.Version

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT.IsResume

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT.FileType

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT.SourceNodeId

_CSV_DOWN_LEVEL_OPEN_ECP_CONTEXT.DestinationNodeId

GUID_ECP_CSV_QUERY_FILE_REVISION

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT.FileId

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT.FileRevision

GUID_ECP_CSV_QUERY_FILE_REVISION_FILE_ID_128

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT_FILE_ID_128

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT_FILE_ID_128.FileId

_CSV_QUERY_FILE_REVISION_ECP_CONTEXT_FILE_ID_128.FileRevision

GUID_ECP_CSV_SET_HANDLE_PROPERTIES

_CSV_SET_HANDLE_PROPERTIES_ECP_CONTEXT

_CSV_SET_HANDLE_PROPERTIES_ECP_CONTEXT.Size

_CSV_SET_HANDLE_PROPERTIES_ECP_CONTEXT.PauseTimeoutInSeconds

_CSV_SET_HANDLE_PROPERTIES_ECP_CONTEXT.Flags

_OPEN_REPARSE_LIST_ENTRY

_OPEN_REPARSE_LIST_ENTRY.OpenReparseListEntry

_OPEN_REPARSE_LIST_ENTRY.ReparseTag

_OPEN_REPARSE_LIST_ENTRY.Flags

_OPEN_REPARSE_LIST_ENTRY.ReparseGuid

_OPEN_REPARSE_LIST_ENTRY.Size

_OPEN_REPARSE_LIST_ENTRY.RemainingLength

_OPEN_REPARSE_LIST

_OPEN_REPARSE_LIST.OpenReparseList

ECP_TYPE_OPEN_REPARSE_GUID

_IO_STOP_ON_SYMLINK_FILTER_ECP_v0

_IO_STOP_ON_SYMLINK_FILTER_ECP_v0.Out

_IO_STOP_ON_SYMLINK_FILTER_ECP_v0.Out.ReparseCount

_IO_STOP_ON_SYMLINK_FILTER_ECP_v0.Out.RemainingPathLength

ECP_TYPE_IO_STOP_ON_SYMLINK_FILTER_GUID

ECP_TYPE_CLFS_CREATE_CONTAINER

GUID_ECP_CREATE_REDIRECTION

_CREATE_REDIRECTION_ECP_CONTEXT

_CREATE_REDIRECTION_ECP_CONTEXT.Size

_CREATE_REDIRECTION_ECP_CONTEXT.Flags

_CREATE_REDIRECTION_ECP_CONTEXT.FileId

_CREATE_REDIRECTION_ECP_CONTEXT.VolumeGuid

_FILE_TIMESTAMPS

_FILE_TIMESTAMPS.CreationTime

_FILE_TIMESTAMPS.LastAccessTime

_FILE_TIMESTAMPS.LastWriteTime

_FILE_TIMESTAMPS.ChangeTime

_ATOMIC_CREATE_ECP_CONTEXT

_ATOMIC_CREATE_ECP_CONTEXT.Size

_ATOMIC_CREATE_ECP_CONTEXT.InFlags

_ATOMIC_CREATE_ECP_CONTEXT.OutFlags

_ATOMIC_CREATE_ECP_CONTEXT.ReparseBufferLength

_ATOMIC_CREATE_ECP_CONTEXT.ReparseBuffer

_ATOMIC_CREATE_ECP_CONTEXT.FileSize

_ATOMIC_CREATE_ECP_CONTEXT.ValidDataLength

_ATOMIC_CREATE_ECP_CONTEXT.FileTimestamps

_ATOMIC_CREATE_ECP_CONTEXT.FileAttributes

_ATOMIC_CREATE_ECP_CONTEXT.UsnSourceInfo

_ATOMIC_CREATE_ECP_CONTEXT.Usn

_ATOMIC_CREATE_ECP_CONTEXT.SuppressFileAttributeInheritanceMask

_ATOMIC_CREATE_ECP_CONTEXT.InOpFlags

_ATOMIC_CREATE_ECP_CONTEXT.OutOpFlags

_ATOMIC_CREATE_ECP_CONTEXT.InGenFlags

_ATOMIC_CREATE_ECP_CONTEXT.OutGenFlags

_ATOMIC_CREATE_ECP_CONTEXT.CaseSensitiveFlagsMask

_ATOMIC_CREATE_ECP_CONTEXT.InCaseSensitiveFlags

_ATOMIC_CREATE_ECP_CONTEXT.OutCaseSensitiveFlags

GUID_ECP_ATOMIC_CREATE

_ECP_OPEN_PARAMETERS

_ECP_OPEN_PARAMETERS.Size

_ECP_OPEN_PARAMETERS.Reserved

_ECP_OPEN_PARAMETERS.Flags

GUID_ECP_OPEN_PARAMETERS

_QUERY_ON_CREATE_FILE_STAT_INFORMATION

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.FileId

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.CreationTime

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.LastAccessTime

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.LastWriteTime

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.ChangeTime

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.AllocationSize

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.EndOfFile

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.FileAttributes

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.ReparseTag

_QUERY_ON_CREATE_FILE_STAT_INFORMATION.NumberOfLinks

_QUERY_ON_CREATE_FILE_LX_INFORMATION

_QUERY_ON_CREATE_FILE_LX_INFORMATION.EffectiveAccess

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxFlags

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxUid

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxGid

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxMode

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxDeviceIdMajor

_QUERY_ON_CREATE_FILE_LX_INFORMATION.LxDeviceIdMinor

_QUERY_ON_CREATE_ECP_CONTEXT

_QUERY_ON_CREATE_ECP_CONTEXT.Flags

_QUERY_ON_CREATE_ECP_CONTEXT.StatInformation

_QUERY_ON_CREATE_ECP_CONTEXT.LxInformation

GUID_ECP_QUERY_ON_CREATE

```cpp NTSTATUS FsRtlChangeBackingFileObject( PFILE_OBJECT CurrentFileObject, PFILE_OBJECT NewFileObject, FSRTL_CHANGE_BACKING_TYPE ChangeBackingType, ULONG Flags)

```cpp NTSTATUS FsRtlLogCcFlushError( PUNICODE_STRING FileName, PDEVICE_OBJECT DeviceObject, PSECTION_OBJECT_POINTERS SectionObjectPointer, NTSTATUS FlushError, ULONG Flags)

```cpp BOOLEAN FsRtlAreVolumeStartupApplicationsComplete( VOID )

```cpp ULONG FsRtlQueryMaximumVirtualDiskNestingLevel( VOID )

```cpp NTSTATUS FsRtlGetVirtualDiskNestingLevel( PDEVICE_OBJECT DeviceObject, PULONG NestingLevel, PULONG NestingFlags)

```cpp NTSTATUS FsRtlVolumeDeviceToCorrelationId( PDEVICE_OBJECT VolumeDeviceObject, GUID *Guid)

```cpp NTSTATUS FsRtlIssueDeviceIoControl( PDEVICE_OBJECT DeviceObject, ULONG IoCtl, UCHAR Flags, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength, PULONG_PTR IosbInformation)

```cpp NTSTATUS FsRtlGetSectorSizeInformation( PDEVICE_OBJECT DeviceObject, PFILE_FS_SECTOR_SIZE_INFORMATION SectorSizeInfo)

```cpp NTSTATUS FsRtlGetSupportedFeatures( PDEVICE_OBJECT DeviceObject, PULONG SupportedFeatures)

```cpp NTSTATUS FsRtlKernelFsControlFile( PFILE_OBJECT FileObject, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength, PULONG RetOutputBufferSize)

```cpp NTSTATUS FsRtlQueryKernelEaFile( PFILE_OBJECT FileObject, PVOID ReturnedEaData, ULONG Length, BOOLEAN ReturnSingleEntry, PVOID EaList, ULONG EaListLength, PULONG EaIndex, BOOLEAN RestartScan, PULONG LengthReturned)

```cpp NTSTATUS FsRtlSetKernelEaFile( PFILE_OBJECT FileObject, PVOID EaBuffer, ULONG Length)

```cpp NTSTATUS FsRtlQueryInformationFile( PFILE_OBJECT FileObject, PVOID FileInformation, ULONG Length, FILE_INFORMATION_CLASS FileInformationClass, PULONG RetFileInformationSize)

```cpp NTSTATUS FsRtlQueryCachedVdl( PFILE_OBJECT FileObject, PLONGLONG Vdl)

```cpp void FsRtlUpdateDiskCounters( ULONG64 BytesRead, ULONG64 BytesWritten)

```cpp void FsRtlDismountComplete( PDEVICE_OBJECT DeviceObject, NTSTATUS DismountStatus)

```cpp NTSTATUS FsRtlSetDriverBacking( PDRIVER_OBJECT DriverObj, ULONG Flags)

```cpp BOOLEAN FsRtlIsMobileOS()

```cpp PFN_NUMBER FsRtlIsExtentDangling( PFN_NUMBER StartPage, PFN_NUMBER NumberOfPages, ULONG Flags)

```cpp BOOLEAN FsRtlIsDaxVolume( PFILE_OBJECT FileObject)

_PUBLIC_BCB

_PUBLIC_BCB.NodeTypeCode

_PUBLIC_BCB.NodeByteSize

_PUBLIC_BCB.MappedLength

_PUBLIC_BCB.MappedFileOffset

_CC_FILE_SIZES

_CC_FILE_SIZES.AllocationSize

_CC_FILE_SIZES.FileSize

_CC_FILE_SIZES.ValidDataLength

_READ_AHEAD_PARAMETERS

_READ_AHEAD_PARAMETERS.NodeByteSize

_READ_AHEAD_PARAMETERS.Granularity

_READ_AHEAD_PARAMETERS.PipelinedRequestSize

_READ_AHEAD_PARAMETERS.ReadAheadGrowthPercentage

_CACHE_MANAGER_CALLBACKS

_CACHE_MANAGER_CALLBACKS.AcquireForLazyWrite

_CACHE_MANAGER_CALLBACKS.ReleaseFromLazyWrite

_CACHE_MANAGER_CALLBACKS.AcquireForReadAhead

_CACHE_MANAGER_CALLBACKS.ReleaseFromReadAhead

_CACHE_UNINITIALIZE_EVENT

_CACHE_UNINITIALIZE_EVENT.Next

_CACHE_UNINITIALIZE_EVENT.Event

CcFastMdlReadWait

_CC_ASYNC_READ_CONTEXT

_CC_ASYNC_READ_CONTEXT.CompletionRoutine

_CC_ASYNC_READ_CONTEXT.Context

_CC_ASYNC_READ_CONTEXT.Mdl

_CC_ASYNC_READ_CONTEXT.RequestorMode

_CC_ASYNC_READ_CONTEXT.NestingLevel

```cpp void CcInitializeCacheMap( PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes, BOOLEAN PinAccess, PCACHE_MANAGER_CALLBACKS Callbacks, PVOID LazyWriteContext)

```cpp BOOLEAN CcUninitializeCacheMap( PFILE_OBJECT FileObject, PLARGE_INTEGER TruncateSize, PCACHE_UNINITIALIZE_EVENT UninitializeEvent)

```cpp void CcSetFileSizes( PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes)

```cpp NTSTATUS CcSetFileSizesEx( PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes)

```cpp BOOLEAN CcPurgeCacheSection( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER FileOffset, ULONG Length, ULONG Flags)

```cpp BOOLEAN CcPurgeCacheSection( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN UninitializeCacheMaps)

```cpp void CcCoherencyFlushAndPurgeCache( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER FileOffset, ULONG Length, PIO_STATUS_BLOCK IoStatus, ULONG Flags)

```cpp void CcSetDirtyPageThreshold( PFILE_OBJECT FileObject, ULONG DirtyPageThreshold)

```cpp void CcFlushCache( PSECTION_OBJECT_POINTERS SectionObjectPointer, PLARGE_INTEGER FileOffset, ULONG Length, PIO_STATUS_BLOCK IoStatus)

```cpp LARGE_INTEGER CcGetFlushedValidData( PSECTION_OBJECT_POINTERS SectionObjectPointer, BOOLEAN BcbListHeld)

```cpp BOOLEAN CcZeroData( PFILE_OBJECT FileObject, PLARGE_INTEGER StartOffset, PLARGE_INTEGER EndOffset, BOOLEAN Wait)

```cpp PVOID CcRemapBcb( PVOID Bcb)

```cpp void CcRepinBcb( PVOID Bcb)

```cpp void CcUnpinRepinnedBcb( PVOID Bcb, BOOLEAN WriteThrough, PIO_STATUS_BLOCK IoStatus)

```cpp PFILE_OBJECT CcGetFileObjectFromSectionPtrs( PSECTION_OBJECT_POINTERS SectionObjectPointer)

```cpp PFILE_OBJECT CcGetFileObjectFromSectionPtrsRef( PSECTION_OBJECT_POINTERS SectionObjectPointer)

```cpp PFILE_OBJECT CcGetFileObjectFromBcb( PVOID Bcb)

```cpp BOOLEAN CcCopyWriteWontFlush( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length)

```cpp BOOLEAN CcCanIWrite( PFILE_OBJECT FileObject, ULONG BytesToWrite, BOOLEAN Wait, UCHAR Retrying)

```cpp void CcDeferWrite( PFILE_OBJECT FileObject, PCC_POST_DEFERRED_WRITE PostRoutine, PVOID Context1, PVOID Context2, ULONG BytesToWrite, BOOLEAN Retrying)

```cpp BOOLEAN CcCopyRead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus)

```cpp void CcFastCopyRead( PFILE_OBJECT FileObject, ULONG FileOffset, ULONG Length, ULONG PageCount, PVOID Buffer, PIO_STATUS_BLOCK IoStatus)

```cpp BOOLEAN CcCopyWrite( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer)

```cpp void CcFastCopyWrite( PFILE_OBJECT FileObject, ULONG FileOffset, ULONG Length, PVOID Buffer)

```cpp void CcMdlRead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus)

```cpp void CcMdlReadComplete( PFILE_OBJECT FileObject, PMDL MdlChain)

```cpp void CcPrepareMdlWrite( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, PMDL *MdlChain, PIO_STATUS_BLOCK IoStatus)

```cpp void CcMdlWriteComplete( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PMDL MdlChain)

```cpp void CcMdlWriteAbort( PFILE_OBJECT FileObject, PMDL MdlChain)

```cpp void CcScheduleReadAhead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length)

```cpp NTSTATUS CcWaitForCurrentLazyWriterActivity( VOID )

```cpp void CcSetReadAheadGranularity( PFILE_OBJECT FileObject, ULONG Granularity)

```cpp BOOLEAN CcCopyWriteEx( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)

```cpp BOOLEAN CcCopyReadEx( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)

```cpp BOOLEAN CcAsyncCopyRead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread, PCC_ASYNC_READ_CONTEXT AsyncReadContext)

```cpp void CcScheduleReadAheadEx( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, PETHREAD IoIssuerThread)

```cpp void CcInitializeCacheMapEx( PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes, BOOLEAN PinAccess, PCACHE_MANAGER_CALLBACKS Callbacks, PVOID LazyWriteContext, ULONG Flags)

```cpp BOOLEAN CcPinRead( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG Flags, PVOID *Bcb, PVOID *Buffer)

```cpp BOOLEAN CcMapData( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG Flags, PVOID *Bcb, PVOID *Buffer)

```cpp BOOLEAN CcMapData( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID *Bcb, PVOID *Buffer)

```cpp BOOLEAN CcPinMappedData( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, ULONG Flags, PVOID *Bcb)

```cpp BOOLEAN CcPreparePinWrite( PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Zero, ULONG Flags, PVOID *Bcb, PVOID *Buffer)

```cpp void CcSetDirtyPinnedData( PVOID BcbVoid, PLARGE_INTEGER Lsn)

```cpp void CcUnpinData( PVOID Bcb)

```cpp void CcSetBcbOwnerPointer( PVOID Bcb, PVOID OwnerPointer)

```cpp void CcUnpinDataForThread( PVOID Bcb, ERESOURCE_THREAD ResourceThreadId)

```cpp void CcSetAdditionalCacheAttributes( PFILE_OBJECT FileObject, BOOLEAN DisableReadAhead, BOOLEAN DisableWriteBehind)

```cpp void CcSetAdditionalCacheAttributesEx( PFILE_OBJECT FileObject, ULONG Flags)

```cpp void CcSetParallelFlushFile( PFILE_OBJECT FileObject, BOOLEAN EnableParallelFlush)

```cpp void CcSetLogHandleForFile( PFILE_OBJECT FileObject, PVOID LogHandle, PFLUSH_TO_LSN FlushToLsnRoutine)

```cpp LARGE_INTEGER CcGetDirtyPages( PVOID LogHandle, PDIRTY_PAGE_ROUTINE DirtyPageRoutine, PVOID Context1, PVOID Context2)

```cpp BOOLEAN CcIsThereDirtyData( PVPB Vpb)

```cpp BOOLEAN CcIsThereDirtyDataEx( PVPB Vpb, PULONG NumberOfDirtyPages)

_SecHandle

_SecHandle.dwLower

_SecHandle.dwUpper

_SecPkgInfoW

_SecPkgInfoW.fCapabilities

_SecPkgInfoW.wVersion

_SecPkgInfoW.wRPCID

_SecPkgInfoW.cbMaxToken

_SecPkgInfoW.Name

_SecPkgInfoW.Comment

_SecBuffer

_SecBuffer.cbBuffer

_SecBuffer.BufferType

_SecBuffer.pvBuffer.#486659332

_SecBuffer.pvBuffer.#967516563

_SecBufferDesc

_SecBufferDesc.ulVersion

_SecBufferDesc.cBuffers

_SecBufferDesc.pBuffers

_SEC_NEGOTIATION_INFO

_SEC_NEGOTIATION_INFO.Size

_SEC_NEGOTIATION_INFO.NameLength

_SEC_NEGOTIATION_INFO.Name

_SEC_NEGOTIATION_INFO.Reserved

_SEC_CHANNEL_BINDINGS

_SEC_CHANNEL_BINDINGS.dwInitiatorAddrType

_SEC_CHANNEL_BINDINGS.cbInitiatorLength

_SEC_CHANNEL_BINDINGS.dwInitiatorOffset

_SEC_CHANNEL_BINDINGS.dwAcceptorAddrType

_SEC_CHANNEL_BINDINGS.cbAcceptorLength

_SEC_CHANNEL_BINDINGS.dwAcceptorOffset

_SEC_CHANNEL_BINDINGS.cbApplicationDataLength

_SEC_CHANNEL_BINDINGS.dwApplicationDataOffset

_SEC_APPLICATION_PROTOCOL_LIST

_SEC_APPLICATION_PROTOCOL_LIST.ProtoNegoExt

_SEC_APPLICATION_PROTOCOL_LIST.ProtocolListSize

_SEC_APPLICATION_PROTOCOL_LIST.ProtocolList

_SEC_APPLICATION_PROTOCOLS

_SEC_APPLICATION_PROTOCOLS.ProtocolListsSize

_SEC_APPLICATION_PROTOCOLS.ProtocolLists

_SEC_SRTP_PROTECTION_PROFILES

_SEC_SRTP_PROTECTION_PROFILES.ProfilesSize

_SEC_SRTP_PROTECTION_PROFILES.ProfilesList

_SEC_SRTP_MASTER_KEY_IDENTIFIER

_SEC_SRTP_MASTER_KEY_IDENTIFIER.MasterKeyIdentifierSize

_SEC_SRTP_MASTER_KEY_IDENTIFIER.MasterKeyIdentifier

_SEC_TOKEN_BINDING

_SEC_TOKEN_BINDING.MajorVersion

_SEC_TOKEN_BINDING.MinorVersion

_SEC_TOKEN_BINDING.KeyParametersSize

_SEC_TOKEN_BINDING.KeyParameters

_SEC_PRESHAREDKEY

_SEC_PRESHAREDKEY.KeySize

_SEC_PRESHAREDKEY.Key

_SEC_PRESHAREDKEY_IDENTITY

_SEC_PRESHAREDKEY_IDENTITY.KeyIdentitySize

_SEC_PRESHAREDKEY_IDENTITY.KeyIdentity

_SEC_DTLS_MTU

_SEC_DTLS_MTU.PathMTU

_SecPkgCredentials_NamesW

_SecPkgCredentials_NamesW.sUserName

_SecPkgCredentials_SSIProviderW

_SecPkgCredentials_SSIProviderW.sProviderName

_SecPkgCredentials_SSIProviderW.ProviderInfoLength

_SecPkgCredentials_SSIProviderW.ProviderInfo

_SecPkgCredentials_KdcProxySettingsW

_SecPkgCredentials_KdcProxySettingsW.Version

_SecPkgCredentials_KdcProxySettingsW.Flags

_SecPkgCredentials_KdcProxySettingsW.ProxyServerOffset

_SecPkgCredentials_KdcProxySettingsW.ProxyServerLength

_SecPkgCredentials_KdcProxySettingsW.ClientTlsCredOffset

_SecPkgCredentials_KdcProxySettingsW.ClientTlsCredLength

_SecPkgCredentials_Cert

_SecPkgCredentials_Cert.EncodedCertSize

_SecPkgCredentials_Cert.EncodedCert

_SecPkgContext_SubjectAttributes

_SecPkgContext_SubjectAttributes.AttributeInfo

_SecPkgContext_CredInfo

_SecPkgContext_CredInfo.CredClass

_SecPkgContext_CredInfo.IsPromptingNeeded

_SecPkgContext_NegoPackageInfo

_SecPkgContext_NegoPackageInfo.PackageMask

_SecPkgContext_NegoStatus

_SecPkgContext_NegoStatus.LastStatus

_SecPkgContext_Sizes

_SecPkgContext_Sizes.cbMaxToken

_SecPkgContext_Sizes.cbMaxSignature

_SecPkgContext_Sizes.cbBlockSize

_SecPkgContext_Sizes.cbSecurityTrailer

_SecPkgContext_StreamSizes

_SecPkgContext_StreamSizes.cbHeader

_SecPkgContext_StreamSizes.cbTrailer

_SecPkgContext_StreamSizes.cbMaximumMessage

_SecPkgContext_StreamSizes.cBuffers

_SecPkgContext_StreamSizes.cbBlockSize

_SecPkgContext_NamesW

_SecPkgContext_NamesW.sUserName

_SecPkgContext_Lifespan

_SecPkgContext_Lifespan.tsStart

_SecPkgContext_Lifespan.tsExpiry

_SecPkgContext_DceInfo

_SecPkgContext_DceInfo.AuthzSvc

_SecPkgContext_DceInfo.pPac

_SecPkgContext_KeyInfoW

_SecPkgContext_KeyInfoW.sSignatureAlgorithmName

_SecPkgContext_KeyInfoW.sEncryptAlgorithmName

_SecPkgContext_KeyInfoW.KeySize

_SecPkgContext_KeyInfoW.SignatureAlgorithm

_SecPkgContext_KeyInfoW.EncryptAlgorithm

_SecPkgContext_AuthorityW

_SecPkgContext_AuthorityW.sAuthorityName

_SecPkgContext_ProtoInfoW

_SecPkgContext_ProtoInfoW.sProtocolName

_SecPkgContext_ProtoInfoW.majorVersion

_SecPkgContext_ProtoInfoW.minorVersion

_SecPkgContext_PasswordExpiry

_SecPkgContext_PasswordExpiry.tsPasswordExpires

_SecPkgContext_LogoffTime

_SecPkgContext_LogoffTime.tsLogoffTime

_SecPkgContext_SessionKey

_SecPkgContext_SessionKey.SessionKeyLength

_SecPkgContext_SessionKey.SessionKey

_SecPkgContext_NegoKeys

_SecPkgContext_NegoKeys.KeyType

_SecPkgContext_NegoKeys.KeyLength

_SecPkgContext_NegoKeys.KeyValue

_SecPkgContext_NegoKeys.VerifyKeyType

_SecPkgContext_NegoKeys.VerifyKeyLength

_SecPkgContext_NegoKeys.VerifyKeyValue

_SecPkgContext_PackageInfoW

_SecPkgContext_PackageInfoW.PackageInfo

_SecPkgContext_UserFlags

_SecPkgContext_UserFlags.UserFlags

_SecPkgContext_Flags

_SecPkgContext_Flags.Flags

_SecPkgContext_NegotiationInfoW

_SecPkgContext_NegotiationInfoW.PackageInfo

_SecPkgContext_NegotiationInfoW.NegotiationState

_SecPkgContext_CredentialNameW

_SecPkgContext_CredentialNameW.CredentialType

_SecPkgContext_CredentialNameW.sCredentialName

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY AcquireCredentialsHandleW( PSECURITY_STRING pPrincipal, PSECURITY_STRING pPackage, LPWSTR pszPrincipal, LPWSTR pszPackage, unsigned long fCredentialUse, void *pvLogonId, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY FreeCredentialsHandle( PCredHandle phCredential)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY AddCredentialsW( PCredHandle hCredentials, PSECURITY_STRING pPrincipal, PSECURITY_STRING pPackage, LPWSTR pszPrincipal, LPWSTR pszPackage, unsigned long fCredentialUse, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SEC_ENTRY AddCredentialsA( PCredHandle hCredentials, LPSTR pszPrincipal, LPSTR pszPackage, unsigned long fCredentialUse, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, PTimeStamp ptsExpiry)

_SspiAsyncContext

```cpp SspiAsyncContext * SspiCreateAsyncContext()

```cpp void SspiFreeAsyncContext( SspiAsyncContext *Handle)

```cpp NTSTATUS SspiReinitAsyncContext( SspiAsyncContext *Handle)

```cpp SECURITY_STATUS SspiSetAsyncNotifyCallback( SspiAsyncContext *Context, SspiAsyncNotifyCallback Callback, void *CallbackData)

```cpp BOOLEAN SspiAsyncContextRequiresNotify( SspiAsyncContext *AsyncContext)

```cpp SECURITY_STATUS SspiGetAsyncCallStatus( SspiAsyncContext *Handle)

```cpp SECURITY_STATUS SspiAcquireCredentialsHandleAsyncW( SspiAsyncContext *AsyncContext, PSECURITY_STRING pszPrincipal, PSECURITY_STRING pszPackage, LPWSTR pszPrincipal, LPWSTR pszPackage, unsigned long fCredentialUse, void *pvLogonId, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SspiAcquireCredentialsHandleAsyncA( SspiAsyncContext *AsyncContext, LPSTR pszPrincipal, LPSTR pszPackage, unsigned long fCredentialUse, void *pvLogonId, void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SspiInitializeSecurityContextAsyncW( SspiAsyncContext *AsyncContext, PCredHandle phCredential, PCtxtHandle phContext, PSECURITY_STRING pszTargetName, LPWSTR pszTargetName, unsigned long fContextReq, unsigned long Reserved1, unsigned long TargetDataRep, PSecBufferDesc pInput, unsigned long Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SspiInitializeSecurityContextAsyncA( SspiAsyncContext *AsyncContext, PCredHandle phCredential, PCtxtHandle phContext, LPSTR pszTargetName, unsigned long fContextReq, unsigned long Reserved1, unsigned long TargetDataRep, PSecBufferDesc pInput, unsigned long Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SspiAcceptSecurityContextAsync( SspiAsyncContext *AsyncContext, PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput, unsigned long fContextReq, unsigned long TargetDataRep, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SspiFreeCredentialsHandleAsync( SspiAsyncContext *AsyncContext, PCredHandle phCredential)

```cpp SECURITY_STATUS SspiDeleteSecurityContextAsync( SspiAsyncContext *AsyncContext, PCtxtHandle phContext)

```cpp SECURITY_STATUS SEC_ENTRY ChangeAccountPasswordW( SEC_WCHAR *pszPackageName, SEC_WCHAR *pszDomainName, SEC_WCHAR *pszAccountName, SEC_WCHAR *pszOldPassword, SEC_WCHAR *pszNewPassword, BOOLEAN bImpersonating, unsigned long dwReserved, PSecBufferDesc pOutput)

```cpp SECURITY_STATUS SEC_ENTRY ChangeAccountPasswordA( SEC_CHAR *pszPackageName, SEC_CHAR *pszDomainName, SEC_CHAR *pszAccountName, SEC_CHAR *pszOldPassword, SEC_CHAR *pszNewPassword, BOOLEAN bImpersonating, unsigned long dwReserved, PSecBufferDesc pOutput)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY InitializeSecurityContextW( PCredHandle phCredential, PCtxtHandle phContext, PSECURITY_STRING pTargetName, SEC_WCHAR *pszTargetName, unsigned long fContextReq, unsigned long Reserved1, unsigned long TargetDataRep, PSecBufferDesc pInput, unsigned long Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY AcceptSecurityContext( PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput, unsigned long fContextReq, unsigned long TargetDataRep, PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned long *pfContextAttr, PTimeStamp ptsExpiry)

```cpp SECURITY_STATUS SEC_ENTRY CompleteAuthToken( PCtxtHandle phContext, PSecBufferDesc pToken)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY ImpersonateSecurityContext( PCtxtHandle phContext)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY RevertSecurityContext( PCtxtHandle phContext)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY QuerySecurityContextToken( PCtxtHandle phContext, void **Token)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY DeleteSecurityContext( PCtxtHandle phContext)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY ApplyControlToken( PCtxtHandle phContext, PSecBufferDesc pInput)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY QueryContextAttributesW( PCtxtHandle phContext, unsigned long ulAttribute, void *pBuffer)

```cpp SECURITY_STATUS SEC_ENTRY QueryContextAttributesExW( PCtxtHandle phContext, unsigned long ulAttribute, void *pBuffer, unsigned long cbBuffer)

```cpp SECURITY_STATUS SEC_ENTRY SetContextAttributesW( PCtxtHandle phContext, unsigned long ulAttribute, void *pBuffer, unsigned long cbBuffer)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY QueryCredentialsAttributesW( PCredHandle phCredential, unsigned long ulAttribute, void *pBuffer)

```cpp SECURITY_STATUS SEC_ENTRY QueryCredentialsAttributesExW( PCredHandle phCredential, unsigned long ulAttribute, void *pBuffer, unsigned long cbBuffer)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY SetCredentialsAttributesW( PCredHandle phCredential, unsigned long ulAttribute, void *pBuffer, unsigned long cbBuffer)

```cpp SECURITY_STATUS SEC_ENTRY FreeContextBuffer( PVOID pvContextBuffer)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY MakeSignature( PCtxtHandle phContext, unsigned long fQOP, PSecBufferDesc pMessage, unsigned long MessageSeqNo)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY VerifySignature( PCtxtHandle phContext, PSecBufferDesc pMessage, unsigned long MessageSeqNo, unsigned long *pfQOP)

```cpp SECURITY_STATUS SEC_ENTRY EncryptMessage( PCtxtHandle phContext, unsigned long fQOP, PSecBufferDesc pMessage, unsigned long MessageSeqNo)

```cpp SECURITY_STATUS SEC_ENTRY DecryptMessage( PCtxtHandle phContext, PSecBufferDesc pMessage, unsigned long MessageSeqNo, unsigned long *pfQOP)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY EnumerateSecurityPackagesW( unsigned long *pcPackages, PSecPkgInfoW *ppPackageInfo)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY QuerySecurityPackageInfoW( PSECURITY_STRING pPackageName, LPWSTR pszPackageName, PSecPkgInfoW *ppPackageInfo)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY ExportSecurityContext( PCtxtHandle phContext, ULONG fFlags, PSecBuffer pPackedContext, void **pToken)

```cpp KSECDDDECLSPEC SECURITY_STATUS SEC_ENTRY ImportSecurityContextW( PSECURITY_STRING pszPackage, LPWSTR pszPackage, PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)

```cpp KSECDDDECLSPEC NTSTATUS SecMakeSPN( IN PUNICODE_STRING ServiceClass, IN PUNICODE_STRING ServiceName, IN PUNICODE_STRING InstanceName, IN USHORT InstancePort, IN PUNICODE_STRING Referrer, IN OUT PUNICODE_STRING Spn, OUT PULONG Length, IN BOOLEAN Allocate)

```cpp KSECDDDECLSPEC NTSTATUS SecMakeSPNEx( IN PUNICODE_STRING ServiceClass, IN PUNICODE_STRING ServiceName, IN PUNICODE_STRING InstanceName, IN USHORT InstancePort, IN PUNICODE_STRING Referrer, IN PUNICODE_STRING TargetInfo, IN OUT PUNICODE_STRING Spn, OUT PULONG Length, IN BOOLEAN Allocate)

```cpp KSECDDDECLSPEC NTSTATUS SecMakeSPNEx2( IN PUNICODE_STRING ServiceClass, IN PUNICODE_STRING ServiceName, IN PUNICODE_STRING InstanceName, IN USHORT InstancePort, IN PUNICODE_STRING Referrer, IN PUNICODE_STRING InTargetInfo, IN OUT PUNICODE_STRING Spn, OUT PULONG TotalSize, IN BOOLEAN Allocate, IN BOOLEAN IsTargetInfoMarshaled)

```cpp KSECDDDECLSPEC NTSTATUS SEC_ENTRY SecLookupAccountSid( PSID Sid, PULONG NameSize, PUNICODE_STRING NameBuffer, PULONG DomainSize, PUNICODE_STRING DomainBuffer, PSID_NAME_USE NameUse)

```cpp KSECDDDECLSPEC NTSTATUS SEC_ENTRY SecLookupAccountName( PUNICODE_STRING Name, PULONG SidSize, PSID Sid, PSID_NAME_USE NameUse, PULONG DomainSize, PUNICODE_STRING ReferencedDomain)

```cpp KSECDDDECLSPEC NTSTATUS SEC_ENTRY SecLookupWellKnownSid( WELL_KNOWN_SID_TYPE SidType, PSID Sid, ULONG SidBufferSize, PULONG SidSize)

_SECURITY_FUNCTION_TABLE_W

_SECURITY_FUNCTION_TABLE_W.dwVersion

_SECURITY_FUNCTION_TABLE_W.EnumerateSecurityPackagesW

_SECURITY_FUNCTION_TABLE_W.QueryCredentialsAttributesW

_SECURITY_FUNCTION_TABLE_W.AcquireCredentialsHandleW

_SECURITY_FUNCTION_TABLE_W.FreeCredentialsHandle

_SECURITY_FUNCTION_TABLE_W.Reserved2

_SECURITY_FUNCTION_TABLE_W.InitializeSecurityContextW

_SECURITY_FUNCTION_TABLE_W.AcceptSecurityContext

_SECURITY_FUNCTION_TABLE_W.CompleteAuthToken

_SECURITY_FUNCTION_TABLE_W.DeleteSecurityContext

_SECURITY_FUNCTION_TABLE_W.ApplyControlToken

_SECURITY_FUNCTION_TABLE_W.QueryContextAttributesW

_SECURITY_FUNCTION_TABLE_W.ImpersonateSecurityContext

_SECURITY_FUNCTION_TABLE_W.RevertSecurityContext

_SECURITY_FUNCTION_TABLE_W.MakeSignature

_SECURITY_FUNCTION_TABLE_W.VerifySignature

_SECURITY_FUNCTION_TABLE_W.FreeContextBuffer

_SECURITY_FUNCTION_TABLE_W.QuerySecurityPackageInfoW

_SECURITY_FUNCTION_TABLE_W.Reserved3

_SECURITY_FUNCTION_TABLE_W.Reserved4

_SECURITY_FUNCTION_TABLE_W.ExportSecurityContext

_SECURITY_FUNCTION_TABLE_W.ImportSecurityContextW

_SECURITY_FUNCTION_TABLE_W.AddCredentialsW

_SECURITY_FUNCTION_TABLE_W.Reserved8

_SECURITY_FUNCTION_TABLE_W.QuerySecurityContextToken

_SECURITY_FUNCTION_TABLE_W.EncryptMessage

_SECURITY_FUNCTION_TABLE_W.DecryptMessage

_SECURITY_FUNCTION_TABLE_W.SetContextAttributesW

_SECURITY_FUNCTION_TABLE_W.SetCredentialsAttributesW

_SECURITY_FUNCTION_TABLE_W.ChangeAccountPasswordW

_SECURITY_FUNCTION_TABLE_W.Reserved9

_SECURITY_FUNCTION_TABLE_W.QueryContextAttributesExW

_SECURITY_FUNCTION_TABLE_W.QueryCredentialsAttributesExW

```cpp KSECDDDECLSPEC PSecurityFunctionTableW SEC_ENTRY InitSecurityInterfaceW( void )

_SEC_WINNT_AUTH_IDENTITY_EX2

_SEC_WINNT_AUTH_IDENTITY_EX2.Version

_SEC_WINNT_AUTH_IDENTITY_EX2.cbHeaderLength

_SEC_WINNT_AUTH_IDENTITY_EX2.cbStructureLength

_SEC_WINNT_AUTH_IDENTITY_EX2.UserOffset

_SEC_WINNT_AUTH_IDENTITY_EX2.UserLength

_SEC_WINNT_AUTH_IDENTITY_EX2.DomainOffset

_SEC_WINNT_AUTH_IDENTITY_EX2.DomainLength

_SEC_WINNT_AUTH_IDENTITY_EX2.PackedCredentialsOffset

_SEC_WINNT_AUTH_IDENTITY_EX2.PackedCredentialsLength

_SEC_WINNT_AUTH_IDENTITY_EX2.Flags

_SEC_WINNT_AUTH_IDENTITY_EX2.PackageListOffset

_SEC_WINNT_AUTH_IDENTITY_EX2.PackageListLength

_SEC_WINNT_AUTH_IDENTITY_W

_SEC_WINNT_AUTH_IDENTITY_W.User

_SEC_WINNT_AUTH_IDENTITY_W.UserLength

_SEC_WINNT_AUTH_IDENTITY_W.Domain

_SEC_WINNT_AUTH_IDENTITY_W.DomainLength

_SEC_WINNT_AUTH_IDENTITY_W.Password

_SEC_WINNT_AUTH_IDENTITY_W.PasswordLength

_SEC_WINNT_AUTH_IDENTITY_W.Flags

_SEC_WINNT_AUTH_IDENTITY_EXW

_SEC_WINNT_AUTH_IDENTITY_EXW.Version

_SEC_WINNT_AUTH_IDENTITY_EXW.Length

_SEC_WINNT_AUTH_IDENTITY_EXW.User

_SEC_WINNT_AUTH_IDENTITY_EXW.UserLength

_SEC_WINNT_AUTH_IDENTITY_EXW.Domain

_SEC_WINNT_AUTH_IDENTITY_EXW.DomainLength

_SEC_WINNT_AUTH_IDENTITY_EXW.Password

_SEC_WINNT_AUTH_IDENTITY_EXW.PasswordLength

_SEC_WINNT_AUTH_IDENTITY_EXW.Flags

_SEC_WINNT_AUTH_IDENTITY_EXW.PackageList

_SEC_WINNT_AUTH_IDENTITY_EXW.PackageListLength

```cpp SECURITY_STATUS SEC_ENTRY SspiEncodeAuthIdentityAsStrings( PSEC_WINNT_AUTH_IDENTITY_OPAQUE pAuthIdentity, PCWSTR *ppszUserName, PCWSTR *ppszDomainName, PCWSTR *ppszPackedCredentialsString)

```cpp SECURITY_STATUS SEC_ENTRY SspiValidateAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData)

```cpp SECURITY_STATUS SEC_ENTRY SspiCopyAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *AuthDataCopy)

```cpp VOID SEC_ENTRY SspiFreeAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData)

```cpp VOID SEC_ENTRY SspiZeroAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthData)

```cpp VOID SEC_ENTRY SspiLocalFree( PVOID DataBuffer)

```cpp SECURITY_STATUS SEC_ENTRY SspiEncodeStringsAsAuthIdentity( PCWSTR pszUserName, PCWSTR pszDomainName, PCWSTR pszPackedCredentialsString, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppAuthIdentity)

```cpp SECURITY_STATUS SEC_ENTRY SspiCompareAuthIdentities( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity1, PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity2, PBOOLEAN SameSuppliedUser, PBOOLEAN SameSuppliedIdentity)

```cpp SECURITY_STATUS SEC_ENTRY SspiMarshalAuthIdentity( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity, unsigned long *AuthIdentityLength, char **AuthIdentityByteArray)

```cpp SECURITY_STATUS SEC_ENTRY SspiUnmarshalAuthIdentity( unsigned long AuthIdentityLength, char *AuthIdentityByteArray, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppAuthIdentity)

```cpp BOOLEAN SEC_ENTRY SspiIsPromptingNeeded( unsigned long ErrorOrNtStatus)

```cpp SECURITY_STATUS SEC_ENTRY SspiGetTargetHostName( PCWSTR pszTargetName, PWSTR *pszHostName)

```cpp SECURITY_STATUS SEC_ENTRY SspiExcludePackage( PSEC_WINNT_AUTH_IDENTITY_OPAQUE AuthIdentity, PCWSTR pszPackageName, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *ppNewAuthIdentity)

_SECURITY_USER_DATA

_SECURITY_USER_DATA.UserName

_SECURITY_USER_DATA.LogonDomainName

_SECURITY_USER_DATA.LogonServer

_SECURITY_USER_DATA.pSid

```cpp NTSTATUS SEC_ENTRY GetSecurityUserInfo( PLUID LogonId, ULONG Flags, PSecurityUserData *UserInformation)

```cpp NTSTATUS SEC_ENTRY MapSecurityError( SECURITY_STATUS SecStatus)

_QUERY_PATH_REQUEST

_QUERY_PATH_REQUEST.PathNameLength

_QUERY_PATH_REQUEST.SecurityContext

_QUERY_PATH_REQUEST.FilePathName

_QUERY_PATH_REQUEST_EX

_QUERY_PATH_REQUEST_EX.pSecurityContext

_QUERY_PATH_REQUEST_EX.EaLength

_QUERY_PATH_REQUEST_EX.pEaBuffer

_QUERY_PATH_REQUEST_EX.PathName

_QUERY_PATH_REQUEST_EX.DomainServiceName

_QUERY_PATH_REQUEST_EX.EcpList

_QUERY_PATH_REQUEST_EX.Silo

_QUERY_PATH_REQUEST_EX.Reserved.#3008142778

_QUERY_PATH_REQUEST_EX.Reserved.#2972206388

_QUERY_PATH_RESPONSE

_QUERY_PATH_RESPONSE.LengthAccepted

```cpp NTSYSAPI NTSTATUS ZwQueryObject( HANDLE Handle, OBJECT_INFORMATION_CLASS ObjectInformationClass, PVOID ObjectInformation, ULONG ObjectInformationLength, PULONG ReturnLength)

```cpp NTSYSAPI NTSTATUS ZwNotifyChangeKey( HANDLE KeyHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG CompletionFilter, BOOLEAN WatchTree, PVOID Buffer, ULONG BufferSize, BOOLEAN Asynchronous)

```cpp NTSYSAPI NTSTATUS ZwCreateEvent( PHANDLE EventHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, EVENT_TYPE EventType, BOOLEAN InitialState)

```cpp NTSYSAPI NTSTATUS ZwDeleteFile( POBJECT_ATTRIBUTES ObjectAttributes)

```cpp NTSYSAPI NTSTATUS ZwDeviceIoControlFile( HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)

```cpp NTSYSAPI NTSTATUS ZwQueryDirectoryFile( HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID FileInformation, ULONG Length, FILE_INFORMATION_CLASS FileInformationClass, BOOLEAN ReturnSingleEntry, PUNICODE_STRING FileName, BOOLEAN RestartScan)

```cpp NTSYSAPI NTSTATUS ZwQueryDirectoryFileEx( HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID FileInformation, ULONG Length, FILE_INFORMATION_CLASS FileInformationClass, ULONG QueryFlags, PUNICODE_STRING FileName)

```cpp NTSYSAPI NTSTATUS ZwQueryVolumeInformationFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID FsInformation, ULONG Length, FS_INFORMATION_CLASS FsInformationClass)

```cpp NTSYSAPI NTSTATUS ZwSetVolumeInformationFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID FsInformation, ULONG Length, FS_INFORMATION_CLASS FsInformationClass)

```cpp NTSYSAPI NTSTATUS ZwFsControlFile( HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)

```cpp NTSYSAPI NTSTATUS ZwDuplicateObject( HANDLE SourceProcessHandle, HANDLE SourceHandle, HANDLE TargetProcessHandle, PHANDLE TargetHandle, ACCESS_MASK DesiredAccess, ULONG HandleAttributes, ULONG Options)

```cpp NTSYSAPI NTSTATUS ZwOpenDirectoryObject( PHANDLE DirectoryHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes)

```cpp NTSYSAPI NTSTATUS ZwAllocateVirtualMemory( HANDLE ProcessHandle, PVOID *BaseAddress, ULONG_PTR ZeroBits, PSIZE_T RegionSize, ULONG AllocationType, ULONG Protect)

```cpp NTSYSAPI NTSTATUS ZwAllocateVirtualMemoryEx( HANDLE ProcessHandle, PVOID *BaseAddress, PSIZE_T RegionSize, ULONG AllocationType, ULONG PageProtection, PMEM_EXTENDED_PARAMETER ExtendedParameters, ULONG ExtendedParameterCount)

```cpp NTSYSAPI NTSTATUS ZwFreeVirtualMemory( HANDLE ProcessHandle, PVOID *BaseAddress, PSIZE_T RegionSize, ULONG FreeType)

```cpp NTSYSAPI NTSTATUS ZwQueryVirtualMemory( HANDLE ProcessHandle, PVOID BaseAddress, MEMORY_INFORMATION_CLASS MemoryInformationClass, PVOID MemoryInformation, SIZE_T MemoryInformationLength, PSIZE_T ReturnLength)

```cpp NTSYSAPI NTSTATUS ZwSetInformationVirtualMemory( HANDLE ProcessHandle, VIRTUAL_MEMORY_INFORMATION_CLASS VmInformationClass, ULONG_PTR NumberOfEntries, PMEMORY_RANGE_ENTRY VirtualAddresses, PVOID VmInformation, ULONG VmInformationLength)

```cpp NTSYSAPI NTSTATUS ZwWaitForSingleObject( HANDLE Handle, BOOLEAN Alertable, PLARGE_INTEGER Timeout)

```cpp NTSYSAPI NTSTATUS ZwSetEvent( HANDLE EventHandle, PLONG PreviousState)

```cpp NTSYSAPI NTSTATUS ZwFlushVirtualMemory( HANDLE ProcessHandle, PVOID *BaseAddress, PSIZE_T RegionSize, PIO_STATUS_BLOCK IoStatus)

```cpp NTSYSAPI NTSTATUS ZwOpenProcessTokenEx( HANDLE ProcessHandle, ACCESS_MASK DesiredAccess, ULONG HandleAttributes, PHANDLE TokenHandle)

```cpp NTSYSAPI NTSTATUS ZwOpenThreadTokenEx( HANDLE ThreadHandle, ACCESS_MASK DesiredAccess, BOOLEAN OpenAsSelf, ULONG HandleAttributes, PHANDLE TokenHandle)

```cpp NTSYSAPI NTSTATUS ZwQueryInformationToken( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, PVOID TokenInformation, ULONG TokenInformationLength, PULONG ReturnLength)

```cpp NTSYSAPI NTSTATUS ZwSetInformationToken( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, PVOID TokenInformation, ULONG TokenInformationLength)

```cpp NTSYSAPI NTSTATUS ZwSetSecurityObject( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor)

```cpp NTSYSAPI NTSTATUS ZwQuerySecurityObject( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG Length, PULONG LengthNeeded)

```cpp NTSYSAPI NTSTATUS ZwLockFile( HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER ByteOffset, PLARGE_INTEGER Length, ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock)

```cpp NTSYSAPI NTSTATUS ZwUnlockFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER ByteOffset, PLARGE_INTEGER Length, ULONG Key)

```cpp NTSYSAPI NTSTATUS ZwQueryQuotaInformationFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, BOOLEAN ReturnSingleEntry, PVOID SidList, ULONG SidListLength, PSID StartSid, BOOLEAN RestartScan)

```cpp NTSYSAPI NTSTATUS ZwSetQuotaInformationFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length)

```cpp NTSYSAPI NTSTATUS ZwFlushBuffersFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock)

```cpp NTSYSAPI NTSTATUS ZwFlushBuffersFileEx( HANDLE FileHandle, ULONG FLags, PVOID Parameters, ULONG ParametersSize, PIO_STATUS_BLOCK IoStatusBlock)

```cpp NTSTATUS ZwQueryEaFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, BOOLEAN ReturnSingleEntry, PVOID EaList, ULONG EaListLength, PULONG EaIndex, BOOLEAN RestartScan)

```cpp NTSTATUS ZwSetEaFile( HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length)

```cpp NTSYSAPI NTSTATUS ZwDuplicateToken( HANDLE ExistingTokenHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, BOOLEAN EffectiveOnly, TOKEN_TYPE TokenType, PHANDLE NewTokenHandle)

FSRTL_COMMON_FCB_HEADER

Remarks

The FSRTL_ADVANCED_FCB_HEADER structure is a superset of the FSRTL_COMMON_FCB_HEADER structure. File systems (including legacy filter and minifilter drivers, when applicable) must use the FSRTL_ADVANCED_FCB_HEADER structure.

File systems must use the FsRtlSetupAdvancedHeader macro or the FsRtlSetupAdvancedHeaderEx macro to initialize an FSRTL_ADVANCED_FCB_HEADER structure.

The following flags are set by the FsRtlSetupAdvancedHeader and FsRtlSetupAdvancedHeaderEx macros.

Flag Meaning
FSRTL_FLAG_ADVANCED_HEADER Set in the Flags member of the FSRTL_COMMON_FCB_HEADER structure, this flag indicates file system driver support for FSRTL_ADVANCED_FCB_HEADER structures. This flag should not be modified.
FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS Set in the Flags2 member of FSRTL_COMMON_FCB_HEADER, this flag indicates support for filter driver contexts. This flag can only be cleared for paging files (see information after the table).
FSRTL_FCB_HEADER_V1 Set in the Version member of FSRTL_COMMON_FCB_HEADER, this value indicates support for the PushLock and FilterContextPointer members. This flag should not be modified.
FSRTL_FCB_HEADER_V2 Set in the Version member of FSRTL_COMMON_FCB_HEADER, this value indicates support for the PushLock, FilterContextPointer, Oplock, and ReservedForRemote members. This flag should not be modified.

File systems must set the FsContext member of every file object to point to an FSRTL_ADVANCED_FCB_HEADER structure. This structure can be embedded inside of a context object structure that is specific to a file-system stream (the remainder of the structure is file-system–specific). Usually, this structure is a file control block (FCB). However, on some file systems that support multiple data streams, such as NTFS, it is a stream control block (SCB). Note that FCBs and SCBs for all classes of open requests, including volume open requests, must include this structure.

If the file is a paging file, the FSRTL_ADVANCED_FCB_HEADER structure must be allocated from a nonpaged pool. Otherwise, it can be allocated from a paged or nonpaged pool.

All Microsoft file systems disable stream context support for paging files by clearing the FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS flag in the Flags2 member of FSRTL_COMMON_FCB_HEADER after they call FsRtlSetupAdvancedHeader. (See the FatCreateFcb function in Strucsup.c for the FASTFAT WDK sample.) You are strongly encouraged to do the same in your file system or systems so that the operating system will behave in a consistent manner across all file systems.

Requirements

   
Header ntifs.h (include Ntifs.h, Fltkernel.h)

See Also

FSRTL_COMMON_FCB_HEADER

FSRTL_PER_STREAM_CONTEXT

FsRtlInsertPerStreamContext

FsRtlLookupPerStreamContext

FsRtlRemovePerStreamContext

FsRtlSetupAdvancedHeader

FsRtlSetupAdvancedHeaderEx

FsRtlTeardownPerStreamContexts