---
title: "vc实现用文件系统过滤驱动实现文件隐藏的类"
author: "winzenghua"
date: "2009-08-17T13:57:00Z"
tags: []
slug: "vc"
draft: false
lastmod: "2009-08-17T13:57:00Z"
id: 948118
url: "https://java4gis.iteye.com/blog/948118"
---

调用一个开源的文件过滤驱动，

头文件

typedef struct \_ATTACH\_EXTENSION {

CHARVolumeLetter;  
PDEVICE\_OBJECTVolumeDevice;

} ATTACH\_EXTENSION, \*PATTACH\_EXTENSION;

PDRIVER\_OBJECT g\_DriverObject;

源文件  
#include &lt;ntifs.h&gt;  
#include "HideDirFile.h"

//-------------------------------------------------  
// F A S T I / O  
//-------------------------------------------------

BOOLEAN  
FilemonFastIoCheckifPossible(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
IN BOOLEAN CheckForReadOperation,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoRead(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
IN PVOID Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoQueryBasicInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT PFILE\_BASIC\_INFORMATION Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoQueryStandardInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT PFILE\_STANDARD\_INFORMATION Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoLock(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
BOOLEAN FailImmediately,  
BOOLEAN ExclusiveLock,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoUnlockSingle(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoUnlockAll(  
IN PFILE\_OBJECT FileObject,  
PEPROCESS ProcessId,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoUnlockAllByKey(  
IN PFILE\_OBJECT FileObject,  
PEPROCESS ProcessId, ULONG Key,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoDeviceControl(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
IN PVOID InputBuffer,  
IN ULONG InputBufferLength,  
OUT PVOID OutbufBuffer,  
IN ULONG OutputBufferLength,  
IN ULONG IoControlCode,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

VOID  
FilemonFastIoAcquireFile(  
PFILE\_OBJECT FileObject  
);

VOID  
FilemonFastIoReleaseFile(  
PFILE\_OBJECT FileObject  
);

VOID  
FilemonFastIoDetachDevice(  
PDEVICE\_OBJECT SourceDevice,  
PDEVICE\_OBJECT TargetDevice  
);

//  
// These are new NT 4.0 Fast I/O calls  
//  
BOOLEAN  
FilemonFastIoQueryNetworkOpenInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT struct \_FILE\_NETWORK\_OPEN\_INFORMATION \*Buffer,  
OUT struct \_IO\_STATUS\_BLOCK \*IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

NTSTATUS  
FilemonFastIoAcquireForModWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER EndingOffset,  
OUT struct \_ERESOURCE \*\*ResourceToRelease,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoMdlRead(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoMdlReadComplete(  
IN PFILE\_OBJECT FileObject,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoPrepareMdlWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoMdlWriteComplete(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoReadCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
OUT struct \_COMPRESSED\_DATA\_INFO \*CompressedDataInfo,  
IN ULONG CompressedDataInfoLength,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoWriteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
IN PVOID Buffer,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_COMPRESSED\_DATA\_INFO \*CompressedDataInfo,  
IN ULONG CompressedDataInfoLength,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoMdlReadCompleteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoMdlWriteCompleteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
);

BOOLEAN  
FilemonFastIoQueryOpen(  
IN struct \_IRP \*Irp,  
OUT PFILE\_NETWORK\_OPEN\_INFORMATION NetworkInformation,  
IN PDEVICE\_OBJECT DeviceObject  
);

NTSTATUS  
FilemonFastIoReleaseForModWrite(  
IN PFILE\_OBJECT FileObject,  
IN struct \_ERESOURCE \*ResourceToRelease,  
IN PDEVICE\_OBJECT DeviceObject  
);

NTSTATUS  
FilemonFastIoAcquireForCcFlush(  
IN PFILE\_OBJECT FileObject,  
IN PDEVICE\_OBJECT DeviceObject  
);

NTSTATUS  
FilemonFastIoReleaseForCcFlush(  
IN PFILE\_OBJECT FileObject,  
IN PDEVICE\_OBJECT DeviceObject  
);

//-------------------------------------------------  
// C U S T O M F U N C T I O N  
//-------------------------------------------------

NTSTATUS  
GetVolumesToAttach(  
OUT PULONG VolumesToAttach  
);

NTSTATUS  
AttachAllVolume(  
IN PDRIVER\_OBJECT DriverObject  
);

NTSTATUS  
AttachOneVolume(  
INULONGVolume,  
INPDRIVER\_OBJECTDriverObject  
);

NTSTATUS  
FilterDispatch(  
INPDEVICE\_OBJECTDeviceObject,  
INPIRPIrp  
);

NTSTATUS  
CompletionRoutine(  
INPDEVICE\_OBJECTDeviceObject,  
INPIRPIrp,  
INPVOIDContext  
);

BOOLEAN  
HideOrNot(  
INPWCHARFileName,  
INULONGFileNameLength  
);

VOID  
HideHandler(  
INULONGIndex,  
INPFILE\_BOTH\_DIR\_INFORMATIONCurrEntry,  
INPFILE\_BOTH\_DIR\_INFORMATIONLastEntry,  
INPIRPIrp  
);

//-------------------------------------------------  
// N A T I V E A P I F U N C T I O N  
//-------------------------------------------------

#defineProcessDeviceMap23

#defineDRIVE\_UNKNOWN0  
#defineDRIVE\_NO\_ROOT\_DIR1  
#defineDRIVE\_REMOVABLE2  
#defineDRIVE\_CDROM5

NTSTATUS  
ZwQueryInformationProcess(  
INHANDLEProcessHandle,  
INULONGProcessInformationClass,  
OUTPVOIDProcessInformation,  
INULONGProcessInformationLength,  
OUTPULONGReturnLength  
);

FAST\_IO\_DISPATCH FastIOHook = {

sizeof(FAST\_IO\_DISPATCH),  
FilemonFastIoCheckifPossible,  
FilemonFastIoRead,  
FilemonFastIoWrite,  
FilemonFastIoQueryBasicInfo,  
FilemonFastIoQueryStandardInfo,  
FilemonFastIoLock,  
FilemonFastIoUnlockSingle,  
FilemonFastIoUnlockAll,  
FilemonFastIoUnlockAllByKey,  
FilemonFastIoDeviceControl,  
FilemonFastIoAcquireFile,  
FilemonFastIoReleaseFile,  
FilemonFastIoDetachDevice,

//  
// new for NT 4.0  
//  
FilemonFastIoQueryNetworkOpenInfo,  
FilemonFastIoAcquireForModWrite,  
FilemonFastIoMdlRead,  
FilemonFastIoMdlReadComplete,  
FilemonFastIoPrepareMdlWrite,  
FilemonFastIoMdlWriteComplete,  
FilemonFastIoReadCompressed,  
FilemonFastIoWriteCompressed,  
FilemonFastIoMdlReadCompleteCompressed,  
FilemonFastIoMdlWriteCompleteCompressed,  
FilemonFastIoQueryOpen,  
FilemonFastIoReleaseForModWrite,  
FilemonFastIoAcquireForCcFlush,  
FilemonFastIoReleaseForCcFlush  
};

NTSTATUS  
DriverEntry(  
INPDRIVER\_OBJECTDriverObject,  
INPUNICODE\_STRINGRegistryPath  
)  
{  
ULONG i;

g\_DriverObject = DriverObject;

//  
// Dispatch Routine  
//

for ( i = 0; i &lt;= IRP\_MJ\_MAXIMUM\_FUNCTION; i++ ) {

DriverObject-&gt;MajorFunction\[i] = FilterDispatch;  
}

//  
// Fast I/O Calls  
//

DriverObject-&gt;FastIoDispatch = &FastIOHook;

return AttachAllVolume( DriverObject );  
}

NTSTATUS GetVolumesToAttach(OUT PULONG VolumesToAttach)  
{  
NTSTATUSstatus;  
PROCESS\_DEVICEMAP\_INFORMATIONDeviceMapInfo;  
ULONGMaxVolumeSet;  
ULONGCurVolumeSet;  
ULONGi;

status = ZwQueryInformationProcess(  
(HANDLE) 0xffffffff,  
ProcessDeviceMap,  
&DeviceMapInfo,  
sizeof(DeviceMapInfo),  
NULL  
);

if ( !NT\_SUCCESS(status) )  
return status;

MaxVolumeSet = DeviceMapInfo.Query.DriveMap;  
CurVolumeSet = MaxVolumeSet;

//  
// 排除以下指定的类型  
//

for ( i = 0; i &lt; 26; i++ ) {

if ( MaxVolumeSet & (1 &lt;&lt; i) ) {

switch ( DeviceMapInfo.Query.DriveType\[i] ) {

case DRIVE\_UNKNOWN:  
case DRIVE\_NO\_ROOT\_DIR:  
case DRIVE\_REMOVABLE:  
case DRIVE\_CDROM:

CurVolumeSet &= ~(1 &lt;&lt; i);  
break;  
}  
}  
}

\*VolumesToAttach = CurVolumeSet;  
return STATUS\_SUCCESS;  
}

NTSTATUS  
AttachOneVolume(  
INULONGVolume,  
INPDRIVER\_OBJECTDriverObject  
)  
{  
WCHARRootDirectory\[] = L"[\\\\DosDevices\\\\A:\\\\]()";  
UNICODE\_STRINGustrRootDirectory;  
OBJECT\_ATTRIBUTESObjectAttributes;  
HANDLEFileHandle;  
IO\_STATUS\_BLOCKIoStatus;  
PFILE\_OBJECTFileObject;  
PDEVICE\_OBJECTVolumeDevice;  
PDEVICE\_OBJECTAttachDevice;  
PATTACH\_EXTENSIONAttachExtension;  
NTSTATUSstatus;

RootDirectory\[12] = (CHAR) ('A' + Volume);

RtlInitUnicodeString( &ustrRootDirectory, RootDirectory );

InitializeObjectAttributes(  
&ObjectAttributes,  
&ustrRootDirectory,  
OBJ\_CASE\_INSENSITIVE,  
NULL,  
NULL  
);

status = ZwCreateFile(  
&FileHandle,  
SYNCHRONIZE | FILE\_ANY\_ACCESS,  
&ObjectAttributes,  
&IoStatus,  
NULL,  
0,  
FILE\_SHARE\_READ | FILE\_SHARE\_WRITE,  
FILE\_OPEN,  
FILE\_SYNCHRONOUS\_IO\_NONALERT | FILE\_DIRECTORY\_FILE,  
NULL,  
0  
);

if ( !NT\_SUCCESS(status) ) return status;

status = ObReferenceObjectByHandle(  
FileHandle,  
FILE\_READ\_DATA,  
NULL,  
KernelMode,  
&FileObject,  
NULL  
);

if ( !NT\_SUCCESS(status) ) {

ZwClose( FileHandle );  
return status;  
}

VolumeDevice = IoGetRelatedDeviceObject( FileObject );

if ( !VolumeDevice ) {

ObDereferenceObject( FileObject );  
ZwClose( FileHandle );  
return STATUS\_UNSUCCESSFUL;  
}

status = IoCreateDevice(  
DriverObject,  
sizeof(ATTACH\_EXTENSION),  
NULL,  
VolumeDevice-&gt;DeviceType,  
VolumeDevice-&gt;Characteristics,  
FALSE,  
&AttachDevice  
);

if ( !NT\_SUCCESS(status) ) {

ObDereferenceObject( FileObject );  
ZwClose( FileHandle );  
return status;  
}

AttachDevice-&gt;Flags &= ~DO\_DEVICE\_INITIALIZING;  
AttachDevice-&gt;Flags |= ( VolumeDevice-&gt;Flags & (DO\_BUFFERED\_IO | DO\_DIRECT\_IO) );

AttachExtension = (PATTACH\_EXTENSION) AttachDevice-&gt;DeviceExtension;

AttachExtension-&gt;VolumeLetter = (CHAR) ('A' + Volume);  
AttachExtension-&gt;VolumeDevice = VolumeDevice;

if ( !IoAttachDeviceToDeviceStack(  
AttachDevice,  
VolumeDevice) ) {

IoDeleteDevice( AttachDevice );  
ObDereferenceObject( FileObject );  
ZwClose( FileHandle );  
return STATUS\_UNSUCCESSFUL;  
}

return STATUS\_SUCCESS;  
}

NTSTATUS AttachAllVolume(IN PDRIVER\_OBJECT DriverObject)  
{  
NTSTATUSstatus;  
ULONGVolumesToAttach;  
ULONGi;

status = GetVolumesToAttach( &VolumesToAttach );

if ( !NT\_SUCCESS(status) )  
return status;

for ( i = 0; i &lt; 26; i++ ) {

if ( VolumesToAttach & (1 &lt;&lt; i) ) {

status = AttachOneVolume( i, DriverObject );

if ( !NT\_SUCCESS(status) ) {

return status;  
}  
}  
}

return STATUS\_SUCCESS;  
}

NTSTATUS  
FilterDispatch(  
INPDEVICE\_OBJECTDeviceObject,  
INPIRPIrp  
)  
{  
PATTACH\_EXTENSIONAttachExtension;

AttachExtension = (PATTACH\_EXTENSION) DeviceObject-&gt;DeviceExtension;

IoCopyCurrentIrpStackLocationToNext( Irp );

IoSetCompletionRoutine(  
Irp,  
CompletionRoutine,  
NULL,  
TRUE,  
TRUE,  
FALSE  
);

return IoCallDriver( AttachExtension-&gt;VolumeDevice, Irp );  
}

NTSTATUS  
CompletionRoutine(  
INPDEVICE\_OBJECTDeviceObject,  
INPIRPIrp,  
INPVOIDContext  
)  
{  
PFILE\_BOTH\_DIR\_INFORMATION volatile CurrEntry;  
PFILE\_BOTH\_DIR\_INFORMATION volatile LastEntry;

ULONGBufferLength;  
ULONGIndex;  
PIO\_STACK\_LOCATIONIrpSp;

IrpSp = IoGetCurrentIrpStackLocation( Irp );

if(IrpSp-&gt;MajorFunction == IRP\_MJ\_DIRECTORY\_CONTROL  
&&IrpSp-&gt;MinorFunction == IRP\_MN\_QUERY\_DIRECTORY  
&&KeGetCurrentIrql() == PASSIVE\_LEVEL  
&&IrpSp-&gt;Parameters.QueryDirectory.FileInformationClass == FileBothDirectoryInformation  
) {

Index=-1;  
LastEntry=NULL;  
CurrEntry=(PFILE\_BOTH\_DIR\_INFORMATION) Irp-&gt;UserBuffer;  
BufferLength=Irp-&gt;IoStatus.Information;

if ( BufferLength &gt; 0 ) {

do {

if ( LastEntry != NULL ) {

CurrEntry = (PFILE\_BOTH\_DIR\_INFORMATION) \\  
((PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset);  
}

Index++;

if ( HideOrNot( CurrEntry-&gt;FileName, CurrEntry-&gt;FileNameLength ) ) {

HideHandler( Index, CurrEntry, LastEntry, Irp );

break;  
}

LastEntry = CurrEntry;

} while ( CurrEntry-&gt;NextEntryOffset != 0 );

}  
}

if ( Irp-&gt;PendingReturned ) {

IoMarkIrpPending( Irp );  
}

return Irp-&gt;IoStatus.Status;  
}

BOOLEAN  
HideOrNot(  
INPWCHARFileName,  
INULONGFileNameLength  
)  
{  
LONGret;  
UNICODE\_STRINGustr1;  
UNICODE\_STRINGustr2;

RtlInitUnicodeString( &ustr1, FileName );  
ustr1.Length = (USHORT) FileNameLength;

RtlInitUnicodeString( &ustr2, L"dream\_8.txt" );

ret = RtlCompareUnicodeString(  
&ustr1,  
&ustr2,  
TRUE  
);

if ( ret == 0 )return TRUE;

elsereturn FALSE;  
}

VOID  
HideHandler(  
INULONGIndex,  
INPFILE\_BOTH\_DIR\_INFORMATIONCurrEntry,  
INPFILE\_BOTH\_DIR\_INFORMATIONLastEntry,  
INPIRPIrp  
)  
{  
PVOID temp;

if ( Index == 0 && CurrEntry-&gt;NextEntryOffset == 0 ) {

RtlZeroMemory( CurrEntry, Irp-&gt;IoStatus.Information );  
Irp-&gt;IoStatus.Information = 0;  
Irp-&gt;UserBuffer = NULL;

} else if ( Index == 0 && CurrEntry-&gt;NextEntryOffset != 0 ) {

temp = ExAllocatePool(  
NonPagedPool,  
Irp-&gt;IoStatus.Information - CurrEntry-&gt;NextEntryOffset  
);

if ( temp ) {

RtlCopyMemory(  
temp,  
(PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset,  
Irp-&gt;IoStatus.Information - CurrEntry-&gt;NextEntryOffset  
);

RtlZeroMemory(  
CurrEntry,  
Irp-&gt;IoStatus.Information  
);

RtlCopyMemory(  
CurrEntry,  
temp,  
Irp-&gt;IoStatus.Information - CurrEntry-&gt;NextEntryOffset  
);

Irp-&gt;IoStatus.Information -= CurrEntry-&gt;NextEntryOffset;

ExFreePool( temp );  
}

} else if ( Index &gt; 0 && CurrEntry-&gt;NextEntryOffset != 0 ) {

temp = ExAllocatePool(  
NonPagedPool,  
((PCHAR) Irp-&gt;UserBuffer + Irp-&gt;IoStatus.Information) - \\  
((PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset)  
);

if ( temp ) {

RtlCopyMemory(  
temp,  
(PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset,  
((PCHAR) Irp-&gt;UserBuffer + Irp-&gt;IoStatus.Information) - \\  
((PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset)  
);

RtlZeroMemory(  
CurrEntry,  
((PCHAR) Irp-&gt;UserBuffer + Irp-&gt;IoStatus.Information) - \\  
(PCHAR) CurrEntry  
);

RtlCopyMemory(  
CurrEntry,  
temp,  
((PCHAR) Irp-&gt;UserBuffer + Irp-&gt;IoStatus.Information) - \\  
((PCHAR) CurrEntry + CurrEntry-&gt;NextEntryOffset)  
);

Irp-&gt;IoStatus.Information -= CurrEntry-&gt;NextEntryOffset;

ExFreePool( temp );  
}

} else if ( Index &gt; 0 && CurrEntry-&gt;NextEntryOffset == 0 ) {

RtlZeroMemory(  
CurrEntry,  
((PCHAR) Irp-&gt;UserBuffer + Irp-&gt;IoStatus.Information) - \\  
(PCHAR) CurrEntry  
);

LastEntry-&gt;NextEntryOffset = 0;

Irp-&gt;IoStatus.Information = (PCHAR) CurrEntry - (PCHAR) Irp-&gt;UserBuffer;  
}  
}

//----------------------------------------------------------------------  
// F A S T I O R O U T I N E S  
//----------------------------------------------------------------------

BOOLEAN  
FilemonFastIoCheckifPossible(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
IN BOOLEAN CheckForReadOperation,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoRead(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
IN PVOID Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoQueryBasicInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT PFILE\_BASIC\_INFORMATION Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoQueryStandardInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT PFILE\_STANDARD\_INFORMATION Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoLock(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
BOOLEAN FailImmediately,  
BOOLEAN ExclusiveLock,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoUnlockSingle(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoUnlockAll(  
IN PFILE\_OBJECT FileObject,  
PEPROCESS ProcessId,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoUnlockAllByKey(  
IN PFILE\_OBJECT FileObject,  
PEPROCESS ProcessId,  
ULONG Key,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoQueryNetworkOpenInfo(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
OUT struct \_FILE\_NETWORK\_OPEN\_INFORMATION \*Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

NTSTATUS  
FilemonFastIoAcquireForModWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER EndingOffset,  
OUT struct \_ERESOURCE \*\*ResourceToRelease,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoMdlRead(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoMdlReadComplete(  
IN PFILE\_OBJECT FileObject,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoPrepareMdlWrite(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoMdlWriteComplete(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoReadCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
OUT struct \_COMPRESSED\_DATA\_INFO \*CompressedDataInfo,  
IN ULONG CompressedDataInfoLength,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoWriteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PMDL \*MdlChain,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
OUT struct \_COMPRESSED\_DATA\_INFO \*CompressedDataInfo,  
IN ULONG CompressedDataInfoLength,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoMdlReadCompleteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoMdlWriteCompleteCompressed(  
IN PFILE\_OBJECT FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PMDL MdlChain,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

BOOLEAN  
FilemonFastIoQueryOpen(  
IN PIRP Irp,  
OUT PFILE\_NETWORK\_OPEN\_INFORMATION NetworkInformation,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

NTSTATUS  
FilemonFastIoReleaseForModWrite(  
IN PFILE\_OBJECT FileObject,  
IN struct \_ERESOURCE \*ResourceToRelease,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{

return STATUS\_NOT\_IMPLEMENTED;  
}

NTSTATUS  
FilemonFastIoAcquireForCcFlush(  
IN PFILE\_OBJECT FileObject,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return STATUS\_NOT\_IMPLEMENTED;  
}

NTSTATUS  
FilemonFastIoReleaseForCcFlush(  
IN PFILE\_OBJECT FileObject,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return STATUS\_NOT\_IMPLEMENTED;  
}

BOOLEAN  
FilemonFastIoDeviceControl(  
IN PFILE\_OBJECT FileObject,  
IN BOOLEAN Wait,  
IN PVOID InputBuffer,  
IN ULONG InputBufferLength,  
OUT PVOID OutputBuffer,  
IN ULONG OutputBufferLength,  
IN ULONG IoControlCode,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN PDEVICE\_OBJECT DeviceObject  
)  
{  
return FALSE;  
}

VOID  
FilemonFastIoAcquireFile(  
PFILE\_OBJECT FileObject  
)  
{

}

VOID  
FilemonFastIoReleaseFile(  
PFILE\_OBJECT FileObject  
)  
{

}

VOID  
FilemonFastIoDetachDevice(  
PDEVICE\_OBJECT SourceDevice,  
PDEVICE\_OBJECT TargetDevice  
)  
{

}

调用时创建一个结构体，就可以隐藏自己的文件