You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
413 lines
9.7 KiB
413 lines
9.7 KiB
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
async.c
|
|
|
|
Abstract:
|
|
|
|
This is the main file for the AsyncMAC Driver for the Remote Access
|
|
Service. This driver conforms to the NDIS 3.0 interface.
|
|
|
|
This driver was adapted from the LANCE driver written by
|
|
TonyE.
|
|
|
|
NULL device driver code from DarrylH.
|
|
|
|
The idea for handling loopback and sends simultaneously is largely
|
|
adapted from the EtherLink II NDIS driver by Adam Barr.
|
|
|
|
Author:
|
|
|
|
Thomas J. Dimitri (TommyD) 08-May-1992
|
|
|
|
Environment:
|
|
|
|
Kernel Mode - Or whatever is the equivalent on OS/2 and DOS.
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#include "asyncall.h"
|
|
|
|
// asyncmac.c will define the global parameters.
|
|
#define GLOBALS
|
|
#include "globals.h"
|
|
|
|
|
|
NDIS_HANDLE NdisWrapperHandle;
|
|
PDRIVER_OBJECT AsyncDriverObject;
|
|
NDIS_HANDLE AsyncDeviceHandle;
|
|
NPAGED_LOOKASIDE_LIST AsyncIoCtxList;
|
|
NPAGED_LOOKASIDE_LIST AsyncInfoList;
|
|
ULONG glConnectionCount = 0;
|
|
|
|
VOID
|
|
AsyncUnload(
|
|
IN NDIS_HANDLE MacMacContext
|
|
);
|
|
|
|
NDIS_STATUS
|
|
AsyncFillInGlobalData(
|
|
IN PASYNC_ADAPTER Adapter,
|
|
IN PNDIS_REQUEST NdisRequest);
|
|
|
|
//
|
|
// Define the local routines used by this driver module.
|
|
//
|
|
|
|
NTSTATUS
|
|
AsyncIOCtlRequest(
|
|
IN PIRP pIrp, // Pointer to I/O request packet
|
|
IN PIO_STACK_LOCATION pIrpSp // Pointer to the IRP stack location
|
|
);
|
|
|
|
|
|
//
|
|
// ZZZ Portable interface.
|
|
//
|
|
NTSTATUS
|
|
DriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the primary initialization routine for the async driver.
|
|
It is simply responsible for the intializing the wrapper and registering
|
|
the MAC. It then calls a system and architecture specific routine that
|
|
will initialize and register each adapter.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - Pointer to driver object created by the system.
|
|
|
|
Return Value:
|
|
|
|
The status of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
NDIS_STATUS InitStatus;
|
|
NDIS_MINIPORT_CHARACTERISTICS AsyncChar;
|
|
|
|
//
|
|
// Initialize some globals
|
|
//
|
|
ExInitializeNPagedLookasideList(&AsyncIoCtxList,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
sizeof(ASYNC_IO_CTX),
|
|
ASYNC_IOCTX_TAG,
|
|
0);
|
|
|
|
ExInitializeNPagedLookasideList(&AsyncInfoList,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
sizeof(ASYNC_INFO),
|
|
ASYNC_INFO_TAG,
|
|
0);
|
|
|
|
NdisAllocateSpinLock(&GlobalLock);
|
|
|
|
AsyncDriverObject = DriverObject;
|
|
|
|
//
|
|
// Initialize the wrapper.
|
|
//
|
|
NdisMInitializeWrapper(&NdisWrapperHandle,
|
|
DriverObject,
|
|
RegistryPath,
|
|
NULL);
|
|
|
|
//
|
|
// Initialize the MAC characteristics for the call to NdisRegisterMac.
|
|
//
|
|
NdisZeroMemory(&AsyncChar, sizeof(AsyncChar));
|
|
|
|
AsyncChar.MajorNdisVersion = ASYNC_NDIS_MAJOR_VERSION;
|
|
AsyncChar.MinorNdisVersion = ASYNC_NDIS_MINOR_VERSION;
|
|
AsyncChar.Reserved = NDIS_USE_WAN_WRAPPER;
|
|
|
|
//
|
|
// We do not need the following handlers:
|
|
// CheckForHang
|
|
// DisableInterrupt
|
|
// EnableInterrupt
|
|
// HandleInterrupt
|
|
// ISR
|
|
// Send
|
|
// TransferData
|
|
//
|
|
AsyncChar.HaltHandler = MpHalt;
|
|
AsyncChar.InitializeHandler = MpInit;
|
|
AsyncChar.QueryInformationHandler = MpQueryInfo;
|
|
AsyncChar.ReconfigureHandler = MpReconfigure;
|
|
AsyncChar.ResetHandler = MpReset;
|
|
AsyncChar.WanSendHandler = MpSend;
|
|
AsyncChar.SetInformationHandler = MpSetInfo;
|
|
|
|
InitStatus =
|
|
NdisMRegisterMiniport(NdisWrapperHandle,
|
|
&AsyncChar,
|
|
sizeof(AsyncChar));
|
|
|
|
if ( InitStatus == NDIS_STATUS_SUCCESS ) {
|
|
|
|
#if MY_DEVICE_OBJECT
|
|
//
|
|
// Initialize the driver object with this device driver's entry points.
|
|
//
|
|
NdisMjDeviceControl = DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL];
|
|
NdisMjCreate = DriverObject->MajorFunction[IRP_MJ_CREATE];
|
|
NdisMjCleanup = DriverObject->MajorFunction[IRP_MJ_CLEANUP];
|
|
|
|
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AsyncDriverDispatch;
|
|
DriverObject->MajorFunction[IRP_MJ_CREATE] = AsyncDriverCreate;
|
|
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = AsyncDriverCleanup;
|
|
|
|
AsyncSetupExternalNaming(DriverObject);
|
|
#endif
|
|
|
|
NdisUnload = DriverObject->DriverUnload;
|
|
DriverObject->DriverUnload = AsyncUnload;
|
|
|
|
DbgTracef(0,("AsyncMAC succeeded to Register MAC\n"));
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
ExDeleteNPagedLookasideList(&AsyncIoCtxList);
|
|
ExDeleteNPagedLookasideList(&AsyncInfoList);
|
|
|
|
NdisTerminateWrapper(NdisWrapperHandle, DriverObject);
|
|
|
|
return NDIS_STATUS_FAILURE;
|
|
}
|
|
|
|
NTSTATUS
|
|
AsyncDriverCreate(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
{
|
|
//
|
|
// Get current Irp stack location
|
|
//
|
|
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
|
|
|
|
#ifdef MY_DEVICE_OBJECT
|
|
//
|
|
// Make sure that this is for us
|
|
//
|
|
if (pDeviceObject != AsyncDeviceObject) {
|
|
|
|
return(NdisMjCreate(pDeviceObject, pIrp));
|
|
}
|
|
#endif
|
|
|
|
pIrp->IoStatus.Information = 0;
|
|
pIrp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
|
|
return (STATUS_SUCCESS);
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
AsyncDriverCleanup(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
{
|
|
//
|
|
// Get current Irp stack location
|
|
//
|
|
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
|
|
|
|
#ifdef MY_DEVICE_OBJECT
|
|
//
|
|
// Make sure that this is for us
|
|
//
|
|
if (pDeviceObject != AsyncDeviceObject) {
|
|
|
|
return(NdisMjCleanup(pDeviceObject, pIrp));
|
|
}
|
|
#endif
|
|
|
|
pIrp->IoStatus.Information = 0;
|
|
pIrp->IoStatus.Status = STATUS_SUCCESS;
|
|
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
|
|
return (STATUS_SUCCESS);
|
|
}
|
|
|
|
NTSTATUS
|
|
AsyncDriverDispatch(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the main dispatch routine for the AsyncMac device
|
|
driver. It accepts an I/O Request Packet, performs the request, and then
|
|
returns with the appropriate status.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for this driver.
|
|
|
|
Irp - Pointer to the request packet representing the I/O request.
|
|
|
|
Return Value:
|
|
|
|
The function value is the status of the operation.
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION irpSp;
|
|
ULONG ulDeviceType;
|
|
ULONG ulMethod;
|
|
|
|
//
|
|
// if this is win64 make sure the calling process is 64bit
|
|
// since this interface is only used by rasman and rasman
|
|
// will always be 64bit on 64bit systems we will not bother
|
|
// with thunking. if the process is not a 64bit process get
|
|
// out.
|
|
#ifdef _WIN64
|
|
if (IoIs32bitProcess(Irp)) {
|
|
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return (STATUS_NOT_SUPPORTED);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Get a pointer to the current stack location in the IRP. This is where
|
|
// the function codes and parameters are stored.
|
|
//
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
ulDeviceType = (irpSp->Parameters.DeviceIoControl.IoControlCode >> 16) & 0x0000FFFF;
|
|
ulMethod = irpSp->Parameters.DeviceIoControl.IoControlCode & 0x00000003;
|
|
|
|
#ifdef MY_DEVICE_OBJECT
|
|
//
|
|
// Make sure that this is for us
|
|
//
|
|
if ((irpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL) ||
|
|
(ulDeviceType != FILE_DEVICE_ASYMAC) ||
|
|
(DeviceObject != AsyncDeviceObject)) {
|
|
|
|
return(NdisMjDeviceControl(DeviceObject, Irp));
|
|
}
|
|
#else
|
|
if ((irpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL) ||
|
|
(ulDeviceType != FILE_DEVICE_NETWORK) ||
|
|
(DeviceObject != AsyncDeviceObject) ||
|
|
(ulMethod != METHOD_BUFFERED)) {
|
|
|
|
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
|
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return (STATUS_NOT_SUPPORTED);
|
|
}
|
|
#endif
|
|
|
|
status = AsyncIOCtlRequest(Irp, irpSp);
|
|
|
|
switch (status) {
|
|
case STATUS_SUCCESS:
|
|
break;
|
|
|
|
case STATUS_PENDING:
|
|
return(status);
|
|
|
|
case STATUS_INFO_LENGTH_MISMATCH:
|
|
//
|
|
// See if this was a request to get size needed for
|
|
// ioctl.
|
|
//
|
|
if (irpSp->Parameters.DeviceIoControl.OutputBufferLength >=
|
|
sizeof(ULONG)) {
|
|
*(PULONG_PTR)Irp->AssociatedIrp.SystemBuffer =
|
|
Irp->IoStatus.Information;
|
|
Irp->IoStatus.Information = sizeof(ULONG);
|
|
} else {
|
|
Irp->IoStatus.Information = 0;
|
|
}
|
|
status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
default:
|
|
if (status < 0xC0000000) {
|
|
status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
Irp->IoStatus.Information = 0;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Copy the final status into the return status,
|
|
// complete the request and get out of here.
|
|
//
|
|
|
|
Irp->IoStatus.Status = status;
|
|
|
|
IoCompleteRequest( Irp, (UCHAR)0 );
|
|
|
|
return (status);
|
|
}
|
|
|
|
VOID
|
|
AsyncUnload(
|
|
PDRIVER_OBJECT DriverObject
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
AsyncUnload is called when the MAC is to unload itself.
|
|
|
|
Arguments:
|
|
|
|
MacMacContext - not used.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
ExDeleteNPagedLookasideList(&AsyncIoCtxList);
|
|
ExDeleteNPagedLookasideList(&AsyncInfoList);
|
|
|
|
#ifdef MY_DEVICE_OBJECT
|
|
AsyncCleanupExternalNaming();
|
|
#endif
|
|
|
|
(*NdisUnload)(DriverObject);
|
|
}
|