passthru.c

ndis中间层驱动程序,实现中间层驱动程序

        DispatchTable[IRP_MJ_DEVICE_CONTROL] = MydrvDispatchIoctl;
        

        NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
        NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);

        //
        // Create a device object and register our dispatch handlers
        //
        
        Status = NdisMRegisterDevice(
                    NdisWrapperHandle, 
                    &DeviceName,
                    &DeviceLinkUnicodeString,
                    &DispatchTable[0],
                    &MyDeviceObject,
                    &NdisDeviceHandle
                    );

        NdisAcquireSpinLock(&GlobalLock);

        ControlDeviceState = PS_DEVICE_STATE_READY;
    }

    NdisReleaseSpinLock(&GlobalLock);

    DBGPRINT(("<==PtRegisterDevice: %x\n", Status));

	Monitor_flag	= 0;	// 设置监视标志
	
	// 分配与应用程序共享的内存
	SystemVirtualAddress = ExAllocatePool(NonPagedPool, 1024);
	Mdl = IoAllocateMdl(SystemVirtualAddress, 1024, FALSE, FALSE, NULL);
	MmBuildMdlForNonPagedPool(Mdl);
	//

    return (Status);
}


/*NTSTATUS
PtDispatch(
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    )
/*++
Routine Description:

    Process IRPs sent to this device.

Arguments:

    DeviceObject - pointer to a device object
    Irp      - pointer to an I/O Request Packet

Return Value:

    NTSTATUS - STATUS_SUCCESS always - change this when adding
    real code to handle ioctls.

--/
{
    PIO_STACK_LOCATION  irpStack;
    NTSTATUS            status = STATUS_SUCCESS;

    UNREFERENCED_PARAMETER(DeviceObject);
    
    DBGPRINT(("==>Pt Dispatch\n"));
    irpStack = IoGetCurrentIrpStackLocation(Irp);
      

    switch (irpStack->MajorFunction)
    {
        case IRP_MJ_CREATE:
            break;
            
        case IRP_MJ_CLEANUP:
            break;
            
        case IRP_MJ_CLOSE:
            break;        
            
        case IRP_MJ_DEVICE_CONTROL:
            //
            // Add code here to handle ioctl commands sent to passthru.
            //
            break;        
        default:
            break;
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    DBGPRINT(("<== Pt Dispatch\n"));

    return status;

} 
*/

NDIS_STATUS
PtDeregisterDevice(
    VOID
    )
/*++

Routine Description:

    Deregister the ioctl interface. This is called whenever a miniport
    instance is halted. When the last miniport instance is halted, we
    request NDIS to delete the device object

Arguments:

    NdisDeviceHandle - Handle returned by NdisMRegisterDevice

Return Value:

    NDIS_STATUS_SUCCESS if everything worked ok

--*/
{
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;

    DBGPRINT(("==>PassthruDeregisterDevice\n"));

    NdisAcquireSpinLock(&GlobalLock);

    ASSERT(MiniportCount > 0);

    --MiniportCount;
    
    if (0 == MiniportCount)
    {
        //
        // All miniport instances have been halted. Deregister
        // the control device.
        //

        ASSERT(ControlDeviceState == PS_DEVICE_STATE_READY);

        //
        // Block PtRegisterDevice() while we release the control
        // device lock and deregister the device.
        // 
        ControlDeviceState = PS_DEVICE_STATE_DELETING;

        NdisReleaseSpinLock(&GlobalLock);

        if (NdisDeviceHandle != NULL)
        {
            Status = NdisMDeregisterDevice(NdisDeviceHandle);
            NdisDeviceHandle = NULL;
        }

        NdisAcquireSpinLock(&GlobalLock);
        ControlDeviceState = PS_DEVICE_STATE_READY;
    }

    NdisReleaseSpinLock(&GlobalLock);

    DBGPRINT(("<== PassthruDeregisterDevice: %x\n", Status));
    return Status;
    
}

VOID
PtUnload(
    IN PDRIVER_OBJECT        DriverObject
    )
//
// PassThru driver unload function
//
{
    UNREFERENCED_PARAMETER(DriverObject);
    
    DBGPRINT(("PtUnload: entered\n"));
    PtUnloadProtocol();
    NdisIMDeregisterLayeredMiniport(DriverHandle);
    NdisFreeSpinLock(&GlobalLock);
    DBGPRINT(("PtUnload: done!\n"));
}

static NTSTATUS MydrvDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) 
{ 
	NTSTATUS status; 
	PIO_STACK_LOCATION irpSp; 

//	UNREFERENCED_PARAMETER(DeviceObject); 
	irpSp = IoGetCurrentIrpStackLocation(Irp); 

	switch (irpSp->MajorFunction) 
	{ 
		case IRP_MJ_CREATE: 
			Irp->IoStatus.Status = STATUS_SUCCESS; 
			Irp->IoStatus.Information = 0L; 
			break; 

		case IRP_MJ_CLEANUP:
			Irp->IoStatus.Status = STATUS_SUCCESS; 
			Irp->IoStatus.Information = 0L; 
			break;

		case IRP_MJ_CLOSE: 
			Irp->IoStatus.Status = STATUS_SUCCESS; 
			Irp->IoStatus.Information = 0L; 
			MmUnmapLockedPages(UserVirtualAddress, Mdl);
			break; 
	} 

	IoCompleteRequest(Irp, IO_NO_INCREMENT); 
	return STATUS_SUCCESS; 

} 

static NTSTATUS MydrvDispatchIoctl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) 
{ 
	PIO_STACK_LOCATION IrpStack; 
	NTSTATUS status; 
	ULONG ControlCode; 
//	ULONG InputLength, OutputLength; 
	OBJECT_HANDLE_INFORMATION	objHandleInfo;
	HANDLE	hEvent = NULL;

	IrpStack = IoGetCurrentIrpStackLocation(Irp); 

	// 得到DeviceIoControl传来的控制码
	ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode; 

	switch (ControlCode) 
	{ 
		case IO_GET_SHAREMEMORY_ADDR:
			// 将分配的内存映射到用户进程地址空间，并返回地址。
			try
			{
				UserVirtualAddress = MmMapLockedPages(Mdl, UserMode); 
				*((PVOID *)(Irp->AssociatedIrp.SystemBuffer)) = UserVirtualAddress;
				Irp->IoStatus.Status = STATUS_SUCCESS; 
				Irp->IoStatus.Information = sizeof(PVOID);
			}
			except(EXCEPTION_EXECUTE_HANDLER){}
			break;

		case IO_REFERENCE_EVENT: 
			hEvent = (HANDLE)IrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
			status = ObReferenceObjectByHandle(hEvent,
												GENERIC_ALL,
												NULL,
												KernelMode,
												&gpEventObject,
												&objHandleInfo);
			if(status != STATUS_SUCCESS)
			{
				DbgPrint("ObReferenceObjectByHandle failed! status = %x\n", status);
				break;
			}
			else DbgPrint("Referenct object sussfully!\n");
			Irp->IoStatus.Status = STATUS_SUCCESS;
			Irp->IoStatus.Information = 0L;
			break;

		case IO_STOP_MONITOR_EVENT:
			Monitor_flag = 0;	// 设置监视标志为停止监视

			if(gpEventObject)
			{
				ObDereferenceObject(gpEventObject);
				DbgPrint("ObDereferenceObject sussfully!\n");
			}
			else{}
			Irp->IoStatus.Status = STATUS_SUCCESS;
			Irp->IoStatus.Information = 0L;
			break;

		case IO_CLEAR_EVENT:
			KeClearEvent(gpEventObject);
			DbgPrint("KeClearEvent sussfully!\n");
			Irp->IoStatus.Status = STATUS_SUCCESS;
			Irp->IoStatus.Information = 0L;
			break;

		default:
			break;
	}

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return status; 
}