eddrv.c

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

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

    IoStatus->Status      = STATUS_NOT_IMPLEMENTED;
    IoStatus->Information = 0;

    if( FASTIOPRESENT( hookExt, PrepareMdlWrite )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


 
BOOLEAN EDDrvFastIoMdlWriteComplete( IN PFILE_OBJECT FileObject,
                                       IN PLARGE_INTEGER FileOffset, 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 EDDrvFastIoMdlWriteComplete\n"));

    if( FASTIOPRESENT( hookExt, MdlWriteComplete )) { 

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


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

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

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

    if( FASTIOPRESENT( hookExt, FastIoReadCompressed )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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



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

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

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

    if( FASTIOPRESENT( hookExt, FastIoWriteCompressed )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


 
BOOLEAN EDDrvFastIoMdlReadCompleteCompressed( 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 EDDrvFastIoMdlReadCompleteCompressed\n"));

    if( FASTIOPRESENT( hookExt, MdlReadCompleteCompressed )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


 
BOOLEAN EDDrvFastIoMdlWriteCompleteCompressed( IN PFILE_OBJECT FileObject,
                                                 IN PLARGE_INTEGER FileOffset, 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 EDDrvFastIoMdlWriteCompleteCompressed\n"));

    if( FASTIOPRESENT( hookExt, MdlWriteCompleteCompressed )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


  
BOOLEAN EDDrvFastIoQueryOpen( IN PIRP Irp,
                                OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
                                IN PDEVICE_OBJECT DeviceObject )
{
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    PFILE_OBJECT        fileobject;
    CHAR                *fullPathName, name[PROCNAMELEN];
    PIO_STACK_LOCATION  currentIrpStack;
    PIO_STACK_LOCATION  nextIrpStack;
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if( !DeviceObject ) return FALSE;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, FastIoQueryOpen )) {

        currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
        nextIrpStack    = IoGetNextIrpStackLocation(Irp);
        fileobject      = currentIrpStack->FileObject;

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( TRUE, fileobject, hookExt, fullPathName );
        }       

       
        *nextIrpStack = *currentIrpStack;
        nextIrpStack->DeviceObject = hookExt->FileSystem;
        IoSetNextIrpStackLocation( Irp );
        
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->FastIoQueryOpen( 
            Irp, NetworkInformation, hookExt->FileSystem );

        
        Irp->CurrentLocation++;
        Irp->Tail.Overlay.CurrentStackLocation++;

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


  
NTSTATUS EDDrvFastIoReleaseForModWrite( IN PFILE_OBJECT FileObject,
                                          IN 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 STATUS_NOT_IMPLEMENTED;

    hookExt = DeviceObject->DeviceExtension;

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

    if( FASTIOPRESENT( hookExt, ReleaseForModWrite )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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


   
NTSTATUS EDDrvFastIoAcquireForCcFlush( IN PFILE_OBJECT FileObject,
                                         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 STATUS_NOT_IMPLEMENTED;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, AcquireForCcFlush )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

            EDDrvGetFullPath( FALSE, FileObject, hookExt, fullPathName );
        }       
       
        retval = hookExt->FileSystem->DriverObject->FastIoDispatch->AcquireForCcFlush( 
            FileObject, hookExt->FileSystem );
        
        if ( fullPathName) ExFreePool( fullPathName );
    }
    return retval;
}


   
NTSTATUS EDDrvFastIoReleaseForCcFlush( IN PFILE_OBJECT FileObject,
                                         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 STATUS_NOT_IMPLEMENTED;

    hookExt = DeviceObject->DeviceExtension;

    if( FASTIOPRESENT( hookExt, ReleaseForCcFlush )) {

        fullPathName = ExAllocatePool( NonPagedPool, MAXPATHLEN );

        if( fullPathName ) {

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

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



BOOLEAN  EDDrvFastIoDeviceControl( 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 ) {
    BOOLEAN             retval = FALSE;
    PHOOK_EXTENSION     hookExt;
    PSTORE_BUF          old;
    CHAR                fullPathName[MAXPATHLEN], name[PROCNAMELEN], errorBuf[ERRORLEN];
    KIRQL               oldirql;
    LARGE_INTEGER       timeStampStart, timeStampComplete, timeResult;

    if ( DeviceObject == ControlDevice )  {

       
        IoStatus->Status      = STATUS_SUCCESS; 
        IoStatus->Information = 0;      

        switch ( IoControlCode ) {

		
        case EDDrv_setdrives:

            
            if ( InputBufferLength >= sizeof(ULONG) &&
                 OutputBufferLength >= sizeof(ULONG)) {

                *(ULONG *)OutputBuffer = HookDriveSet( *(ULONG *)InputBuffer, DeviceObject->DriverObject );
                IoStatus->Information = sizeof(ULONG);

            } else {

                IoStatus->Status = STATUS_BUFFER_TOO_SMALL;
            }
            break;

        case EDDrv_stopfilter:
            
            FilterOn = FALSE;
            break;

        case EDDrv_startfilter:
          
            FilterOn = TRUE;
            break;


	case EDDrv_uservalid:
	    UserValid=TRUE;	
            break;

	case EDDrv_userinvalid:
	    UserValid=FALSE;
	    break;		
		
    case EDDrv_setfilter:
         break;

    case EDDrv_unloadquery:

            KeAcquireSpinLock( &CountMutex, &oldirql );
            IoStatus->Information = OutstandingIRPCount;

            if( !OutstandingIRPCount ) {

               
                UnloadInProgress = TRUE;