/*++
Copyright (c) 1991  Microsoft Corporation

Module Name:
    vdm.c

Abstract:
    This module supplies the entry point to the system for manipulating vdms.

Author:
    Dave Hastings (daveh) 6-Apr-1992
--*/

#include <ntos.h>
#include <vdmntos.h>
#include <ntvdmp.h>
#include <zwapi.h>
#include <fsrtl.h>

typedef struct _QueryDirPoolData {
    KEVENT         kevent;
    UNICODE_STRING FileName;
    WCHAR          FileNameBuf[1];
} QDIR_POOLDATA, *PQDIR_POOLDATA;

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VdmQueryDirectoryFile)
#endif


#if !defined(i386)

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NtVdmControl)
#endif


NTSTATUS NtVdmControl(IN VDMSERVICECLASS Service, IN OUT PVOID ServiceData)
/*++
Routine Description:
    This routine is the entry point for controlling Vdms.
    On risc it returns STATUS_NOT_IMPLEMENTED.
    On 386 the entry point is in i386\vdmentry.c
Arguments:
    Service -- Specifies what service is to be performed
    ServiceData -- Supplies a pointer to service specific data
--*/
{
    PAGED_CODE();

    if (Service == VdmQueryDir) {
        return VdmQueryDirectoryFile(ServiceData);
        }

    return STATUS_NOT_IMPLEMENTED;
}

#endif


extern POBJECT_TYPE IoFileObjectType;

NTSTATUS VdmQueryDirectoryFile(PVDMQUERYDIRINFO pVdmQueryDir)
/*++
    This VDM specific service allows vdm to restart searches at a specified location in the dir search by using the FileIndex, FileName parameters passed back from previous query calls.
    See NtQueryDirectoryFile for additional documentation.
Arguments: PVDMQUERYDIRINFO pVdmQueryDir
    FileHandle - Supplies a handle to the directory file for which information should be returned.
    FileInformation - Supplies a buffer to receive the requested information returned about the contents of the directory.
    Length - Supplies the length, in bytes, of the FileInformation buffer.
    FileName - Supplies a file name within the specified directory.
    FileIndex - Supplies a file index within the specified directory.

    The FileInformationClass is assumed to be FILE_BOTH_DIR_INFORMATION
    The Caller's mode is assumed to be UserMode Synchronous IO is used
--*/
{
    KIRQL    irql;
    NTSTATUS status;
    PKEVENT  Event;
    HANDLE FileHandle;
    IO_STATUS_BLOCK IoStatusBlock;
    PVOID FileInformation;
    ULONG Length;
    UNICODE_STRING FileName;
    PUNICODE_STRING pFileNameSrc;
    ULONG FileIndex;
    PQDIR_POOLDATA QDirPoolData = NULL;
    FILE_FS_DEVICE_INFORMATION DeviceInfo;
    PMDL mdl;
    PIRP irp;
    PIO_STACK_LOCATION irpSp;
    PCHAR SystemBuffer;
    PFILE_OBJECT fileObject;
    PDEVICE_OBJECT DeviceObject;

    PAGED_CODE();

    // We assume that the caller is usermode, so verify all parameters accordingly
    try {
        // Copy out the callers service data into local variables
        ProbeForRead( pVdmQueryDir, sizeof(VDMQUERYDIRINFO), sizeof(ULONG));

        FileHandle      = pVdmQueryDir->FileHandle;
        FileInformation = pVdmQueryDir->FileInformation;
        Length          = pVdmQueryDir->Length;
        FileIndex       = pVdmQueryDir->FileIndex;
        pFileNameSrc    = pVdmQueryDir->FileName;

        // Ensure that we have a valid file name string

        // check for pVdmQueryDir->Filename validity first
        if (NULL == pFileNameSrc) {
           return(STATUS_INVALID_PARAMETER);
        }

        FileName = ProbeAndReadUnicodeString(pFileNameSrc);
        if (!FileName.Length || FileName.Length > MAXIMUM_FILENAME_LENGTH<<1) {
            return(STATUS_INVALID_PARAMETER);
        }

        ProbeForRead(FileName.Buffer, FileName.Length, sizeof( UCHAR ));

        // The FileInformation buffer must be writeable by the caller.
        ProbeForWrite( FileInformation, Length, sizeof( ULONG ) );

        // Ensure that the caller's supplied buffer is at least large enough to contain the fixed part of the structure required for this query.
        if (Length < sizeof(FILE_BOTH_DIR_INFORMATION)) {
            return STATUS_INFO_LENGTH_MISMATCH;
        }

        // Allocate from nonpaged pool a buffer large enough to contain the file name, and the kevent used to wait for io.
        QDirPoolData = (PQDIR_POOLDATA) ExAllocatePoolWithQuotaTag(NonPagedPool, sizeof(QDIR_POOLDATA) + FileName.Length, ' MDV');

        // Capture the file name string into the nonpaged pool block.
        QDirPoolData->FileName.Length = FileName.Length;
        QDirPoolData->FileName.MaximumLength = FileName.Length;
        QDirPoolData->FileName.Buffer = QDirPoolData->FileNameBuf;
        RtlCopyMemory( QDirPoolData->FileNameBuf, FileName.Buffer, FileName.Length );
    } except(EXCEPTION_EXECUTE_HANDLER) {
        if (QDirPoolData) {
            ExFreePool(QDirPoolData);
        }

        return GetExceptionCode();
    }

    // There were no blatant errors so far, so reference the file object so the target device object can be found.
    // Note that if the handle does not refer to a file object, or if the caller does not have the required access to the file, then it will fail.
    status = ObReferenceObjectByHandle( FileHandle, FILE_LIST_DIRECTORY, IoFileObjectType, UserMode, (PVOID *) &fileObject, (POBJECT_HANDLE_INFORMATION) NULL );
    if (!NT_SUCCESS( status )) {
        if (QDirPoolData) {
            ExFreePool(QDirPoolData);
        }
        return status;
    }

    //  We don't handle FO_SYNCHRONOUS_IO, because it requires io internal finctionality.
    //  Ntvdm can get away with this because it serializes access to the dir handle.

    // Initialize the kernel event that will signal I/O completion
    Event = &QDirPoolData->kevent;
    KeInitializeEvent(Event, SynchronizationEvent, FALSE);

    // Set the file object to the Not-Signaled state.
    KeClearEvent( &fileObject->Event );

    // Get the address of the target device object.
    DeviceObject = IoGetRelatedDeviceObject( fileObject );

    // Allocate and initialize the I/O Request Packet (IRP) for this operation.
    // The allocation is performed with an exception handler in case the caller does not have enough quota to allocate the packet.
    irp = IoAllocateIrp( DeviceObject->StackSize, TRUE );
    if (!irp) {
        // An IRP could not be allocated.  Cleanup and return an appropriate error status code.
        ObDereferenceObject( fileObject );
        if (QDirPoolData) {
            ExFreePool(QDirPoolData);
        }

        return STATUS_INSUFFICIENT_RESOURCES;
    }

    // Fill in the service independent parameters in the IRP.
    irp->Flags = (ULONG)IRP_SYNCHRONOUS_API;
    irp->RequestorMode = UserMode;
    irp->UserIosb = &IoStatusBlock;
    irp->UserEvent = Event;
    irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
    irp->AssociatedIrp.SystemBuffer = (PVOID) NULL;
    SystemBuffer = NULL;

    irp->Tail.Overlay.Thread = PsGetCurrentThread();
    irp->Tail.Overlay.OriginalFileObject = fileObject;
    irp->Tail.Overlay.AuxiliaryBuffer = NULL;
    irp->MdlAddress = NULL;

    // Get a pointer to the stack location for the first driver.
    // This will be used to pass the function codes and parameters.
    irpSp = IoGetNextIrpStackLocation( irp );
    irpSp->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;
    irpSp->MinorFunction = IRP_MN_QUERY_DIRECTORY;
    irpSp->FileObject = fileObject;

    // Copy the caller's parameters to the service-specific portion of the IRP.
    irpSp->Parameters.QueryDirectory.Length = Length;
    irpSp->Parameters.QueryDirectory.FileInformationClass = FileBothDirectoryInformation;
    irpSp->Parameters.QueryDirectory.FileIndex = FileIndex;

    if (QDirPoolData->FileName.Length) {
        irpSp->Parameters.QueryDirectory.FileName = (PSTRING)&QDirPoolData->FileName;
    } else {
        irpSp->Parameters.QueryDirectory.FileName = NULL;
    }

    irpSp->Flags = SL_INDEX_SPECIFIED;

    // Now determine whether this driver expects to have data buffered to it or whether it performs direct I/O.
    // This is based on the DO_BUFFERED_IO flag in the device object.
    // If the flag is set, then a system buffer is allocated and the driver's data will be copied into it.
    // Otherwise, a Memory Descriptor List (MDL) is allocated and the caller's buffer is locked down using it.
    if (DeviceObject->Flags & DO_BUFFERED_IO) {
        // The file system wants buffered I/O.  Pass the address of the "system buffer" in the IRP.
        // Note that we don't want the buffer deallocated, nor do we want the I/O system to copy to a user buffer, so we don't set the corresponding flags in irp->Flags.
        try {
            // Allocate the intermediary system buffer from nonpaged pool and charge quota for it.
            SystemBuffer = ExAllocatePoolWithQuotaTag( NonPagedPool, Length, ' MDV' );
            irp->AssociatedIrp.SystemBuffer = SystemBuffer;
        } except(EXCEPTION_EXECUTE_HANDLER) {
            IoFreeIrp(irp);
            ObDereferenceObject( fileObject );
            if (QDirPoolData) {
                ExFreePool(QDirPoolData);
            }
            return GetExceptionCode();
        }
    } else if (DeviceObject->Flags & DO_DIRECT_IO) {
        // This is a direct I/O operation.
        // Allocate an MDL and invoke the memory management routine to lock the buffer into memory.
        // This is done using an exception handler that will perform cleanup if the operation fails.
        mdl = (PMDL) NULL;
        try {
            // Allocate an MDL, charging quota for it, and hang it off of the IRP.
            // Probe and lock the pages associated with the caller's buffer for write access and fill in the MDL with the PFNs of those pages.
            mdl = IoAllocateMdl( FileInformation, Length, FALSE, TRUE, irp );
            if (mdl == NULL) {
                ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
            }
            MmProbeAndLockPages( mdl, UserMode, IoWriteAccess );
        } except(EXCEPTION_EXECUTE_HANDLER) {
            if (irp->MdlAddress != NULL) {
                 IoFreeMdl( irp->MdlAddress );
            }
            IoFreeIrp(irp);
            ObDereferenceObject( fileObject );
            if (QDirPoolData) {
                ExFreePool(QDirPoolData);
            }
            return GetExceptionCode();
        }
    } else {
        // Pass the address of the user's buffer so the driver has access to it.
        // It is now the driver's responsibility to do everything.
        irp->UserBuffer = FileInformation;
    }

    // Insert the packet at the head of the IRP list for the thread.
    KeRaiseIrql( APC_LEVEL, &irql );
    InsertHeadList( &irp->Tail.Overlay.Thread->IrpList, &irp->ThreadListEntry );
    KeLowerIrql( irql );

    // invoke the driver and wait for it to complete
    status = IoCallDriver(DeviceObject, irp);
    if (status == STATUS_PENDING) {
        status = KeWaitForSingleObject(Event, UserRequest, UserMode, FALSE, NULL );
    }

    if (NT_SUCCESS(status)) {
        status = IoStatusBlock.Status;
        if (NT_SUCCESS(status) || status == STATUS_BUFFER_OVERFLOW) {
            if (SystemBuffer) {
                try {
                    RtlCopyMemory( FileInformation, SystemBuffer, IoStatusBlock.Information);
                } except(EXCEPTION_EXECUTE_HANDLER) {
                    status = GetExceptionCode();
                }
            }
        }
    }

    // Cleanup any memory allocated
    if (QDirPoolData) {
        ExFreePool(QDirPoolData);
    }

    if (SystemBuffer) {
        ExFreePool(SystemBuffer);
    }

    return status;
}