passthru.c

用Delphi实现的防火墙,可实现象天网一样的功能.

/*++

Copyright (c) 1992  Microsoft Corporation
 
Module Name:
 
	passthru.c

Abstract:

	Ndis Intermediate Miniport driver sample. This is a passthru driver.

Author:

Environment:


Revision History:


--*/


#include "precomp.h"
#include "fw_rule.h"
#include "util.h"
//#include "in_systm.h"
#include "DDKLBLInc.h"
#include "cons_def.h"
#include "fw_interface.h"

#include "driver.h"

#define DEVICE_NAME	L"\\Device\\DOGFW"
#define DOSDEVICE_NAME L"\\DosDevices\\DogFW"

#pragma hdrstop

#pragma NDIS_INIT_FUNCTION(DriverEntry)

NDIS_PHYSICAL_ADDRESS			HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
NDIS_HANDLE						ProtHandle = NULL;
NDIS_HANDLE						DriverHandle = NULL;
NDIS_MEDIUM						MediumArray[3] =
									{
										NdisMedium802_3,	// Ethernet
										NdisMedium802_5,	// Token-ring
										NdisMediumFddi		// Fddi
									};


PADAPT  pAdaptList=NULL;
PDEVICE_OBJECT g_DeviceObject = NULL;
NDIS_HANDLE    g_NdisDeviceHandle = NULL;
struct Fw_Rules g_Rules;
struct Statistics  g_stat;
struct ip 		g_IPHeader, *g_pIPHeader=NULL;
struct tcphdr	g_TCPHeader, *g_pTCPHeader=NULL;
struct udphdr	g_UDPHeader, *g_pUDPHeader=NULL;
struct icmp		g_ICMPHeader, *g_pICMPHeader=NULL;

/*struct All_Alarms 	g_AllAlarm[MAX_CALL_NUM];
struct All_Logs		g_AllLog[MAX_CALL_NUM];
PFILE_OBJECT 		g_alarmfop=NULL;
PDEVICE_EXTENSION 	g_alarmpdx=NULL;

PFILE_OBJECT 		g_logfop=NULL;
PDEVICE_EXTENSION 	g_logpdx=NULL;
*/
//FAST_MUTEX  fw_mutex;

extern USHORT	lcall_num,acall_num;

NTSTATUS
DefaultDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
)
{
	PIO_STACK_LOCATION	IrpStack;
	ULONG	ControlCode;
	ULONG	InputLength, OutputLength;
	
	IrpStack=IoGetCurrentIrpStackLocation(Irp);
	ControlCode=IrpStack->Parameters.DeviceIoControl.IoControlCode;
	InputLength=IrpStack->Parameters.DeviceIoControl.InputBufferLength;
	OutputLength=IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

	Irp->IoStatus.Status=STATUS_SUCCESS;
	Irp->IoStatus.Information=0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;

}


NTSTATUS
DeviceIoDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
)
{
	PIO_STACK_LOCATION	IrpStack;
	ULONG	ControlCode;
	ULONG	InputLength, OutputLength;
	//add by df
	struct All_Rules		*pallrules=NULL;
	struct Proto_Restrict	*pprotocol=NULL;
	struct Time_Restrict	*pschedule=NULL;
	
	struct All_Alarms		*pallalarm=NULL;
	struct All_Logs			*palllog=NULL;
	struct Statistics		*pstat=NULL;
	PVOID					chkbuf=NULL;
	ULONG					length;
	ULONG	info=0;
	NTSTATUS status;
	PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
	//NTSTATUS status = IoAcquireRemoveLock(&pdx->RemoveLock, Irp);
//	if (!NT_SUCCESS(status))
	//	return CompleteRequest(Irp, status, 0);
	
	IrpStack=IoGetCurrentIrpStackLocation(Irp);
	ControlCode=IrpStack->Parameters.DeviceIoControl.IoControlCode;
	InputLength=IrpStack->Parameters.DeviceIoControl.InputBufferLength;
	OutputLength=IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

	DBGPRINT("test begin");
	switch(ControlCode){
	case IOCTL_DOGFW_CTL_FW_STATUS:				//char *fw_status
		//ExAcquireFastMutex(&fw_mutex);
		g_Rules.global.fw_status=*(PCHAR)Irp->AssociatedIrp.SystemBuffer;
		info=sizeof(char);
		status=STATUS_SUCCESS;
		//ExReleaseFastMutex(&fw_mutex);
		break;
	case IOCTL_DOGFW_CTL_FWMODE:				//char *fw_mode
		//ExAcquireFastMutex(&fw_mutex);
   		g_Rules.global.fw_mode=*(PCHAR)Irp->AssociatedIrp.SystemBuffer;
		info=sizeof(char);
		status=STATUS_SUCCESS;
		//ExReleaseFastMutex(&fw_mutex);
		break;
    case IOCTL_DOGFW_CTL_CHKDATA:				//
    	chkbuf=(PVOID)Irp->AssociatedIrp.SystemBuffer;
    	length=IrpStack->Parameters.DeviceIoControl.InputBufferLength;
    	UTIL_AddKeyword(chkbuf,length);
    	info=length;
		status=STATUS_SUCCESS;
		break;
	case IOCTL_DOGFW_CTL_DELCHKDATA:
		UTIL_DelKeyword();
		status=STATUS_SUCCESS;
		break;
	
	default:
		status=STATUS_SUCCESS;
		break;
	}
	//Irp->IoStatus.Status=status;
	//Irp->IoStatus.Information=info;
	//IoReleaseRemoveLock(&pdx->RemoveLock, Irp);
	//IoCompleteRequest(Irp, IO_NO_INCREMENT);
	CompleteRequest(Irp,status,info);
	return status;
}


NTSTATUS
DriverEntry(
	IN	PDRIVER_OBJECT		DriverObject,
	IN	PUNICODE_STRING		RegistryPath
	)
/*++

Routine Description:


Arguments:

Return Value:


--*/
{
	NDIS_STATUS						Status;
	NDIS_PROTOCOL_CHARACTERISTICS	PChars;
	NDIS_MINIPORT_CHARACTERISTICS	MChars;
	PNDIS_CONFIGURATION_PARAMETER	Param;
	NDIS_STRING						Name;
	NDIS_HANDLE						WrapperHandle;
	PDRIVER_DISPATCH				MajorFunc[IRP_MJ_MAXIMUM_FUNCTION+1];
	UNICODE_STRING					DeviceName, DosDeviceName;
	
	PDEVICE_EXTENSION 				pdx;
	int i;
	
	DbgPrint(("driverentry------------------------------------\n"));
	RtlInitUnicodeString(&DeviceName, DEVICE_NAME);
	RtlInitUnicodeString(&DosDeviceName, DOSDEVICE_NAME);
	//ExInitializeFastMutex(&fw_mutex);

	//
	// Register the miniport with NDIS. Note that it is the miniport
	// which was started as a driver and not the protocol. Also the miniport
	// must be registered prior to the protocol since the protocol's BindAdapter
	// handler can be initiated anytime and when it is, it must be ready to
	// start driver instances.
	//
	NdisMInitializeWrapper(&WrapperHandle, DriverObject, RegistryPath, NULL);

	NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_CHARACTERISTICS));

	MChars.MajorNdisVersion = 4;
	MChars.MinorNdisVersion = 0;

	MChars.InitializeHandler = MPInitialize;
	MChars.QueryInformationHandler = MPQueryInformation;
	MChars.SetInformationHandler = MPSetInformation;
	MChars.ResetHandler = MPReset;
	MChars.TransferDataHandler = MPTransferData;
	MChars.HaltHandler = MPHalt;

	//
	// We will disable the check for hang timeout so we do not
	// need a check for hang handler!
	//
	MChars.CheckForHangHandler = NULL;
	MChars.SendHandler = MPSend;
	MChars.ReturnPacketHandler = MPReturnPacket;

	//
	// Either the Send or the SendPackets handler should be specified.
	// If SendPackets handler is specified, SendHandler is ignored
	//
	// MChars.SendPacketsHandler = MPSendPackets;

	Status = NdisIMRegisterLayeredMiniport(WrapperHandle,
										   &MChars,
										   sizeof(MChars),
										   &DriverHandle);
	ASSERT(Status == NDIS_STATUS_SUCCESS);

	NdisMRegisterUnloadHandler(WrapperHandle, PtUnload);

	//
	// Now register the protocol.
	//
	NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
	PChars.MajorNdisVersion = 4;
	PChars.MinorNdisVersion = 0;

	//
	// Make sure the protocol-name matches the service-name under which this protocol is installed.
	// This is needed to ensure that NDIS can correctly determine the binding and call us to bind
	// to miniports below.
	//
	NdisInitUnicodeString(&Name, L"SFilter");	// Protocol name
	PChars.Name = Name;
	PChars.OpenAdapterCompleteHandler = PtOpenAdapterComplete;
	PChars.CloseAdapterCompleteHandler = PtCloseAdapterComplete;
	PChars.SendCompleteHandler = PtSendComplete;
	PChars.TransferDataCompleteHandler = PtTransferDataComplete;
	
	PChars.ResetCompleteHandler = PtResetComplete;
	PChars.RequestCompleteHandler = PtRequestComplete;
	PChars.ReceiveHandler = PtReceive;
	PChars.ReceiveCompleteHandler = PtReceiveComplete;
	PChars.StatusHandler = PtStatus;
	PChars.StatusCompleteHandler = PtStatusComplete;
	PChars.BindAdapterHandler = PtBindAdapter;
	PChars.UnbindAdapterHandler = PtUnbindAdapter;
	PChars.UnloadHandler = NULL;
	PChars.ReceivePacketHandler = PtReceivePacket;
	PChars.PnPEventHandler= PtPNPHandler;

	NdisRegisterProtocol(&Status,
						 &ProtHandle,
						 &PChars,
						 sizeof(NDIS_PROTOCOL_CHARACTERISTICS));

	ASSERT(Status == NDIS_STATUS_SUCCESS);

	NdisIMAssociateMiniport(DriverHandle, ProtHandle);
	
	for(i=0; i<=IRP_MJ_MAXIMUM_FUNCTION; i++)
		MajorFunc[i]=DefaultDispatch;//DefaultDispatch;

	MajorFunc[IRP_MJ_CREATE] = DispatchCreate;
	MajorFunc[IRP_MJ_CLOSE] = DispatchClose;
	MajorFunc[IRP_MJ_DEVICE_CONTROL]=DeviceIoDispatch;
	
	
	NdisMRegisterDevice(
	    WrapperHandle,
	    &DeviceName,
	    &DosDeviceName,
	    MajorFunc,
	    &g_DeviceObject,
	    &g_NdisDeviceHandle
	    );


	pdx = (PDEVICE_EXTENSION) g_DeviceObject->DeviceExtension;
	pdx->DeviceObject=g_DeviceObject;
	InitializeListHead(&pdx->hlist);
	KeInitializeSpinLock(&pdx->lockHandles);
    //IoInitializeRemoveLock(&pdx->RemoveLock, 0, 0, 0);
    g_DeviceObject->Flags&= ~DO_DEVICE_INITIALIZING;	//hear of ....
  	RtlFillMemory(
	  &g_Rules,
	  sizeof(g_Rules),
	  0
	  );

    RtlFillMemory(
	  &g_stat,
	  sizeof(g_stat),
	  0
	  );

	g_pIPHeader=&g_IPHeader;
	g_pTCPHeader=&g_TCPHeader;
	g_pUDPHeader=&g_UDPHeader;
	g_pICMPHeader=&g_ICMPHeader;

	g_Rules.global.pkeylist=NULL;
	g_Rules.global.fw_status=FWS_ALLOWALL;
	g_Rules.icmp.enable=1;
	g_Rules.tcp.enable=1;
	g_Rules.udp.enable=1;
	g_Rules.ip.enable=1;
  	return(Status);
}