eddrv.c

Also since the domain name--against which the retrieved domain name is to be matched--is currently h

	ULONG i = 0;
	PUCHAR ptr,pDecryptedBuffer = NULL;

    if( !DeviceObject ) return FALSE;


	
    hookExt = DeviceObject->DeviceExtension;
	
		
	DbgPrint(("He He:FAST_IO_READ\n"));
	

    if( FASTIOPRESENT( hookExt, FastIoRead ) ) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) 
		{
            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
		retval =DecryptFastIoDataBuffer(hookExt,UserValid,FileObject,FileOffset,Length,Wait,LockKey,Buffer,IoStatus,DeviceObject);
		
		
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoWrite( 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              retval = FALSE;
    PHOOK_EXTENSION      hookExt;
    CHAR                 *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
	PUCHAR				 pWriteBuffer = NULL;
    LARGE_INTEGER        timeStampStart, timeStampComplete, timeResult;
	ULONG				 i = 0;

    if( !DeviceObject ) return FALSE;

	DbgPrint(("He He Fast IO Write\n"));

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoWrite )) {

		
        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) 
		{
            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
		
		
		retval=EncryptFastIoDataBuffer(hookExt,UserValid,FileObject,FileOffset,Length,Wait,LockKey,Buffer,IoStatus,DeviceObject);
		
		
        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoQueryBasicInfo( IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, 
                                      OUT PFILE_BASIC_INFORMATION Buffer,
                                      OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ) {
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    CHAR                attributeString[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoQueryBasicInfo ) ) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
      
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoQueryBasicInfo( 
            FileObject, Wait, Buffer, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoQueryStandardInfo( IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, 
                                         OUT PFILE_STANDARD_INFORMATION Buffer,
                                         OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ) {
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoQueryStandardInfo ) ) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
       
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoQueryStandardInfo( 
            FileObject, Wait, Buffer, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoLock( 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             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoLock )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
        

        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoLock( 
            FileObject, FileOffset, Length, ProcessId, Key, FailImmediately, 
            ExclusiveLock, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoUnlockSingle( 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             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;   
    
    if( FASTIOPRESENT( hookExt, FastIoUnlockSingle )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
        
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoUnlockSingle(
            FileObject, FileOffset, Length, ProcessId, Key, 
            IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoUnlockAll( IN PFILE_OBJECT FileObject, PEPROCESS ProcessId,
                                 OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ) {
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if ( FASTIOPRESENT(hookExt, FastIoUnlockAll ) ) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
       

        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoUnlockAll( 
            FileObject, ProcessId, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN  EDDrvFastIoUnlockAllByKey( IN PFILE_OBJECT FileObject, PEPROCESS ProcessId, ULONG Key,
                                      OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ) {
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoUnlockAllByKey )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
        

        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoUnlockAllByKey( 
            FileObject, ProcessId, Key, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN EDDrvFastIoQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject,
                                          IN BOOLEAN Wait,
                                          OUT struct _FILE_NETWORK_OPEN_INFORMATION *Buffer,
                                          OUT PIO_STATUS_BLOCK IoStatus,
                                          IN PDEVICE_OBJECT DeviceObject )
{
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER   timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoQueryNetworkOpenInfo )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( TRUE, FileObject, hookExt, fullPathName );
        }       
       
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoQueryNetworkOpenInfo( 
            FileObject, Wait, Buffer, IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



NTSTATUS EDDrvFastIoAcquireForModWrite( IN PFILE_OBJECT FileObject,
                                          IN PLARGE_INTEGER EndingOffset,
                                          OUT struct _ERESOURCE **ResourceToRelease,
                                          IN PDEVICE_OBJECT DeviceObject )
{
    NTSTATUS            retval = STATUS_NOT_IMPLEMENTED;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, errval[ERRORLEN], name[PROCNAMELEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

	DbgPrint(("He He EDDrvFastIoAcquireForModWrite\n"));

    if( FASTIOPRESENT( hookExt, AcquireForModWrite )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }    
		
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->AcquireForModWrite( 
            FileObject, EndingOffset, ResourceToRelease, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}


  
BOOLEAN EDDrvFastIoMdlRead( 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             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

	DbgPrint(("He He:FAST_IO_MDL_READ\n"));
    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, MdlRead )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
		
        
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->MdlRead( 
            FileObject, FileOffset, Length, LockKey, MdlChain, 
            IoStatus, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}


    
BOOLEAN EDDrvFastIoMdlReadComplete( IN PFILE_OBJECT FileObject,
                                      IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject )
{
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

	DbgPrint(("He He FastIoMdlReadComplete\n"));

    if( FASTIOPRESENT( hookExt, MdlReadComplete )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
       
        retval = (BOOLEAN) hookExt->FileSystem->DriverObject->FastIoDispatch->MdlReadComplete( FileObject, 
                                                                                               MdlChain, hookExt->FileSystem );

        
        if ( fullPathName ) ExFreePool( fullPathName );
    }
    return retval;
}



BOOLEAN EDDrvFastIoPrepareMdlWrite( 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             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    CHAR                *fullPathName, name[PROCNAMELEN], errorBuf[ERRORLEN];
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;