驱动学习--IOControl

驱动：

#include <ntddk.h>
#include <minwindef.h>


#define  DEVICE_NAME L"\\Device\\Mydevice"
#define  SYMBOL_NAME L"\\??\\Mydevice"


#define  IOCTL_MUL   CTL_CODE(FILE_DEVICE_UNKNOWN,0x9888,METHOD_BUFFERED,FILE_ANY_ACCESS)


VOID DriverUnload(PDRIVER_OBJECT pdriver)
{

	if (pdriver->DeviceObject)
	{
		IoDeleteDevice(pdriver->DeviceObject);
		UNICODE_STRING symname = { 0 };
		RtlInitUnicodeString(&symname, SYMBOL_NAME);
		IoDeleteSymbolicLink(&symname);
	}


	DbgPrint("Drive has loaded\n");



}

NTSTATUS MajorCreate(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be open!\n");
	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = 0;
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}
NTSTATUS MajorClose(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be close!\n");
	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = 0;
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}
NTSTATUS MajorCleanUp(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be MajorCleanUp!\n");
	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = 0;
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}

NTSTATUS MajorRead(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be MajorRead!\n");

	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);
	ULONG  readSize = pstack->Parameters.Read.Length;
	PCHAR  readBuff = pirp->AssociatedIrp.SystemBuffer;
	RtlCopyMemory(readBuff, "this is from kernel", strlen("this is from kernel"));

	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = strlen("this is from kernel");
	DbgPrint("the kernel read length:%d\n", strlen("this is from kernel"));
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}
NTSTATUS MajorWrite(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be MajorRead!\n");

	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);
	ULONG  writeSize = pstack->Parameters.Write.Length;
	PCHAR  writeBuff = pirp->AssociatedIrp.SystemBuffer;
	RtlZeroMemory(pdevice->DeviceExtension, 200);
	RtlCopyMemory(pdevice->DeviceExtension, writeBuff, writeSize);

	DbgPrint("--%p---%s\n", writeBuff, (PCHAR)pdevice->DeviceExtension);

	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = writeSize;
	DbgPrint("the kernel read length:%d\n", strlen("this is from kernel"));
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}

NTSTATUS MajorControl(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;
	DbgPrint("My Device has be MajorCleanUp!\n");

	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);

	ULONG iocode = pstack->Parameters.DeviceIoControl.IoControlCode;
	ULONG inlen = pstack->Parameters.DeviceIoControl.InputBufferLength;
	ULONG outlen = pstack->Parameters.DeviceIoControl.OutputBufferLength;
	ULONG ioinfo = 0;
	switch (iocode)
	{
	case IOCTL_MUL:
	{
		DWORD indata = *(PDWORD)pirp->AssociatedIrp.SystemBuffer;

		DbgPrint("---kernel indata %d\n", indata);

		indata = indata * 5;
		*(PDWORD)pirp->AssociatedIrp.SystemBuffer = indata;
		ioinfo = 4;
		break;
	}
	default:
		status = STATUS_UNSUCCESSFUL;
		ioinfo = 0;
		break;
	}




	pirp->IoStatus.Status = status;
	pirp->IoStatus.Information = ioinfo;
	IoCompleteRequest(pirp, IO_NO_INCREMENT);
	return status;
}


NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverobject, PUNICODE_STRING pRegPath)
{
	NTSTATUS status = STATUS_SUCCESS;

	UNICODE_STRING devicename = { 0 };
	PDEVICE_OBJECT pdevice = NULL;

	pDriverobject->DriverUnload = DriverUnload;
	DbgPrint("Hello world\n");

	RtlInitUnicodeString(&devicename,DEVICE_NAME);

	status = IoCreateDevice(pDriverobject, 200, &devicename, FILE_DEVICE_UNKNOWN, 0, TRUE, &pdevice);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("Create device failed\n");
		return status;
	}

	pdevice->Flags |= DO_BUFFERED_IO;

	UNICODE_STRING symname = { 0 };

	RtlInitUnicodeString(&symname, SYMBOL_NAME);

	status = IoCreateSymbolicLink(&symname, &devicename);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("createsymbollink failed\n");
		IoDeleteSymbolicLink(&devicename);
		return status;
	}


	pDriverobject->MajorFunction[IRP_MJ_CREATE] = MajorCreate;
	pDriverobject->MajorFunction[IRP_MJ_CLOSE] = MajorClose;
	pDriverobject->MajorFunction[IRP_MJ_CLEANUP] = MajorCleanUp;
	pDriverobject->MajorFunction[IRP_MJ_READ] = MajorRead;
	pDriverobject->MajorFunction[IRP_MJ_WRITE] = MajorWrite;
	pDriverobject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = MajorControl;
	return status;
}

应用层：

#include <iostream>
#include <windows.h>
#include <winioctl.h>


#define  IOCTL_MUL   CTL_CODE(FILE_DEVICE_UNKNOWN,0x9888,METHOD_BUFFERED,FILE_ANY_ACCESS)


int main()
{
    HANDLE hdevice = NULL;

    CHAR readBuffer[50] = { 0 };
    DWORD bread = 0;

    int a = 114;
    int b = 0;

    hdevice = CreateFile(L"\\\\.\\Mydevice", GENERIC_READ | GENERIC_WRITE, 0, NULL,OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (!hdevice)
    {
        printf("Open Device failed\n");
        system("pause");
    }
    printf("Open Success\n");
    system("pause");

    /*ReadFile(hdevice, (PVOID)readBuffer, 50, &bread, NULL);

    printf("---%s----%d--\n", readBuffer, bread);
    system("pause");
    WriteFile(hdevice, "this is from R3.", strlen("this is from R3."), &bread, NULL);*/


    DeviceIoControl(hdevice, IOCTL_MUL, &a, 4, &b, 4, &bread, NULL);

    printf("--in  %d----out  %d---really  %d",a,b,bread);

    system("pause");
    CloseHandle(hdevice);
    system("pause");
    return 0;
}