b2ether/driver/b2ether.c

/*
 *  b2ether driver -- derived from DDK packet driver sample
 *
 *  Basilisk II (C) 1997-1999 Christian Bauer
 *
 *  Windows platform specific code copyright (C) Lauri Pesonen
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


#include "stdarg.h"
#include "ntddk.h"
#include "ntiologc.h"
#include "ndis.h"
#include "ntddpack.h"
#include "b2ether.h"

#undef DBG
#define DBG 0
#include "debug.h"

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    );


NTSTATUS
PacketReadRegistry(
    IN  PWSTR              *MacDriverName,
    IN  PWSTR              *PacketDriverName,
    IN  PUNICODE_STRING     RegistryPath
    );


NTSTATUS
PacketCreateSymbolicLink(
    IN  PUNICODE_STRING  DeviceName,
    IN  BOOLEAN          Create
    );

NTSTATUS
PacketQueryRegistryRoutine(
    IN PWSTR     ValueName,
    IN ULONG     ValueType,
    IN PVOID     ValueData,
    IN ULONG     ValueLength,
    IN PVOID     Context,
    IN PVOID     EntryContext
    );


#if DBG
ULONG PacketDebugFlag = PACKET_DEBUG_LOUD;
#endif


PDEVICE_EXTENSION GlobalDeviceExtension;


NTSTATUS DriverEntry(
        IN PDRIVER_OBJECT DriverObject,
        IN PUNICODE_STRING RegistryPath
)
{
  NDIS_PROTOCOL_CHARACTERISTICS  ProtocolChar;

  UNICODE_STRING MacDriverName;
  UNICODE_STRING UnicodeDeviceName;

  PDEVICE_OBJECT DeviceObject = NULL;
  PDEVICE_EXTENSION DeviceExtension = NULL;

  NTSTATUS Status = STATUS_SUCCESS;
  NTSTATUS ErrorCode = STATUS_SUCCESS;
  NDIS_STRING ProtoName = NDIS_STRING_CONST("PacketDriver");

  ULONG          DevicesCreated=0;

  PWSTR          BindString;
  PWSTR          ExportString;

  PWSTR          BindStringSave;
  PWSTR          ExportStringSave;

  NDIS_HANDLE    NdisProtocolHandle;

  IF_LOUD(DbgPrint("\n\nPacket: DriverEntry\n");)

  RtlZeroMemory(&ProtocolChar,sizeof(NDIS_PROTOCOL_CHARACTERISTICS));

  ProtocolChar.MajorNdisVersion            = 3;
  ProtocolChar.MinorNdisVersion            = 0;
  ProtocolChar.Reserved                    = 0;
  ProtocolChar.OpenAdapterCompleteHandler  = PacketOpenAdapterComplete;
  ProtocolChar.CloseAdapterCompleteHandler = PacketCloseAdapterComplete;
  ProtocolChar.SendCompleteHandler         = PacketSendComplete;
  ProtocolChar.TransferDataCompleteHandler = PacketTransferDataComplete;
  ProtocolChar.ResetCompleteHandler        = PacketResetComplete;
  ProtocolChar.RequestCompleteHandler      = PacketRequestComplete;
  ProtocolChar.ReceiveHandler              = PacketReceiveIndicate;
  ProtocolChar.ReceiveCompleteHandler      = PacketReceiveComplete;
  ProtocolChar.StatusHandler               = PacketStatus;
  ProtocolChar.StatusCompleteHandler       = PacketStatusComplete;
  ProtocolChar.Name                        = ProtoName;

  NdisRegisterProtocol(
      &Status,
      &NdisProtocolHandle,
      &ProtocolChar,
      sizeof(NDIS_PROTOCOL_CHARACTERISTICS));

  if (Status != NDIS_STATUS_SUCCESS) {
      IF_LOUD(DbgPrint("Packet: Failed to register protocol with NDIS\n");)
      return Status;
  }

  //
  // Set up the device driver entry points.
  //

  DriverObject->MajorFunction[IRP_MJ_CREATE] = PacketOpen;
  DriverObject->MajorFunction[IRP_MJ_CLOSE]  = PacketClose;
  DriverObject->MajorFunction[IRP_MJ_READ]   = PacketRead;
  DriverObject->MajorFunction[IRP_MJ_WRITE]  = PacketWrite;
  DriverObject->MajorFunction[IRP_MJ_CLEANUP]  = PacketCleanup;
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]  = PacketIoControl;

  DriverObject->DriverUnload = PacketUnload;


  //
  //  Get the name of the Packet driver and the name of the MAC driver
  //  to bind to from the registry
  //

  Status=PacketReadRegistry(
             &BindString,
             &ExportString,
             RegistryPath
             );

  if (Status != STATUS_SUCCESS) {
      IF_LOUD(DbgPrint("Perf: Failed to read registry\n");)
      goto RegistryError;
  }

  BindStringSave   = BindString;
  ExportStringSave = ExportString;

  //  create a device object for each entry
  while (*BindString!= UNICODE_NULL && *ExportString!= UNICODE_NULL) {

      //  Create a counted unicode string for both null terminated strings
      RtlInitUnicodeString(
          &MacDriverName,
          BindString
          );

      RtlInitUnicodeString(
          &UnicodeDeviceName,
          ExportString
          );

      //  Advance to the next string of the MULTI_SZ string
      BindString   += (MacDriverName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);

      ExportString += (UnicodeDeviceName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);

      IF_LOUD(DbgPrint("Packet: DeviceName=%ws  MacName=%ws\n",UnicodeDeviceName.Buffer,MacDriverName.Buffer);)

      //  Create the device object
      Status = IoCreateDevice(
                  DriverObject,
                  sizeof(DEVICE_EXTENSION),
                  &UnicodeDeviceName,
                  FILE_DEVICE_PROTOCOL,
                  0,
                  FALSE,
                  &DeviceObject
                  );

      if (Status != STATUS_SUCCESS) {
          IF_LOUD(DbgPrint("Perf: IoCreateDevice() failed:\n");)
          break;
      }

      DevicesCreated++;

      DeviceObject->Flags |= DO_DIRECT_IO;
      DeviceExtension  =  (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
      DeviceExtension->DeviceObject = DeviceObject;

      //  Save the the name of the MAC driver to open in the Device Extension
      DeviceExtension->AdapterName=MacDriverName;

      if (DevicesCreated == 1) {
          DeviceExtension->BindString   = BindStringSave;
          DeviceExtension->ExportString = ExportStringSave;
      }

      DeviceExtension->NdisProtocolHandle=NdisProtocolHandle;
  }

  if (DevicesCreated > 0) {
      return STATUS_SUCCESS;
  }

  ExFreePool(BindStringSave);
  ExFreePool(ExportStringSave);

RegistryError:

  NdisDeregisterProtocol(
      &Status,
      NdisProtocolHandle
      );

  Status=STATUS_UNSUCCESSFUL;

  return(Status);
}


VOID PacketUnload( IN PDRIVER_OBJECT DriverObject )
{
  PDEVICE_OBJECT     DeviceObject;
  PDEVICE_OBJECT     OldDeviceObject;
  PDEVICE_EXTENSION  DeviceExtension;

  NDIS_HANDLE        NdisProtocolHandle;
  NDIS_STATUS        Status;

  IF_LOUD(DbgPrint("Packet: Unload\n");)

  DeviceObject = DriverObject->DeviceObject;

  while (DeviceObject != NULL) {
      DeviceExtension = DeviceObject->DeviceExtension;
      NdisProtocolHandle = DeviceExtension->NdisProtocolHandle;
      if (DeviceExtension->BindString != NULL) {
          ExFreePool(DeviceExtension->BindString);
      }
      if (DeviceExtension->ExportString != NULL) {
          ExFreePool(DeviceExtension->ExportString);
      }
      OldDeviceObject=DeviceObject;
      DeviceObject=DeviceObject->NextDevice;
      IoDeleteDevice(OldDeviceObject);
  }

  NdisDeregisterProtocol( &Status, NdisProtocolHandle );
}


NTSTATUS PacketIoControl( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
{
  POPEN_INSTANCE      Open;
  PIO_STACK_LOCATION  IrpSp;
  PLIST_ENTRY         RequestListEntry;
  PINTERNAL_REQUEST   pRequest;
  ULONG               FunctionCode;
  NDIS_STATUS     Status;

  IF_LOUD(DbgPrint("Packet: IoControl\n");)

  IrpSp = IoGetCurrentIrpStackLocation(Irp);

  FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;

  Open=IrpSp->FileObject->FsContext;

  RequestListEntry=ExInterlockedRemoveHeadList(&Open->RequestList,&Open->RequestSpinLock);
  if (RequestListEntry == NULL) {
    Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_UNSUCCESSFUL;
  }

  pRequest=CONTAINING_RECORD(RequestListEntry,INTERNAL_REQUEST,ListElement);
  pRequest->Irp=Irp;

  IoMarkIrpPending(Irp);
  Irp->IoStatus.Status = STATUS_PENDING;

  IF_LOUD(DbgPrint("Packet: Function code is %08lx  buff size=%08lx  %08lx\n",FunctionCode,IrpSp->Parameters.DeviceIoControl.InputBufferLength,IrpSp->Parameters.DeviceIoControl.OutputBufferLength);)

  if (FunctionCode == IOCTL_PROTOCOL_RESET) {
      IF_LOUD(DbgPrint("Packet: IoControl - Reset request\n");)
      ExInterlockedInsertTailList(
              &Open->ResetIrpList,
              &Irp->Tail.Overlay.ListEntry,
              &Open->RequestSpinLock);
      NdisReset( &Status, Open->AdapterHandle );

      if (Status != NDIS_STATUS_PENDING) {
          IF_LOUD(DbgPrint("Packet: IoControl - ResetComplte being called\n");)
          PacketResetComplete( Open, Status );
      }

  } else {
      //  See if it is an Ndis request
      PPACKET_OID_DATA    OidData=Irp->AssociatedIrp.SystemBuffer;

      if (((FunctionCode == IOCTL_PROTOCOL_SET_OID) || (FunctionCode == IOCTL_PROTOCOL_QUERY_OID))
          &&
          (IrpSp->Parameters.DeviceIoControl.InputBufferLength == IrpSp->Parameters.DeviceIoControl.OutputBufferLength)
          &&
          (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA))
          &&
          (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA)-1+OidData->Length)) {

          IF_LOUD(DbgPrint("Packet: IoControl: Request: Oid=%08lx, Length=%08lx\n",OidData->Oid,OidData->Length);)

          if (FunctionCode == IOCTL_PROTOCOL_SET_OID) {
              pRequest->Request.RequestType=NdisRequestSetInformation;
              pRequest->Request.DATA.SET_INFORMATION.Oid=OidData->Oid;
              pRequest->Request.DATA.SET_INFORMATION.InformationBuffer=OidData->Data;
              pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength=OidData->Length;
          } else {
              pRequest->Request.RequestType=NdisRequestQueryInformation;
              pRequest->Request.DATA.QUERY_INFORMATION.Oid=OidData->Oid;
              pRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer=OidData->Data;
              pRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength=OidData->Length;
          }
          NdisRequest(
              &Status,
              Open->AdapterHandle,
              &pRequest->Request
              );
      } else { // buffer too small
          Status=NDIS_STATUS_FAILURE;
          pRequest->Request.DATA.SET_INFORMATION.BytesRead=0;
          pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten=0;
      }

      if (Status != NDIS_STATUS_PENDING) {
          IF_LOUD(DbgPrint("Packet: Calling RequestCompleteHandler\n");)
          PacketRequestComplete(
              Open,
              &pRequest->Request,
              Status
              );
      }
  }
  return(STATUS_PENDING);
}


VOID PacketRequestComplete(
  IN NDIS_HANDLE   ProtocolBindingContext,
  IN PNDIS_REQUEST NdisRequest,
  IN NDIS_STATUS   Status
)
{
  POPEN_INSTANCE      Open;
  PIO_STACK_LOCATION  IrpSp;
  PIRP                Irp;
  PINTERNAL_REQUEST   pRequest;
  UINT                FunctionCode;

  PPACKET_OID_DATA    OidData;

  IF_LOUD(DbgPrint("Packet: RequestComplete\n");)

  Open= (POPEN_INSTANCE)ProtocolBindingContext;

  pRequest=CONTAINING_RECORD(NdisRequest,INTERNAL_REQUEST,Request);
  Irp=pRequest->Irp;

  IrpSp = IoGetCurrentIrpStackLocation(Irp);

  FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;

  OidData=Irp->AssociatedIrp.SystemBuffer;

  if (FunctionCode == IOCTL_PROTOCOL_SET_OID) {
      OidData->Length=pRequest->Request.DATA.SET_INFORMATION.BytesRead;
  } else {
      if (FunctionCode == IOCTL_PROTOCOL_QUERY_OID) {
          OidData->Length=pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
      }
  }

  Irp->IoStatus.Information=IrpSp->Parameters.DeviceIoControl.InputBufferLength;

  ExInterlockedInsertTailList(
      &Open->RequestList,
      &pRequest->ListElement,
      &Open->RequestSpinLock);

  Irp->IoStatus.Status = Status;
  IoCompleteRequest(Irp, IO_NO_INCREMENT);
}


VOID PacketStatus(
  IN NDIS_HANDLE   ProtocolBindingContext,
  IN NDIS_STATUS   Status,
  IN PVOID         StatusBuffer,
  IN UINT          StatusBufferSize
)
{
  IF_LOUD(DbgPrint("Packet: Status Indication\n");)
}


VOID PacketStatusComplete( IN NDIS_HANDLE  ProtocolBindingContext )
{
  IF_LOUD(DbgPrint("Packet: StatusIndicationComplete\n");)
}


#if 0
NTSTATUS PacketCreateSymbolicLink(
  IN  PUNICODE_STRING  DeviceName,
  IN  BOOLEAN          Create
)
{
    UNICODE_STRING UnicodeDosDeviceName;
    NTSTATUS       Status;

    if (DeviceName->Length < sizeof(L"\\Device\\")) {
        return STATUS_UNSUCCESSFUL;
    }

    RtlInitUnicodeString(&UnicodeDosDeviceName,NULL);
    UnicodeDosDeviceName.MaximumLength=DeviceName->Length+sizeof(L"\\DosDevices")+sizeof(UNICODE_NULL);
    UnicodeDosDeviceName.Buffer=ExAllocatePool(
                                    NonPagedPool,
                                    UnicodeDosDeviceName.MaximumLength
                                    );
    if (UnicodeDosDeviceName.Buffer != NULL) {
        RtlZeroMemory( UnicodeDosDeviceName.Buffer, UnicodeDosDeviceName.MaximumLength );
        RtlAppendUnicodeToString( &UnicodeDosDeviceName, L"\\DosDevices\\" );
        RtlAppendUnicodeToString( &UnicodeDosDeviceName, (DeviceName->Buffer+(sizeof("\\Device"))) );
        IF_LOUD(DbgPrint("Packet: DosDeviceName is %ws\n",UnicodeDosDeviceName.Buffer);)
        if (Create) {
            Status=IoCreateSymbolicLink(&UnicodeDosDeviceName,DeviceName);
        } else {
            Status=IoDeleteSymbolicLink(&UnicodeDosDeviceName);
        }
        ExFreePool(UnicodeDosDeviceName.Buffer);
    }
    return Status;
}
#endif


NTSTATUS PacketReadRegistry(
        IN  PWSTR              *MacDriverName,
        IN  PWSTR              *PacketDriverName,
        IN  PUNICODE_STRING     RegistryPath
)
{
  NTSTATUS   Status;
  RTL_QUERY_REGISTRY_TABLE ParamTable[5];
  PWSTR      Bind       = L"Bind";        // LAURI: \Device\W30NT1
  PWSTR      Export     = L"Export";      // \Device\appletalk\W30NT1\0\0
  PWSTR      Parameters = L"Parameters";
  PWSTR      Linkage    = L"Linkage";
  PWCHAR     Path;

  Path=ExAllocatePool( PagedPool, RegistryPath->Length+sizeof(WCHAR) );

  if (!Path) return STATUS_INSUFFICIENT_RESOURCES;

  RtlZeroMemory( Path, RegistryPath->Length+sizeof(WCHAR) );
  RtlCopyMemory( Path, RegistryPath->Buffer, RegistryPath->Length );

  IF_LOUD(DbgPrint("Packet: Reg path is %ws\n",RegistryPath->Buffer);)

  RtlZeroMemory( ParamTable, sizeof(ParamTable) );

  //  change to the parmeters key
  ParamTable[0].QueryRoutine = NULL;
  ParamTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
  ParamTable[0].Name = Parameters;

  //  change to the linkage key
  ParamTable[1].QueryRoutine = NULL;
  ParamTable[1].Flags = RTL_QUERY_REGISTRY_SUBKEY;
  ParamTable[1].Name = Linkage;

  //  Get the name of the mac driver we should bind to
  ParamTable[2].QueryRoutine = PacketQueryRegistryRoutine;
  ParamTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;

  ParamTable[2].Name = Bind;
  ParamTable[2].EntryContext = (PVOID)MacDriverName;
  ParamTable[2].DefaultType = REG_MULTI_SZ;

  //  Get the name that we should use for the driver object
  ParamTable[3].QueryRoutine = PacketQueryRegistryRoutine;
  ParamTable[3].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND;

  ParamTable[3].Name = Export;
  ParamTable[3].EntryContext = (PVOID)PacketDriverName;
  ParamTable[3].DefaultType = REG_MULTI_SZ;

  Status=RtlQueryRegistryValues(
             RTL_REGISTRY_ABSOLUTE,
             Path,
             ParamTable,
             NULL,
             NULL
             );

  ExFreePool(Path);

  return Status;
}


NTSTATUS PacketQueryRegistryRoutine(
    IN PWSTR     ValueName,
    IN ULONG     ValueType,
    IN PVOID     ValueData,
    IN ULONG     ValueLength,
    IN PVOID     Context,
    IN PVOID     EntryContext
    )

{
  PUCHAR Buffer;

  IF_LOUD(DbgPrint("Perf: QueryRegistryRoutine\n");)

  if (ValueType != REG_MULTI_SZ) {
      return STATUS_OBJECT_NAME_NOT_FOUND;
  }

  Buffer=ExAllocatePool(NonPagedPool,ValueLength);
  if(!Buffer) return STATUS_INSUFFICIENT_RESOURCES;

  RtlCopyMemory( Buffer, ValueData, ValueLength );

  *((PUCHAR *)EntryContext)=Buffer;

  return STATUS_SUCCESS;
}
Revision:	1.1
Committed:	2012-04-21T16:23:07Z (12 years, 5 months ago) by asvitkine
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Import b2ether driver sources from a 2001 source archive of BasiliskII.
#	User	Rev	Content
1	asvitkine	1.1	/*
2			* b2ether driver -- derived from DDK packet driver sample
3			*
4			* Basilisk II (C) 1997-1999 Christian Bauer
5			*
6			* Windows platform specific code copyright (C) Lauri Pesonen
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21			*/
22
23
24			#include "stdarg.h"
25			#include "ntddk.h"
26			#include "ntiologc.h"
27			#include "ndis.h"
28			#include "ntddpack.h"
29			#include "b2ether.h"
30
31			#undef DBG
32			#define DBG 0
33			#include "debug.h"
34
35			NTSTATUS
36			DriverEntry(
37			IN PDRIVER_OBJECT DriverObject,
38			IN PUNICODE_STRING RegistryPath
39			);
40
41
42			NTSTATUS
43			PacketReadRegistry(
44			IN PWSTR *MacDriverName,
45			IN PWSTR *PacketDriverName,
46			IN PUNICODE_STRING RegistryPath
47			);
48
49
50			NTSTATUS
51			PacketCreateSymbolicLink(
52			IN PUNICODE_STRING DeviceName,
53			IN BOOLEAN Create
54			);
55
56			NTSTATUS
57			PacketQueryRegistryRoutine(
58			IN PWSTR ValueName,
59			IN ULONG ValueType,
60			IN PVOID ValueData,
61			IN ULONG ValueLength,
62			IN PVOID Context,
63			IN PVOID EntryContext
64			);
65
66
67			#if DBG
68			ULONG PacketDebugFlag = PACKET_DEBUG_LOUD;
69			#endif
70
71
72			PDEVICE_EXTENSION GlobalDeviceExtension;
73
74
75			NTSTATUS DriverEntry(
76			IN PDRIVER_OBJECT DriverObject,
77			IN PUNICODE_STRING RegistryPath
78			)
79			{
80			NDIS_PROTOCOL_CHARACTERISTICS ProtocolChar;
81
82			UNICODE_STRING MacDriverName;
83			UNICODE_STRING UnicodeDeviceName;
84
85			PDEVICE_OBJECT DeviceObject = NULL;
86			PDEVICE_EXTENSION DeviceExtension = NULL;
87
88			NTSTATUS Status = STATUS_SUCCESS;
89			NTSTATUS ErrorCode = STATUS_SUCCESS;
90			NDIS_STRING ProtoName = NDIS_STRING_CONST("PacketDriver");
91
92			ULONG DevicesCreated=0;
93
94			PWSTR BindString;
95			PWSTR ExportString;
96
97			PWSTR BindStringSave;
98			PWSTR ExportStringSave;
99
100			NDIS_HANDLE NdisProtocolHandle;
101
102			IF_LOUD(DbgPrint("\n\nPacket: DriverEntry\n");)
103
104			RtlZeroMemory(&ProtocolChar,sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
105
106			ProtocolChar.MajorNdisVersion = 3;
107			ProtocolChar.MinorNdisVersion = 0;
108			ProtocolChar.Reserved = 0;
109			ProtocolChar.OpenAdapterCompleteHandler = PacketOpenAdapterComplete;
110			ProtocolChar.CloseAdapterCompleteHandler = PacketCloseAdapterComplete;
111			ProtocolChar.SendCompleteHandler = PacketSendComplete;
112			ProtocolChar.TransferDataCompleteHandler = PacketTransferDataComplete;
113			ProtocolChar.ResetCompleteHandler = PacketResetComplete;
114			ProtocolChar.RequestCompleteHandler = PacketRequestComplete;
115			ProtocolChar.ReceiveHandler = PacketReceiveIndicate;
116			ProtocolChar.ReceiveCompleteHandler = PacketReceiveComplete;
117			ProtocolChar.StatusHandler = PacketStatus;
118			ProtocolChar.StatusCompleteHandler = PacketStatusComplete;
119			ProtocolChar.Name = ProtoName;
120
121			NdisRegisterProtocol(
122			&Status,
123			&NdisProtocolHandle,
124			&ProtocolChar,
125			sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
126
127			if (Status != NDIS_STATUS_SUCCESS) {
128			IF_LOUD(DbgPrint("Packet: Failed to register protocol with NDIS\n");)
129			return Status;
130			}
131
132			//
133			// Set up the device driver entry points.
134			//
135
136			DriverObject->MajorFunction[IRP_MJ_CREATE] = PacketOpen;
137			DriverObject->MajorFunction[IRP_MJ_CLOSE] = PacketClose;
138			DriverObject->MajorFunction[IRP_MJ_READ] = PacketRead;
139			DriverObject->MajorFunction[IRP_MJ_WRITE] = PacketWrite;
140			DriverObject->MajorFunction[IRP_MJ_CLEANUP] = PacketCleanup;
141			DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PacketIoControl;
142
143			DriverObject->DriverUnload = PacketUnload;
144
145
146			//
147			// Get the name of the Packet driver and the name of the MAC driver
148			// to bind to from the registry
149			//
150
151			Status=PacketReadRegistry(
152			&BindString,
153			&ExportString,
154			RegistryPath
155			);
156
157			if (Status != STATUS_SUCCESS) {
158			IF_LOUD(DbgPrint("Perf: Failed to read registry\n");)
159			goto RegistryError;
160			}
161
162			BindStringSave = BindString;
163			ExportStringSave = ExportString;
164
165			// create a device object for each entry
166			while (BindString!= UNICODE_NULL && ExportString!= UNICODE_NULL) {
167
168			// Create a counted unicode string for both null terminated strings
169			RtlInitUnicodeString(
170			&MacDriverName,
171			BindString
172			);
173
174			RtlInitUnicodeString(
175			&UnicodeDeviceName,
176			ExportString
177			);
178
179			// Advance to the next string of the MULTI_SZ string
180			BindString += (MacDriverName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);
181
182			ExportString += (UnicodeDeviceName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);
183
184			IF_LOUD(DbgPrint("Packet: DeviceName=%ws MacName=%ws\n",UnicodeDeviceName.Buffer,MacDriverName.Buffer);)
185
186			// Create the device object
187			Status = IoCreateDevice(
188			DriverObject,
189			sizeof(DEVICE_EXTENSION),
190			&UnicodeDeviceName,
191			FILE_DEVICE_PROTOCOL,
192			0,
193			FALSE,
194			&DeviceObject
195			);
196
197			if (Status != STATUS_SUCCESS) {
198			IF_LOUD(DbgPrint("Perf: IoCreateDevice() failed:\n");)
199			break;
200			}
201
202			DevicesCreated++;
203
204			DeviceObject->Flags \|= DO_DIRECT_IO;
205			DeviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
206			DeviceExtension->DeviceObject = DeviceObject;
207
208			// Save the the name of the MAC driver to open in the Device Extension
209			DeviceExtension->AdapterName=MacDriverName;
210
211			if (DevicesCreated == 1) {
212			DeviceExtension->BindString = BindStringSave;
213			DeviceExtension->ExportString = ExportStringSave;
214			}
215
216			DeviceExtension->NdisProtocolHandle=NdisProtocolHandle;
217			}
218
219			if (DevicesCreated > 0) {
220			return STATUS_SUCCESS;
221			}
222
223			ExFreePool(BindStringSave);
224			ExFreePool(ExportStringSave);
225
226			RegistryError:
227
228			NdisDeregisterProtocol(
229			&Status,
230			NdisProtocolHandle
231			);
232
233			Status=STATUS_UNSUCCESSFUL;
234
235			return(Status);
236			}
237
238
239			VOID PacketUnload( IN PDRIVER_OBJECT DriverObject )
240			{
241			PDEVICE_OBJECT DeviceObject;
242			PDEVICE_OBJECT OldDeviceObject;
243			PDEVICE_EXTENSION DeviceExtension;
244
245			NDIS_HANDLE NdisProtocolHandle;
246			NDIS_STATUS Status;
247
248			IF_LOUD(DbgPrint("Packet: Unload\n");)
249
250			DeviceObject = DriverObject->DeviceObject;
251
252			while (DeviceObject != NULL) {
253			DeviceExtension = DeviceObject->DeviceExtension;
254			NdisProtocolHandle = DeviceExtension->NdisProtocolHandle;
255			if (DeviceExtension->BindString != NULL) {
256			ExFreePool(DeviceExtension->BindString);
257			}
258			if (DeviceExtension->ExportString != NULL) {
259			ExFreePool(DeviceExtension->ExportString);
260			}
261			OldDeviceObject=DeviceObject;
262			DeviceObject=DeviceObject->NextDevice;
263			IoDeleteDevice(OldDeviceObject);
264			}
265
266			NdisDeregisterProtocol( &Status, NdisProtocolHandle );
267			}
268
269
270			NTSTATUS PacketIoControl( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
271			{
272			POPEN_INSTANCE Open;
273			PIO_STACK_LOCATION IrpSp;
274			PLIST_ENTRY RequestListEntry;
275			PINTERNAL_REQUEST pRequest;
276			ULONG FunctionCode;
277			NDIS_STATUS Status;
278
279			IF_LOUD(DbgPrint("Packet: IoControl\n");)
280
281			IrpSp = IoGetCurrentIrpStackLocation(Irp);
282
283			FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;
284
285			Open=IrpSp->FileObject->FsContext;
286
287			RequestListEntry=ExInterlockedRemoveHeadList(&Open->RequestList,&Open->RequestSpinLock);
288			if (RequestListEntry == NULL) {
289			Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
290			Irp->IoStatus.Information = 0;
291			IoCompleteRequest(Irp, IO_NO_INCREMENT);
292			return STATUS_UNSUCCESSFUL;
293			}
294
295			pRequest=CONTAINING_RECORD(RequestListEntry,INTERNAL_REQUEST,ListElement);
296			pRequest->Irp=Irp;
297
298			IoMarkIrpPending(Irp);
299			Irp->IoStatus.Status = STATUS_PENDING;
300
301			IF_LOUD(DbgPrint("Packet: Function code is %08lx buff size=%08lx %08lx\n",FunctionCode,IrpSp->Parameters.DeviceIoControl.InputBufferLength,IrpSp->Parameters.DeviceIoControl.OutputBufferLength);)
302
303			if (FunctionCode == IOCTL_PROTOCOL_RESET) {
304			IF_LOUD(DbgPrint("Packet: IoControl - Reset request\n");)
305			ExInterlockedInsertTailList(
306			&Open->ResetIrpList,
307			&Irp->Tail.Overlay.ListEntry,
308			&Open->RequestSpinLock);
309			NdisReset( &Status, Open->AdapterHandle );
310
311			if (Status != NDIS_STATUS_PENDING) {
312			IF_LOUD(DbgPrint("Packet: IoControl - ResetComplte being called\n");)
313			PacketResetComplete( Open, Status );
314			}
315
316			} else {
317			// See if it is an Ndis request
318			PPACKET_OID_DATA OidData=Irp->AssociatedIrp.SystemBuffer;
319
320			if (((FunctionCode == IOCTL_PROTOCOL_SET_OID) \|\| (FunctionCode == IOCTL_PROTOCOL_QUERY_OID))
321			&&
322			(IrpSp->Parameters.DeviceIoControl.InputBufferLength == IrpSp->Parameters.DeviceIoControl.OutputBufferLength)
323			&&
324			(IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA))
325			&&
326			(IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA)-1+OidData->Length)) {
327
328			IF_LOUD(DbgPrint("Packet: IoControl: Request: Oid=%08lx, Length=%08lx\n",OidData->Oid,OidData->Length);)
329
330			if (FunctionCode == IOCTL_PROTOCOL_SET_OID) {
331			pRequest->Request.RequestType=NdisRequestSetInformation;
332			pRequest->Request.DATA.SET_INFORMATION.Oid=OidData->Oid;
333			pRequest->Request.DATA.SET_INFORMATION.InformationBuffer=OidData->Data;
334			pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength=OidData->Length;
335			} else {
336			pRequest->Request.RequestType=NdisRequestQueryInformation;
337			pRequest->Request.DATA.QUERY_INFORMATION.Oid=OidData->Oid;
338			pRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer=OidData->Data;
339			pRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength=OidData->Length;
340			}
341			NdisRequest(
342			&Status,
343			Open->AdapterHandle,
344			&pRequest->Request
345			);
346			} else { // buffer too small
347			Status=NDIS_STATUS_FAILURE;
348			pRequest->Request.DATA.SET_INFORMATION.BytesRead=0;
349			pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten=0;
350			}
351
352			if (Status != NDIS_STATUS_PENDING) {
353			IF_LOUD(DbgPrint("Packet: Calling RequestCompleteHandler\n");)
354			PacketRequestComplete(
355			Open,
356			&pRequest->Request,
357			Status
358			);
359			}
360			}
361			return(STATUS_PENDING);
362			}
363
364
365			VOID PacketRequestComplete(
366			IN NDIS_HANDLE ProtocolBindingContext,
367			IN PNDIS_REQUEST NdisRequest,
368			IN NDIS_STATUS Status
369			)
370			{
371			POPEN_INSTANCE Open;
372			PIO_STACK_LOCATION IrpSp;
373			PIRP Irp;
374			PINTERNAL_REQUEST pRequest;
375			UINT FunctionCode;
376
377			PPACKET_OID_DATA OidData;
378
379			IF_LOUD(DbgPrint("Packet: RequestComplete\n");)
380
381			Open= (POPEN_INSTANCE)ProtocolBindingContext;
382
383			pRequest=CONTAINING_RECORD(NdisRequest,INTERNAL_REQUEST,Request);
384			Irp=pRequest->Irp;
385
386			IrpSp = IoGetCurrentIrpStackLocation(Irp);
387
388			FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;
389
390			OidData=Irp->AssociatedIrp.SystemBuffer;
391
392			if (FunctionCode == IOCTL_PROTOCOL_SET_OID) {
393			OidData->Length=pRequest->Request.DATA.SET_INFORMATION.BytesRead;
394			} else {
395			if (FunctionCode == IOCTL_PROTOCOL_QUERY_OID) {
396			OidData->Length=pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
397			}
398			}
399
400			Irp->IoStatus.Information=IrpSp->Parameters.DeviceIoControl.InputBufferLength;
401
402			ExInterlockedInsertTailList(
403			&Open->RequestList,
404			&pRequest->ListElement,
405			&Open->RequestSpinLock);
406
407			Irp->IoStatus.Status = Status;
408			IoCompleteRequest(Irp, IO_NO_INCREMENT);
409			}
410
411
412			VOID PacketStatus(
413			IN NDIS_HANDLE ProtocolBindingContext,
414			IN NDIS_STATUS Status,
415			IN PVOID StatusBuffer,
416			IN UINT StatusBufferSize
417			)
418			{
419			IF_LOUD(DbgPrint("Packet: Status Indication\n");)
420			}
421
422
423			VOID PacketStatusComplete( IN NDIS_HANDLE ProtocolBindingContext )
424			{
425			IF_LOUD(DbgPrint("Packet: StatusIndicationComplete\n");)
426			}
427
428
429			#if 0
430			NTSTATUS PacketCreateSymbolicLink(
431			IN PUNICODE_STRING DeviceName,
432			IN BOOLEAN Create
433			)
434			{
435			UNICODE_STRING UnicodeDosDeviceName;
436			NTSTATUS Status;
437
438			if (DeviceName->Length < sizeof(L"\\Device\\")) {
439			return STATUS_UNSUCCESSFUL;
440			}
441
442			RtlInitUnicodeString(&UnicodeDosDeviceName,NULL);
443			UnicodeDosDeviceName.MaximumLength=DeviceName->Length+sizeof(L"\\DosDevices")+sizeof(UNICODE_NULL);
444			UnicodeDosDeviceName.Buffer=ExAllocatePool(
445			NonPagedPool,
446			UnicodeDosDeviceName.MaximumLength
447			);
448			if (UnicodeDosDeviceName.Buffer != NULL) {
449			RtlZeroMemory( UnicodeDosDeviceName.Buffer, UnicodeDosDeviceName.MaximumLength );
450			RtlAppendUnicodeToString( &UnicodeDosDeviceName, L"\\DosDevices\\" );
451			RtlAppendUnicodeToString( &UnicodeDosDeviceName, (DeviceName->Buffer+(sizeof("\\Device"))) );
452			IF_LOUD(DbgPrint("Packet: DosDeviceName is %ws\n",UnicodeDosDeviceName.Buffer);)
453			if (Create) {
454			Status=IoCreateSymbolicLink(&UnicodeDosDeviceName,DeviceName);
455			} else {
456			Status=IoDeleteSymbolicLink(&UnicodeDosDeviceName);
457			}
458			ExFreePool(UnicodeDosDeviceName.Buffer);
459			}
460			return Status;
461			}
462			#endif
463
464
465			NTSTATUS PacketReadRegistry(
466			IN PWSTR *MacDriverName,
467			IN PWSTR *PacketDriverName,
468			IN PUNICODE_STRING RegistryPath
469			)
470			{
471			NTSTATUS Status;
472			RTL_QUERY_REGISTRY_TABLE ParamTable[5];
473			PWSTR Bind = L"Bind"; // LAURI: \Device\W30NT1
474			PWSTR Export = L"Export"; // \Device\appletalk\W30NT1\0\0
475			PWSTR Parameters = L"Parameters";
476			PWSTR Linkage = L"Linkage";
477			PWCHAR Path;
478
479			Path=ExAllocatePool( PagedPool, RegistryPath->Length+sizeof(WCHAR) );
480
481			if (!Path) return STATUS_INSUFFICIENT_RESOURCES;
482
483			RtlZeroMemory( Path, RegistryPath->Length+sizeof(WCHAR) );
484			RtlCopyMemory( Path, RegistryPath->Buffer, RegistryPath->Length );
485
486			IF_LOUD(DbgPrint("Packet: Reg path is %ws\n",RegistryPath->Buffer);)
487
488			RtlZeroMemory( ParamTable, sizeof(ParamTable) );
489
490			// change to the parmeters key
491			ParamTable[0].QueryRoutine = NULL;
492			ParamTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
493			ParamTable[0].Name = Parameters;
494
495			// change to the linkage key
496			ParamTable[1].QueryRoutine = NULL;
497			ParamTable[1].Flags = RTL_QUERY_REGISTRY_SUBKEY;
498			ParamTable[1].Name = Linkage;
499
500			// Get the name of the mac driver we should bind to
501			ParamTable[2].QueryRoutine = PacketQueryRegistryRoutine;
502			ParamTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED \| RTL_QUERY_REGISTRY_NOEXPAND;
503
504			ParamTable[2].Name = Bind;
505			ParamTable[2].EntryContext = (PVOID)MacDriverName;
506			ParamTable[2].DefaultType = REG_MULTI_SZ;
507
508			// Get the name that we should use for the driver object
509			ParamTable[3].QueryRoutine = PacketQueryRegistryRoutine;
510			ParamTable[3].Flags = RTL_QUERY_REGISTRY_REQUIRED \| RTL_QUERY_REGISTRY_NOEXPAND;
511
512			ParamTable[3].Name = Export;
513			ParamTable[3].EntryContext = (PVOID)PacketDriverName;
514			ParamTable[3].DefaultType = REG_MULTI_SZ;
515
516			Status=RtlQueryRegistryValues(
517			RTL_REGISTRY_ABSOLUTE,
518			Path,
519			ParamTable,
520			NULL,
521			NULL
522			);
523
524			ExFreePool(Path);
525
526			return Status;
527			}
528
529
530			NTSTATUS PacketQueryRegistryRoutine(
531			IN PWSTR ValueName,
532			IN ULONG ValueType,
533			IN PVOID ValueData,
534			IN ULONG ValueLength,
535			IN PVOID Context,
536			IN PVOID EntryContext
537			)
538
539			{
540			PUCHAR Buffer;
541
542			IF_LOUD(DbgPrint("Perf: QueryRegistryRoutine\n");)
543
544			if (ValueType != REG_MULTI_SZ) {
545			return STATUS_OBJECT_NAME_NOT_FOUND;
546			}
547
548			Buffer=ExAllocatePool(NonPagedPool,ValueLength);
549			if(!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
550
551			RtlCopyMemory( Buffer, ValueData, ValueLength );
552
553			((PUCHAR )EntryContext)=Buffer;
554
555			return STATUS_SUCCESS;
556			}