// Main program for ioctl driver

// Copyright (C) 1999 by Walter Oney

// All rights reserved



#include "stddcls.h"

#include "driver.h"



NTSTATUS AddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT pdo);

VOID DriverUnload(IN PDRIVER_OBJECT fdo);



BOOLEAN win98 = FALSE;



UNICODE_STRING servkey;



///////////////////////////////////////////////////////////////////////////////



#pragma PAGEDCODE



extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,

	IN PUNICODE_STRING RegistryPath)

	{							// DriverEntry

	KdPrint((DRIVERNAME " - Entering DriverEntry: DriverObject %8.8lX\n", DriverObject));



	// Insist that OS support at least the WDM level of the DDK we use



	if (!IoIsWdmVersionAvailable(1, 0))

		{

		KdPrint((DRIVERNAME " - Expected version of WDM (%d.%2.2d) not available\n", 1, 0));

		return STATUS_UNSUCCESSFUL;

		}



	// See if we're running under Win98 or NT:



	win98 = IsWin98();



#if DBG

	if (win98)

		KdPrint((DRIVERNAME " - Running under Windows 98\n"));

	else

		KdPrint((DRIVERNAME " - Running under NT\n"));

#endif



	// Save the name of the service key



	servkey.Buffer = (PWSTR) ExAllocatePool(PagedPool, RegistryPath->Length + sizeof(WCHAR));

	if (!servkey.Buffer)

		{

		KdPrint((DRIVERNAME " - Unable to allocate %d bytes for copy of service key name\n", RegistryPath->Length + sizeof(WCHAR)));

		return STATUS_INSUFFICIENT_RESOURCES;

		}

	servkey.MaximumLength = RegistryPath->Length + sizeof(WCHAR);

	RtlCopyUnicodeString(&servkey, RegistryPath);

	servkey.Buffer[RegistryPath->Length / 2] = 0;



	// Initialize function pointers



	DriverObject->DriverUnload = DriverUnload;

	DriverObject->DriverExtension->AddDevice = AddDevice;



	DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;

	DriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;

	DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchControl;

	DriverObject->MajorFunction[IRP_MJ_POWER] = DispatchPower;

	DriverObject->MajorFunction[IRP_MJ_PNP] = DispatchPnp;

	DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = DispatchWmi;

	

	return STATUS_SUCCESS;

	}							// DriverEntry



///////////////////////////////////////////////////////////////////////////////



#pragma PAGEDCODE



VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)

	{							// DriverUnload

	PAGED_CODE();

	DBG_UNREFERENCED_LOCAL_VARIABLE(DriverObject);

	KdPrint((DRIVERNAME " - Entering DriverUnload: DriverObject %8.8lX\n", DriverObject));

	RtlFreeUnicodeString(&servkey);

	}							// DriverUnload



///////////////////////////////////////////////////////////////////////////////



NTSTATUS AddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT pdo)

	{							// AddDevice

	PAGED_CODE();

	KdPrint((DRIVERNAME " - Entering AddDevice: DriverObject %8.8lX, pdo %8.8lX\n", DriverObject, pdo));



	NTSTATUS status;



	// Create a function device object to represent the hardware we're managing.



	PDEVICE_OBJECT fdo;

	

	ULONG dxsize = (sizeof(DEVICE_EXTENSION) + 7) & ~7;

	ULONG xsize = dxsize + GetSizeofGenericExtension();

	

	UNICODE_STRING devname;

	RtlInitUnicodeString(&devname, L"\\DosDevices\\IOCTL");



	status = IoCreateDevice(DriverObject, xsize, &devname,

		FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &fdo);

	if (!NT_SUCCESS(status))

		{						// can't create device object

		KdPrint((DRIVERNAME " - IoCreateDevice failed - %X\n", status));

		return status;

		}						// can't create device object

	

	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;



	// From this point forward, any error will have side effects that need to

	// be cleaned up.



	do

		{						// finish initialization

		pdx->DeviceObject = fdo;

		pdx->Pdo = pdo;



		// Make a copy of the device name



		pdx->devname.Buffer = (PWCHAR) ExAllocatePool(NonPagedPool, devname.MaximumLength);

		if (!pdx->devname.Buffer)

			{					// can't allocate buffer

			status = STATUS_INSUFFICIENT_RESOURCES;

			KdPrint((DRIVERNAME " - Unable to allocate %d bytes for copy of name\n", devname.MaximumLength));

			break;;

			}					// can't allocate buffer

		pdx->devname.MaximumLength = devname.MaximumLength;

		RtlCopyUnicodeString(&pdx->devname, &devname);



		// Link our device object into the stack leading to the PDO

		

		pdx->LowerDeviceObject = IoAttachDeviceToDeviceStack(fdo, pdo);

		if (!pdx->LowerDeviceObject)

			{					// can't attach								 

			KdPrint((DRIVERNAME " - IoAttachDeviceToDeviceStack failed\n"));

			status = STATUS_DEVICE_REMOVED;

			break;;

			}					// can't attach



		// Initialize to use the GENERIC.SYS library



		pdx->pgx = (PGENERIC_EXTENSION) ((PUCHAR) pdx + dxsize);



		GENERIC_INIT_STRUCT gis = {sizeof(GENERIC_INIT_STRUCT)};

		gis.DeviceObject = fdo;

		gis.Pdo = pdo;

		gis.Ldo = pdx->LowerDeviceObject;

		gis.RemoveLock = &pdx->RemoveLock;

		gis.StartDevice = StartDevice;

		gis.StopDevice = StopDevice;

		gis.RemoveDevice = RemoveDevice;

		RtlInitUnicodeString(&gis.DebugName, LDRIVERNAME);



		status = InitializeGenericExtension(pdx->pgx, &gis);

		if (!NT_SUCCESS(status))

			{

			KdPrint((DRIVERNAME " - InitializeGenericExtension failed - %X\n", status));

			break;;

			}



		// Clear the "initializing" flag so that we can get IRPs



		fdo->Flags &= ~DO_DEVICE_INITIALIZING;

		}						// finish initialization

	while (FALSE);



	if (!NT_SUCCESS(status))

		{					// need to cleanup

		if (pdx->devname.Buffer)

			RtlFreeUnicodeString(&pdx->devname);

		if (pdx->LowerDeviceObject)

			IoDetachDevice(pdx->LowerDeviceObject);

		IoDeleteDevice(fdo);

		}					// need to cleanup



	return status;

	}							// AddDevice



///////////////////////////////////////////////////////////////////////////////



#pragma LOCKEDCODE



NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG_PTR info)

	{							// CompleteRequest

	Irp->IoStatus.Status = status;

	Irp->IoStatus.Information = info;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return status;

	}							// CompleteRequest



///////////////////////////////////////////////////////////////////////////////



#pragma PAGEDCODE



NTSTATUS DispatchPnp(PDEVICE_OBJECT fdo, PIRP Irp)

	{							// DispatchPnp

	PAGED_CODE();

	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

	return GenericDispatchPnp(pdx->pgx, Irp);

	}							// DispatchPnp



NTSTATUS DispatchPower(PDEVICE_OBJECT fdo, PIRP Irp)

	{							// DispatchPower

	PAGED_CODE();

	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

	return GenericDispatchPower(pdx->pgx, Irp);

	}							// DispatchPower



NTSTATUS DispatchWmi(PDEVICE_OBJECT fdo, PIRP Irp)

	{							// DispatchWmi

	PAGED_CODE();

	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

	IoSkipCurrentIrpStackLocation(Irp);

	return IoCallDriver(pdx->LowerDeviceObject, Irp);

	}							// DispatchWmi



///////////////////////////////////////////////////////////////////////////////



#pragma PAGEDCODE



VOID RemoveDevice(IN PDEVICE_OBJECT fdo)

	{							// RemoveDevice

	PAGED_CODE();

	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;



	RtlFreeUnicodeString(&pdx->devname);



	if (pdx->LowerDeviceObject)

		IoDetachDevice(pdx->LowerDeviceObject);



	IoDeleteDevice(fdo);

	}							// RemoveDevice



#pragma LOCKEDCODE				// force inline functions into locked code