/****************.h*********************//

#pragma once



#include <Ntifs.h>

#define ArraySize(p)   (sizeof(p)/sizeof(p[0]))

#define MAX_PROCESS_SIZE 1024



#define PAGECODE code_seg("PAGE")

#define INITCODE code_seg("INIT")

#define LOCKCODE code_seg()

#define Print(p)    KdPrint((p));

#define PAGEDATA data_seg("PAGE")

#define INITDATA data_seg("INIT")

#define LOCKDATA data_seg()





typedef struct _DEVICE_EXTENSION{

	PDEVICE_OBJECT pdv;

	UNICODE_STRING devName;

	UNICODE_STRING devSymLikn;

	PUCHAR DeviceBuff;

	ULONG  BuffLength;

	PIRP   pIrp;

    PDEVICE_OBJECT pTragetDevice;

	PVOID VirutalArrd;

}DEVICE_EXTENSION,*PDEVICE_EXTENSION;



#pragma  LOCKCODE

VOID UnInstallDriver(PDRIVER_OBJECT pDriverObject)

{

	PDEVICE_OBJECT pdev = pDriverObject->DeviceObject;

	while(pdev != NULL)

	{

		PDEVICE_EXTENSION pdevExt =(PDEVICE_EXTENSION)pdev->DeviceExtension;

		KdPrint(("SumLink----%S",pdevExt->devSymLikn));

		IoDeleteSymbolicLink(&(pdevExt->devSymLikn));

		pdev = pdevExt->pdv->NextDevice;

		IoDeleteDevice(pdevExt->pdv);

	}

	Print("UninStall Complete\n");

}



#pragma  LOCKCODE

NTSTATUS DeviceRoutine(PDEVICE_OBJECT pDeviceObject,PIRP pIrp)

{

	PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);

	Print("Steup Routine\n");

	pIrp->IoStatus.Information = 0;

	pIrp->IoStatus.Status = STATUS_SUCCESS;



	IoCompleteRequest(pIrp,IO_NO_INCREMENT);

	return STATUS_SUCCESS;

}

typedef struct RW_CONTEXT 

{

    PMDL NewMdl;

	PMDL OldMdl;

	ULONG Length;

	ULONG ReadSize;

	ULONG AlreadlyLength;

	ULONG_PTR VirtualAddress;

	PDEVICE_EXTENSION pDevExt;

	PIRP UserIrp;

	PDEVICE_OBJECT pTarDevice;

    KEVENT Uevent;

}RWCONTEST,*PRWCONTEXT;

#define Ioctl_Read CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)



NTKERNELAPI

	NTSTATUS

	ObReferenceObjectByName(

	__in PUNICODE_STRING ObjectName,

	__in ULONG Attributes,

	__in_opt PACCESS_STATE AccessState,

	__in_opt ACCESS_MASK DesiredAccess,

	__in POBJECT_TYPE ObjectType,

	__in KPROCESSOR_MODE AccessMode,

	__inout_opt PVOID ParseContext,

	__out PVOID *Object

	);

extern POBJECT_TYPE IoDeviceObjectType;

/**********************.c*********************/

#include "..\Include\inc.h"



NTSTATUS CreateDevice(PDRIVER_OBJECT pDriverObject);

NTSTATUS OperatoeDevice(PDEVICE_OBJECT pDrviceObject,PIRP pIrp);

NTSTATUS IoCompleteRoutine(PDEVICE_OBJECT pDeviceObject,PIRP pIrp, PVOID Context);

NTSTATUS CreateIrpRoutine(PDEVICE_OBJECT pDeviceObjec,PIRP pIrp);

NTSTATUS CloseDeviceIrpRoutine(PDEVICE_OBJECT pDevcieObject,PIRP pIrp);



#pragma  INITCODE

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject,PUNICODE_STRING pRegistryPath)

{

	NTSTATUS status = STATUS_SUCCESS;



	int i =0;

	Print("start DriverEntry Device B\n");

	for (i;i<ArraySize(pDriverObject->MajorFunction);i++)

	{

		pDriverObject->MajorFunction[i] = CloseDeviceIrpRoutine;

	}

	pDriverObject->MajorFunction[IRP_MJ_READ] = OperatoeDevice;

	pDriverObject->MajorFunction[IRP_MJ_CREATE] = CloseDeviceIrpRoutine;

	pDriverObject->MajorFunction[IRP_MJ_CLOSE]= CloseDeviceIrpRoutine;

	pDriverObject->DriverUnload = UnInstallDriver;



	status = CreateDevice(pDriverObject);

	if (!NT_SUCCESS(status))

	{

		Print("Create Device Failed\n");

		return status;

	}

	return STATUS_SUCCESS;

}



#pragma  INITCODE

NTSTATUS CreateDevice(PDRIVER_OBJECT pDriverObject)

{

	NTSTATUS status = STATUS_SUCCESS;

	UNICODE_STRING pDevName;

	PDEVICE_OBJECT pdev;

	PDEVICE_EXTENSION pDevExt;

	PDEVICE_OBJECT DEVICEOBJECT;

	PFILE_OBJECT FileObject;

	PDEVICE_OBJECT pTarget;

    UNICODE_STRING TargetDeviceName;



	Print("Starup Driver B \n");

	RtlInitUnicodeString(&pDevName,L"\\Device\\MyDeviceName");

	RtlInitUnicodeString(&TargetDeviceName,L"\\Device\\MoonDeviceA");

	status = IoCreateDevice(pDriverObject,sizeof(DEVICE_EXTENSION),&pDevName,FILE_DEVICE_UNKNOWN,0,TRUE,&pdev);

	if (!NT_SUCCESS(status))

	{

		Print("Create Device B failed\n");

		return status;

	}

	pDevExt = (PDEVICE_EXTENSION)pdev->DeviceExtension;

	pDevExt->devName = pDevName;

	pdev->Flags |=DO_DIRECT_IO;

	pDevExt->pdv = pdev;

	KdPrint(("Create DeviceB Successful\n"));

	status = IoGetDeviceObjectPointer(&TargetDeviceName,FILE_ALL_ACCESS,&FileObject,&DEVICEOBJECT);

	if (!NT_SUCCESS(status))

	{

		KdPrint(("Get TarDevice Point Failed\n"));

		IoDeleteDevice(pdev);

		return status;

	}

	pTarget = IoAttachDeviceToDeviceStack(pdev,DEVICEOBJECT);

	pDevExt->pTragetDevice = pTarget;

	if (!pTarget)

	{

		KdPrint(("Ioattach failed\n"));

		IoDeleteDevice(pdev);

		ObDereferenceObject(FileObject);

		return STATUS_INSUFFICIENT_RESOURCES;

	}



	pdev->Flags |=(pTarget->Flags &(DO_DIRECT_IO | DO_BUFFERED_IO));

	pdev->Flags &=~DO_DEVICE_INITIALIZING;

	pdev->Characteristics = pTarget->Characteristics;

	pdev->DeviceType = pTarget->DeviceType;

	ObDereferenceObject(FileObject);

	return STATUS_SUCCESS;

}

#pragma  PAGECODE

NTSTATUS CreateIrpRoutine(PDEVICE_OBJECT pDeviceObjec,PIRP pIrp)

{

	NTSTATUS status = STATUS_SUCCESS;

	PDEVICE_EXTENSION pdev = (PDEVICE_EXTENSION)pDeviceObjec->DeviceExtension;

	IoSkipCurrentIrpStackLocation(pIrp);

	IoCallDriver(pdev->pTragetDevice,pIrp);

	KdPrint(("CreateIrpRoutine\n"));

	return status;

}



#pragma  PAGECODE

NTSTATUS CloseDeviceIrpRoutine(PDEVICE_OBJECT pDevcieObject,PIRP pIrp)

{   

	PDEVICE_EXTENSION pdevExt;

	ULONG Type;

	PIO_STACK_LOCATION stack;

	

	static char* irpname[] = 

	{

		"IRP_MJ_CREATE",

		"IRP_MJ_CREATE_NAMED_PIPE",

		"IRP_MJ_CLOSE",

		"IRP_MJ_READ",

		"IRP_MJ_WRITE",

		"IRP_MJ_QUERY_INFORMATION",

		"IRP_MJ_SET_INFORMATION",

		"IRP_MJ_QUERY_EA",

		"IRP_MJ_SET_EA",

		"IRP_MJ_FLUSH_BUFFERS",

		"IRP_MJ_QUERY_VOLUME_INFORMATION",

		"IRP_MJ_SET_VOLUME_INFORMATION",

		"IRP_MJ_DIRECTORY_CONTROL",

		"IRP_MJ_FILE_SYSTEM_CONTROL",

		"IRP_MJ_DEVICE_CONTROL",

		"IRP_MJ_INTERNAL_DEVICE_CONTROL",

		"IRP_MJ_SHUTDOWN",

		"IRP_MJ_LOCK_CONTROL",

		"IRP_MJ_CLEANUP",

		"IRP_MJ_CREATE_MAILSLOT",

		"IRP_MJ_QUERY_SECURITY",

		"IRP_MJ_SET_SECURITY",

		"IRP_MJ_POWER",

		"IRP_MJ_SYSTEM_CONTROL",

		"IRP_MJ_DEVICE_CHANGE",

		"IRP_MJ_QUERY_QUOTA",

		"IRP_MJ_SET_QUOTA",

		"IRP_MJ_PNP",

	};

	stack= IoGetCurrentIrpStackLocation(pIrp);

	Type = stack->MajorFunction;

	if(Type >= ArraySize(irpname))

	{

		KdPrint(("Unknown Irp\n"));



	}

	else

	{

		KdPrint(("Irp Type == %s",irpname[Type]));



	}

	pdevExt = (PDEVICE_EXTENSION)pDevcieObject->DeviceExtension;

	IoSkipCurrentIrpStackLocation(pIrp);

	IoCallDriver(pdevExt->pTragetDevice,pIrp);

	KdPrint(("CloseDeviceIrpRoutine\n"));

	return STATUS_SUCCESS;

}



#pragma  LOCKCODE 

NTSTATUS IoCompleteRoutine(PDEVICE_OBJECT pDeviceObject,PIRP pIrp, PVOID Context)

{

	PRWCONTEXT pContext= (PRWCONTEXT)Context;

	PIO_STACK_LOCATION stack;

	ULONG stareLong;

	KdPrint(("IoCompleteRoutine---\n"));

	if (pContext && NT_SUCCESS(pIrp->IoStatus.Status))

	{

	   pContext->AlreadlyLength += pIrp->IoStatus.Information;

	   pContext->Length -= pIrp->IoStatus.Information;

	   if(pContext->Length)

	   {

		   if (pContext->Length > MAX_PROCESS_SIZE)

		   {

			   stareLong = MAX_PROCESS_SIZE;

		   }

		   else

		   {

			   stareLong = pContext->Length;

		   }

		   MmPrepareMdlForReuse((PMDL)pContext->NewMdl);

		   IoBuildPartialMdl(pContext->UserIrp->MdlAddress,(PMDL)pContext->NewMdl,(PVOID)pContext->VirtualAddress,stareLong);



		   pContext->VirtualAddress += stareLong;

		   pContext->Length -=stareLong;

		   IoCopyCurrentIrpStackLocationToNext(pIrp);

		   stack = IoGetNextIrpStackLocation(pIrp);

		   stack->Parameters.Read.Length = stareLong;

		   stack->Parameters.Write.Length =stareLong;

		   IoSetCompletionRoutine(pIrp,IoCompleteRoutine,pContext,TRUE,TRUE,TRUE);

		   IoCallDriver(pContext->pTarDevice,pIrp);

		   return STATUS_MORE_PROCESSING_REQUIRED;

	   }

	   else

	   {

		   pContext->UserIrp->IoStatus.Information = pContext->AlreadlyLength;

	   }

	}

	



	return   STATUS_MORE_PROCESSING_REQUIRED;

}



#pragma  PAGECODE

NTSTATUS OperatoeDevice(PDEVICE_OBJECT pDeviceObject,PIRP pIrp)

{  

    NTSTATUS status =STATUS_SUCCESS;

	PDEVICE_OBJECT pTarDev;

	UNICODE_STRING TarName;

	PIRP pNewIrp;

	PMDL pNewMdl;

	PFILE_OBJECT pFileObject;

	//HANDLE handle;

	IO_STATUS_BLOCK TarBlock;

	PIO_STACK_LOCATION stack;

	PVOID UserVirtualAddress;

	ULONG UserVirtualSize;

	PRWCONTEXT pConText;

	PUCHAR ReadBuff;

	ULONG max_read_size;

	ULONG LastReadSize;

	KEVENT Revent;

//	PDRIVER_OBJECT pDriverObject;

	stack = IoGetCurrentIrpStackLocation(pIrp);

	

	KeInitializeEvent(&Revent,NotificationEvent,FALSE);



	RtlInitUnicodeString(&TarName,L"\\Device\\MoonDeviceA");

	status = IoGetDeviceObjectPointer(&TarName,FILE_ALL_ACCESS,&pFileObject,&pTarDev);

	if(!NT_SUCCESS(status))

	{   

		KdPrint(("error COde == %08X",status));

		status = STATUS_UNSUCCESSFUL;

		goto IrpState;

	}



	UserVirtualAddress = MmGetMdlVirtualAddress(pIrp->MdlAddress);

	UserVirtualSize = MmGetMdlByteCount(pIrp->MdlAddress);

	KdPrint(("User Mdl == %08X\n",UserVirtualAddress));

	KdPrint(("Use Mdl length == %d\n",UserVirtualSize));



// 	status = ObReferenceObjectByName(&TarName,OBJ_CASE_INSENSITIVE,NULL,FILE_ALL_ACCESS,IoDeviceObjectType,KernelMode,NULL,(PVOID*)&pTarDev);

// 	//status = IoGetDeviceObjectPointer(&TarName,FILE_ALL_ACCESS,&pFileObject,&pTarDev);

// 	if(!NT_SUCCESS(status))

// 	{   

// 		KdPrint(("error COde == %08X",status));

// 	    status = STATUS_UNSUCCESSFUL;

// 		goto IrpState;

// 	}

// 	KdPrint(("ObReferenceObjectByName-----\n"));

// 	status  = ObOpenObjectByPointer(pTarDev,0,0,PROCESS_ALL_ACCESS,NULL,KernelMode,&handle);

// 	if(!NT_SUCCESS(status))

// 	{

// 		status = STATUS_UNSUCCESSFUL;

// 		goto IrpState;

// 	}

// 	status = ObReferenceObjectByHandle(handle,FILE_ALL_ACCESS,*IoFileObjectType,KernelMode,(PVOID*)&pFileObject,NULL);

// 	KdPrint(("ObReferenceObjectByHandle-----\n"));

// 	if(!NT_SUCCESS(status))

// 	{

// 		status = STATUS_UNSUCCESSFUL;

// 	}

	pConText =(PRWCONTEXT) ExAllocatePool(PagedPool,sizeof(RWCONTEST));

	pConText->Length = UserVirtualSize ;

	pConText->OldMdl = pIrp->MdlAddress;

	if(UserVirtualSize > MAX_PROCESS_SIZE)

	{

		max_read_size = MAX_PROCESS_SIZE;

	}

	else

	{

         max_read_size= UserVirtualSize;

	}

	ReadBuff =(PUCHAR) ExAllocatePool(PagedPool,max_read_size);

	pNewIrp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,pTarDev,ReadBuff,max_read_size,0,&Revent,&TarBlock);

	KdPrint(("IoBuildAsynchronousFsdRequest-----\n"));

	if (pNewIrp == NULL)

	{

		status = STATUS_UNSUCCESSFUL;

		goto IrpState;

	}



	pNewMdl = IoAllocateMdl(UserVirtualAddress,UserVirtualSize,FALSE,FALSE,pNewIrp);

	pNewIrp->MdlAddress = pNewMdl;

	pConText->NewMdl = pNewMdl;

	pConText->AlreadlyLength=0;

	pConText->AlreadlyLength = max_read_size;

	pConText->VirtualAddress = (ULONG_PTR)UserVirtualAddress+max_read_size ;

	pConText->UserIrp = pIrp;

	KeInitializeEvent(&(pConText->Uevent),NotificationEvent,FALSE);

	IoCopyCurrentIrpStackLocationToNext(pNewIrp);

	IoSetCompletionRoutine(pNewIrp,IoCompleteRoutine,pConText,TRUE,TRUE,TRUE);

	LastReadSize = pConText->AlreadlyLength;

	status = IoCallDriver(pTarDev,pNewIrp);



IrpState:

	pIrp->IoStatus.Status = status;

	pIrp->IoStatus.Information = LastReadSize;//pConText->AlreadlyLength;

	//if(IoFreeMdl !=NULL)

	//IoFreeMdl(pNewMdl);

	//if(pConText != NULL)

	//ExFreePool(pConText);

	IoCompleteRequest(pIrp,IO_NO_INCREMENT);

	return status;



}