2521 lines
72 KiB
C
2521 lines
72 KiB
C
/*++
|
|
|
|
Copyright(c) 1999-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
brdgmini.c
|
|
|
|
Abstract:
|
|
|
|
Ethernet MAC level bridge.
|
|
Miniport section
|
|
|
|
Author:
|
|
|
|
Mark Aiken
|
|
(original bridge by Jameel Hyder)
|
|
|
|
Environment:
|
|
|
|
Kernel mode driver
|
|
|
|
Revision History:
|
|
|
|
Sept 1999 - Original version
|
|
Feb 2000 - Overhaul
|
|
|
|
--*/
|
|
|
|
#define NDIS_MINIPORT_DRIVER
|
|
#define NDIS50_MINIPORT 1
|
|
#define NDIS_WDM 1
|
|
|
|
#pragma warning( push, 3 )
|
|
#include <ndis.h>
|
|
#pragma warning( pop )
|
|
|
|
#include <netevent.h>
|
|
|
|
#include "bridge.h"
|
|
#include "brdgmini.h"
|
|
#include "brdgfwd.h"
|
|
#include "brdgprot.h"
|
|
#include "brdgbuf.h"
|
|
#include "brdgsta.h"
|
|
#include "brdgcomp.h"
|
|
|
|
// ===========================================================================
|
|
//
|
|
// GLOBALS
|
|
//
|
|
// ===========================================================================
|
|
|
|
// NDIS Wrapper handle
|
|
NDIS_HANDLE gNDISWrapperHandle = NULL;
|
|
|
|
// Handle to our miniport driver
|
|
NDIS_HANDLE gMiniPortDriverHandle = NULL;
|
|
|
|
// ----------------------------------------------
|
|
// The handle of the miniport (NULL if not initialized)
|
|
NDIS_HANDLE gMiniPortAdapterHandle = NULL;
|
|
|
|
// Refcount to allow waiting for other code to finish using the miniport
|
|
WAIT_REFCOUNT gMiniPortAdapterRefcount;
|
|
|
|
// Refcount indicating whether the bridge miniport is media-connected
|
|
WAIT_REFCOUNT gMiniPortConnectedRefcount;
|
|
|
|
// Refcount indicating whether the bridge miniport is in the middle of a media
|
|
// state toggle.
|
|
WAIT_REFCOUNT gMiniPortToggleRefcount;
|
|
// ----------------------------------------------
|
|
//
|
|
// Refcount for use in passing through requests to underlying NICs
|
|
// This works because NDIS doesn't make requests re-entrantly. That
|
|
// is, only one SetInfo operation can be pending at any given time.
|
|
//
|
|
LONG gRequestRefCount;
|
|
// ----------------------------------------------
|
|
// Virtual characteristics of the bridge adapter
|
|
ULONG gBridgeLinkSpeed = 10000L, // Start at 1Mbps, since reporting
|
|
// zero makes some components unhappy.
|
|
// Measured in 100's of bps.
|
|
gBridgeMediaState = NdisMediaStateDisconnected;
|
|
|
|
// MAC Address of the bridge. This does not change once
|
|
// it has been set.
|
|
UCHAR gBridgeAddress[ETH_LENGTH_OF_ADDRESS];
|
|
|
|
// Whether we have chosen an address yet
|
|
BOOLEAN gHaveAddress;
|
|
|
|
// Current bridge packet filter
|
|
ULONG gPacketFilter = 0L;
|
|
|
|
// Current multicast list
|
|
PUCHAR gMulticastList = NULL;
|
|
ULONG gMulticastListLength = 0L;
|
|
|
|
// Device name of the bridge miniport (from the registry)
|
|
PWCHAR gBridgeDeviceName = NULL;
|
|
ULONG gBridgeDeviceNameSize = 0L;
|
|
|
|
// RW lock to protect all above bridge variables
|
|
NDIS_RW_LOCK gBridgeStateLock;
|
|
//-----------------------------------------------
|
|
// Name of the registry entry for the device name
|
|
const PWCHAR gDeviceNameEntry = L"Device";
|
|
|
|
// Description of our miniport
|
|
const PCHAR gDriverDescription = "Microsoft MAC Bridge Virtual NIC";
|
|
// ----------------------------------------------
|
|
// Device object so user-mode code can talk to us
|
|
PDEVICE_OBJECT gDeviceObject = NULL;
|
|
|
|
// NDIS handle to track the device object
|
|
NDIS_HANDLE gDeviceHandle = NULL;
|
|
// ----------------------------------------------
|
|
|
|
// List of supported OIDs
|
|
NDIS_OID gSupportedOIDs[] =
|
|
{
|
|
// General characteristics
|
|
OID_GEN_SUPPORTED_LIST,
|
|
OID_GEN_HARDWARE_STATUS,
|
|
OID_GEN_MEDIA_SUPPORTED,
|
|
OID_GEN_MEDIA_IN_USE,
|
|
OID_GEN_MAXIMUM_LOOKAHEAD,
|
|
OID_GEN_MAXIMUM_FRAME_SIZE,
|
|
OID_GEN_LINK_SPEED,
|
|
OID_GEN_TRANSMIT_BUFFER_SPACE,
|
|
OID_GEN_RECEIVE_BUFFER_SPACE,
|
|
OID_GEN_TRANSMIT_BLOCK_SIZE,
|
|
OID_GEN_RECEIVE_BLOCK_SIZE,
|
|
OID_GEN_VENDOR_ID,
|
|
OID_GEN_VENDOR_DESCRIPTION,
|
|
OID_GEN_CURRENT_PACKET_FILTER,
|
|
OID_GEN_CURRENT_LOOKAHEAD,
|
|
OID_GEN_DRIVER_VERSION,
|
|
OID_GEN_MAXIMUM_TOTAL_SIZE,
|
|
OID_GEN_PROTOCOL_OPTIONS,
|
|
OID_GEN_MAC_OPTIONS,
|
|
OID_GEN_MEDIA_CONNECT_STATUS,
|
|
OID_GEN_MAXIMUM_SEND_PACKETS,
|
|
OID_GEN_VENDOR_DRIVER_VERSION,
|
|
|
|
// Set only characteristics (relayed)
|
|
OID_GEN_NETWORK_LAYER_ADDRESSES,
|
|
OID_GEN_TRANSPORT_HEADER_OFFSET,
|
|
|
|
// General statistics
|
|
OID_GEN_XMIT_OK,
|
|
OID_GEN_RCV_OK,
|
|
OID_GEN_XMIT_ERROR,
|
|
OID_GEN_RCV_NO_BUFFER,
|
|
OID_GEN_RCV_NO_BUFFER,
|
|
OID_GEN_DIRECTED_BYTES_XMIT,
|
|
OID_GEN_DIRECTED_FRAMES_XMIT,
|
|
OID_GEN_MULTICAST_BYTES_XMIT,
|
|
OID_GEN_MULTICAST_FRAMES_XMIT,
|
|
OID_GEN_BROADCAST_BYTES_XMIT,
|
|
OID_GEN_BROADCAST_FRAMES_XMIT,
|
|
OID_GEN_DIRECTED_BYTES_RCV,
|
|
OID_GEN_DIRECTED_FRAMES_RCV,
|
|
OID_GEN_MULTICAST_BYTES_RCV,
|
|
OID_GEN_MULTICAST_FRAMES_RCV,
|
|
OID_GEN_BROADCAST_BYTES_RCV,
|
|
OID_GEN_BROADCAST_FRAMES_RCV,
|
|
|
|
// Ethernet characteristics
|
|
OID_802_3_PERMANENT_ADDRESS,
|
|
OID_802_3_CURRENT_ADDRESS,
|
|
OID_802_3_MULTICAST_LIST,
|
|
OID_802_3_MAXIMUM_LIST_SIZE,
|
|
|
|
// Ethernet statistics
|
|
OID_802_3_RCV_ERROR_ALIGNMENT,
|
|
OID_802_3_XMIT_ONE_COLLISION,
|
|
OID_802_3_XMIT_MORE_COLLISIONS,
|
|
|
|
// PnP OIDs
|
|
OID_PNP_QUERY_POWER,
|
|
OID_PNP_SET_POWER,
|
|
|
|
// tcp oids
|
|
OID_TCP_TASK_OFFLOAD
|
|
|
|
};
|
|
|
|
|
|
|
|
// 1394 specific related global variables
|
|
#define OID_1394_ENTER_BRIDGE_MODE 0xFF00C914
|
|
#define OID_1394_EXIT_BRIDGE_MODE 0xFF00C915
|
|
|
|
// Set when the bridge knows that tcpip has been loaded
|
|
// set on receiving the OID_TCP_TASK_OFFLOAD Oid
|
|
BOOLEAN g_fIsTcpIpLoaded = FALSE;
|
|
|
|
|
|
// ===========================================================================
|
|
//
|
|
// PRIVATE PROTOTYPES
|
|
//
|
|
// ===========================================================================
|
|
|
|
VOID
|
|
BrdgMiniHalt(
|
|
IN NDIS_HANDLE MiniportAdapterContext
|
|
);
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniInitialize(
|
|
OUT PNDIS_STATUS OpenErrorStatus,
|
|
OUT PUINT SelectedMediumIndex,
|
|
IN PNDIS_MEDIUM MediumArray,
|
|
IN UINT MediumArraySize,
|
|
IN NDIS_HANDLE MiniportAdapterHandle,
|
|
IN NDIS_HANDLE WrapperConfigurationContext
|
|
);
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniQueryInfo(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN NDIS_OID Oid,
|
|
IN PVOID InformationBuffer,
|
|
IN ULONG InformationBufferLength,
|
|
OUT PULONG BytesWritten,
|
|
OUT PULONG BytesNeeded
|
|
);
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniReset(
|
|
OUT PBOOLEAN AddressingReset,
|
|
IN NDIS_HANDLE MiniportAdapterContext
|
|
);
|
|
|
|
VOID
|
|
BrdgMiniSendPackets(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN PPNDIS_PACKET PacketArray,
|
|
IN UINT NumberOfPackets
|
|
);
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniSetInfo(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN NDIS_OID Oid,
|
|
IN PVOID InformationBuffer,
|
|
IN ULONG InformationBufferLength,
|
|
OUT PULONG BytesRead,
|
|
OUT PULONG BytesNeeded
|
|
);
|
|
|
|
BOOLEAN
|
|
BrdgMiniAddrIsInMultiList(
|
|
IN PUCHAR pTargetAddr
|
|
);
|
|
|
|
VOID
|
|
BrdgMiniRelayedRequestComplete(
|
|
PNDIS_REQUEST_BETTER pRequest,
|
|
PVOID unused
|
|
);
|
|
|
|
VOID
|
|
BrdgMiniReAcquireMiniport();
|
|
|
|
// ===========================================================================
|
|
//
|
|
// PUBLIC FUNCTIONS
|
|
//
|
|
// ===========================================================================
|
|
|
|
|
|
NTSTATUS
|
|
BrdgMiniDriverInit()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Load-time initialization function
|
|
|
|
Must run at PASSIVE_LEVEL since we call NdisRegisterDevice().
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
Status of initialization. A return code != STATUS_SUCCESS causes driver load
|
|
to fail. Any event causing a failure return code must be logged, as it
|
|
prevents us from loading successfully.
|
|
|
|
--*/
|
|
{
|
|
NDIS_MINIPORT_CHARACTERISTICS MiniPortChars;
|
|
NDIS_STATUS NdisStatus;
|
|
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
|
|
NDIS_STRING DeviceName, LinkName;
|
|
|
|
SAFEASSERT(CURRENT_IRQL == PASSIVE_LEVEL);
|
|
|
|
NdisInitializeReadWriteLock( &gBridgeStateLock );
|
|
BrdgInitializeWaitRef( &gMiniPortAdapterRefcount, FALSE );
|
|
BrdgInitializeWaitRef( &gMiniPortConnectedRefcount, TRUE );
|
|
BrdgInitializeWaitRef( &gMiniPortToggleRefcount, FALSE );
|
|
|
|
// Put the miniport refcount into shutdown mode (so a refcount can't be acquired)
|
|
// since we don't have a miniport yet
|
|
BrdgShutdownWaitRefOnce( &gMiniPortAdapterRefcount );
|
|
|
|
// We start out disconnected so shutdown the media-connect waitref too.
|
|
BrdgShutdownWaitRefOnce( &gMiniPortConnectedRefcount );
|
|
|
|
NdisInitUnicodeString( &DeviceName, DEVICE_NAME );
|
|
NdisInitUnicodeString( &LinkName, SYMBOLIC_NAME );
|
|
|
|
// Must first tell NDIS we're a miniport driver and initializing
|
|
NdisMInitializeWrapper( &gNDISWrapperHandle, gDriverObject, &gRegistryPath, NULL );
|
|
|
|
// Fill in the description of our miniport
|
|
NdisZeroMemory(&MiniPortChars, sizeof(MiniPortChars));
|
|
MiniPortChars.MajorNdisVersion = 5;
|
|
MiniPortChars.MinorNdisVersion = 0;
|
|
|
|
MiniPortChars.HaltHandler = BrdgMiniHalt;
|
|
MiniPortChars.InitializeHandler = BrdgMiniInitialize;
|
|
MiniPortChars.QueryInformationHandler = BrdgMiniQueryInfo;
|
|
MiniPortChars.ResetHandler = BrdgMiniReset;
|
|
MiniPortChars.SendPacketsHandler = BrdgMiniSendPackets;
|
|
MiniPortChars.SetInformationHandler = BrdgMiniSetInfo;
|
|
|
|
//
|
|
// Wire the ReturnPacketHandler straight into the forwarding engine
|
|
//
|
|
MiniPortChars.ReturnPacketHandler = BrdgFwdReturnIndicatedPacket;
|
|
|
|
// Create a virtual NIC
|
|
NdisStatus = NdisIMRegisterLayeredMiniport( gNDISWrapperHandle, &MiniPortChars, sizeof(MiniPortChars),
|
|
&gMiniPortDriverHandle );
|
|
|
|
|
|
if (NdisStatus != NDIS_STATUS_SUCCESS)
|
|
{
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_MINIPORT_REGISTER_FAILED, 0, 0, NULL,
|
|
sizeof(NDIS_STATUS), &NdisStatus );
|
|
DBGPRINT(MINI, ("Failed to create an NDIS virtual NIC: %08x\n", NdisStatus));
|
|
NdisTerminateWrapper( gNDISWrapperHandle, NULL );
|
|
return NdisStatus;
|
|
}
|
|
|
|
//
|
|
// Initialize Dispatch Table array before setting selected members
|
|
//
|
|
NdisZeroMemory( DispatchTable, sizeof( DispatchTable ) );
|
|
|
|
//
|
|
// Register a device object and symbolic link so user-mode code can talk to us
|
|
//
|
|
DispatchTable[IRP_MJ_CREATE] = BrdgDispatchRequest;
|
|
DispatchTable[IRP_MJ_CLEANUP] = BrdgDispatchRequest;
|
|
DispatchTable[IRP_MJ_CLOSE] = BrdgDispatchRequest;
|
|
DispatchTable[IRP_MJ_DEVICE_CONTROL] = BrdgDispatchRequest;
|
|
|
|
NdisStatus = NdisMRegisterDevice( gNDISWrapperHandle, &DeviceName, &LinkName, DispatchTable,
|
|
&gDeviceObject, &gDeviceHandle );
|
|
|
|
if( NdisStatus != NDIS_STATUS_SUCCESS )
|
|
{
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_DEVICE_CREATION_FAILED, 0, 0, NULL,
|
|
sizeof(NDIS_STATUS), &NdisStatus );
|
|
DBGPRINT(MINI, ("Failed to create a device object and sym link: %08x\n", NdisStatus));
|
|
NdisIMDeregisterLayeredMiniport( gMiniPortDriverHandle );
|
|
NdisTerminateWrapper( gNDISWrapperHandle, NULL );
|
|
return NdisStatus;
|
|
}
|
|
|
|
// Register the unload function
|
|
NdisMRegisterUnloadHandler(gNDISWrapperHandle, BrdgUnload);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniCleanup()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Unload-time orderly shutdown function
|
|
|
|
This function is guaranteed to be called exactly once
|
|
|
|
Must run at PASSIVE_LEVEL since we call NdisIMDeInitializeDeviceInstance
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NDIS_STATUS NdisStatus;
|
|
|
|
SAFEASSERT(CURRENT_IRQL == PASSIVE_LEVEL);
|
|
|
|
DBGPRINT(MINI, ("BrdgMiniCleanup\n"));
|
|
|
|
if( gMiniPortAdapterHandle != NULL )
|
|
{
|
|
SAFEASSERT( gNDISWrapperHandle != NULL );
|
|
|
|
// This should cause a call to BrdgMiniHalt where gMiniPortAdapterHandle
|
|
// is NULLed out
|
|
|
|
NdisStatus = NdisIMDeInitializeDeviceInstance( gMiniPortAdapterHandle );
|
|
SAFEASSERT( NdisStatus == NDIS_STATUS_SUCCESS );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Tear down our device object. This is normally done when the miniport
|
|
// shuts down, but in scenarios where the miniport was never created,
|
|
// the device object still exists at this point.
|
|
//
|
|
NDIS_HANDLE Scratch = gDeviceHandle;
|
|
|
|
if( Scratch != NULL )
|
|
{
|
|
// Tear down the device object
|
|
gDeviceHandle = gDeviceObject = NULL;
|
|
NdisMDeregisterDevice( Scratch );
|
|
}
|
|
}
|
|
|
|
// Unregister ourselves as an intermediate driver
|
|
NdisIMDeregisterLayeredMiniport( gMiniPortDriverHandle );
|
|
}
|
|
|
|
BOOLEAN
|
|
BrdgMiniIsBridgeDeviceName(
|
|
IN PNDIS_STRING pDeviceName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Compares a device name to the current device name of the bridge miniport.
|
|
|
|
This actually requires that we allocate memory, so it should be called sparingly.
|
|
|
|
Arguments:
|
|
|
|
pDeviceName The name of a device
|
|
|
|
Return Value:
|
|
|
|
TRUE if the names match (case is ignored), FALSE otherwise.
|
|
|
|
--*/
|
|
{
|
|
LOCK_STATE LockState;
|
|
BOOLEAN rc = FALSE;
|
|
NDIS_STATUS Status;
|
|
ULONG BridgeNameCopySize = 0L;
|
|
PWCHAR pBridgeNameCopy = NULL;
|
|
|
|
// The bridge device name must be read inside the gBridgeStateLock
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE/*Read access*/, &LockState );
|
|
|
|
if( gBridgeDeviceName != NULL )
|
|
{
|
|
if( gBridgeDeviceNameSize > 0 )
|
|
{
|
|
// Alloc memory for the copy of the name
|
|
Status = NdisAllocateMemoryWithTag( &pBridgeNameCopy, gBridgeDeviceNameSize, 'gdrB' );
|
|
|
|
if( Status == NDIS_STATUS_SUCCESS )
|
|
{
|
|
// Copy the name
|
|
NdisMoveMemory( pBridgeNameCopy, gBridgeDeviceName, gBridgeDeviceNameSize );
|
|
BridgeNameCopySize = gBridgeDeviceNameSize;
|
|
}
|
|
else
|
|
{
|
|
SAFEASSERT( pBridgeNameCopy == NULL );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SAFEASSERT( FALSE );
|
|
}
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
if( pBridgeNameCopy != NULL )
|
|
{
|
|
NDIS_STRING NdisStr;
|
|
|
|
NdisInitUnicodeString( &NdisStr, pBridgeNameCopy );
|
|
|
|
if( NdisEqualString( &NdisStr, pDeviceName, TRUE/*Ignore case*/ ) )
|
|
{
|
|
rc = TRUE;
|
|
}
|
|
|
|
NdisFreeMemory( pBridgeNameCopy, BridgeNameCopySize, 0 );
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniInstantiateMiniport()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Instantiates the virtual NIC we expose to overlying protocols.
|
|
|
|
At least one adapter must be in the global adapter list, since we build
|
|
our MAC address with the MAC address of the first bound adapter.
|
|
|
|
Must run at < DISPATCH_LEVEL since we call NdisIMInitializeDeviceInstanceEx
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NDIS_STATUS Status;
|
|
NTSTATUS NtStatus;
|
|
NDIS_STRING NdisString;
|
|
LOCK_STATE LockState;
|
|
PWCHAR pDeviceName;
|
|
ULONG DeviceNameSize;
|
|
|
|
SAFEASSERT(CURRENT_IRQL < DISPATCH_LEVEL);
|
|
|
|
DBGPRINT(MINI, ("About to instantiate the miniport...\n"));
|
|
|
|
//
|
|
// Retrieve our device name from the registry
|
|
// (it is written there by our notify object during install)
|
|
//
|
|
NtStatus = BrdgReadRegUnicode( &gRegistryPath, gDeviceNameEntry, &pDeviceName, &DeviceNameSize );
|
|
|
|
if( NtStatus != STATUS_SUCCESS )
|
|
{
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_MINIPROT_DEVNAME_MISSING, 0, 0, NULL,
|
|
sizeof(NTSTATUS), &NtStatus );
|
|
DBGPRINT(MINI, ("Failed to retrieve the miniport's device name: %08x\n", NtStatus));
|
|
return;
|
|
}
|
|
|
|
SAFEASSERT( pDeviceName != NULL );
|
|
DBGPRINT(MINI, ("Initializing miniport with device name %ws\n", pDeviceName));
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE/*Write access*/, &LockState );
|
|
|
|
if( ! gHaveAddress )
|
|
{
|
|
// We don't have a MAC address yet. This is fatal.
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_NO_BRIDGE_MAC_ADDR, 0L, 0L, NULL,
|
|
sizeof(NDIS_STATUS), &Status );
|
|
DBGPRINT(MINI, ("Failed to determine a MAC address: %08x\n", Status));
|
|
NdisFreeMemory( pDeviceName, DeviceNameSize, 0 );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Save the device name in our global for use until we reinitialize.
|
|
// Must do this before calling NdisIMInitializeDeviceInstanceEx, since NDIS calls
|
|
// BrdgProtBindAdapter in the context of our call to NdisIMInitializeDeviceInstanceEx
|
|
// and we want to consult the bridge's device name when binding
|
|
//
|
|
|
|
if( gBridgeDeviceName != NULL )
|
|
{
|
|
// Free the old name
|
|
NdisFreeMemory( gBridgeDeviceName, gBridgeDeviceNameSize, 0 );
|
|
}
|
|
|
|
gBridgeDeviceName = pDeviceName;
|
|
gBridgeDeviceNameSize = DeviceNameSize;
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
// Go ahead and intantiate the miniport.
|
|
NdisInitUnicodeString( &NdisString, pDeviceName );
|
|
Status = NdisIMInitializeDeviceInstanceEx(gMiniPortDriverHandle, &NdisString, NULL);
|
|
|
|
if( Status != NDIS_STATUS_SUCCESS )
|
|
{
|
|
// Log this error since it means we can't create the miniport
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_MINIPORT_INIT_FAILED, 0L, 0L, NULL,
|
|
sizeof(NDIS_STATUS), &Status );
|
|
|
|
DBGPRINT(MINI, ("NdisIMInitializeDeviceInstanceEx failed: %08x\n", Status));
|
|
|
|
// Destroy the stored device name for the miniport
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE/*Write access*/, &LockState );
|
|
|
|
if( gBridgeDeviceName != NULL )
|
|
{
|
|
// Free the old name
|
|
NdisFreeMemory( gBridgeDeviceName, gBridgeDeviceNameSize, 0 );
|
|
}
|
|
|
|
gBridgeDeviceName = NULL;
|
|
gBridgeDeviceNameSize = 0L;
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
BrdgMiniShouldIndicatePacket(
|
|
IN PUCHAR pTargetAddr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines whether an inbound packet should be indicated to overlying protocols through
|
|
our virtual NIC
|
|
|
|
Arguments:
|
|
|
|
pTargetAddr The target MAC address of a packet
|
|
|
|
Return Value:
|
|
|
|
TRUE : The packet should be indicated
|
|
FALSE : The packet should not be indicated
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN bIsBroadcast, bIsMulticast, bIsLocalUnicast, rc = FALSE;
|
|
LOCK_STATE LockState;
|
|
|
|
if( gMiniPortAdapterHandle == NULL )
|
|
{
|
|
// Yikes! The miniport isn't set up yet. Definitely don't indicate!
|
|
return FALSE;
|
|
}
|
|
|
|
bIsBroadcast = ETH_IS_BROADCAST(pTargetAddr);
|
|
bIsMulticast = ETH_IS_MULTICAST(pTargetAddr);
|
|
bIsLocalUnicast = BrdgMiniIsUnicastToBridge(pTargetAddr);
|
|
|
|
// Get read access to the packet filter
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read-only*/, &LockState );
|
|
|
|
do
|
|
{
|
|
// Promiscuous / ALL_LOCAL means indicate everything
|
|
if( (gPacketFilter & (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_ALL_LOCAL)) != 0 )
|
|
{
|
|
rc = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( ((gPacketFilter & NDIS_PACKET_TYPE_BROADCAST) != 0) && bIsBroadcast )
|
|
{
|
|
rc = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( ((gPacketFilter & NDIS_PACKET_TYPE_DIRECTED) != 0) && bIsLocalUnicast )
|
|
{
|
|
rc = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( bIsMulticast )
|
|
{
|
|
if( (gPacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST) != 0 )
|
|
{
|
|
rc = TRUE;
|
|
break;
|
|
}
|
|
else if( (gPacketFilter & NDIS_PACKET_TYPE_MULTICAST) != 0 )
|
|
{
|
|
|
|
rc = BrdgMiniAddrIsInMultiList( pTargetAddr );
|
|
}
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
return rc;
|
|
}
|
|
|
|
BOOLEAN
|
|
BrdgMiniIsUnicastToBridge (
|
|
IN PUCHAR Address
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines whether a given packet is a directed packet unicast straight to
|
|
the bridge's host machine
|
|
|
|
Arguments:
|
|
|
|
Address The target MAC address of a packet
|
|
|
|
Return Value:
|
|
|
|
TRUE : This is a directed packet destined for the local machine
|
|
FALSE : The above is not true
|
|
|
|
--*/
|
|
{
|
|
UINT Result;
|
|
|
|
if( gHaveAddress )
|
|
{
|
|
// Not necessary to acquire a lock to read gBridgeAddress since it cannot
|
|
// change once it is set.
|
|
ETH_COMPARE_NETWORK_ADDRESSES_EQ( Address, gBridgeAddress, &Result );
|
|
}
|
|
else
|
|
{
|
|
// We have no MAC address, so this can't be addressed to us!
|
|
Result = 1; // Inequality
|
|
}
|
|
|
|
return (BOOLEAN)(Result == 0); // Zero is equality
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniAssociate()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Associates our miniport with our protocol
|
|
|
|
Must run at PASSIVE_LEVEL
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
SAFEASSERT(CURRENT_IRQL == PASSIVE_LEVEL);
|
|
|
|
// Associate ourselves with the protocol section in NDIS's tortured mind
|
|
NdisIMAssociateMiniport( gMiniPortDriverHandle, gProtHandle );
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniDeferredMediaDisconnect(
|
|
IN PVOID arg
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Signals a media-disconnect to NDIS
|
|
|
|
Must run at PASSIVE IRQL, since we have to wait for all packet indications
|
|
to complete before indicating media-disconnect.
|
|
|
|
Arguments:
|
|
|
|
arg The bridge miniport handle (must be released)
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NDIS_HANDLE MiniportHandle = (NDIS_HANDLE)arg;
|
|
|
|
if( BrdgShutdownBlockedWaitRef(&gMiniPortConnectedRefcount) )
|
|
{
|
|
// Nobody can indicate packets anymore.
|
|
|
|
LOCK_STATE LockState;
|
|
|
|
//
|
|
// Close a timing window: we may have just gone media-connect but our high-IRQL
|
|
// processing may not yet have reset the wait-refcount. Serialize here so it's
|
|
// impossible for us to signal a disconnect to NDIS after we have actually
|
|
// gone media-connect.
|
|
//
|
|
// This RELIES on high-IRQL processing acquiring gBridgeStateLock to set
|
|
// gBridgeMediaState to NdisMediaStateConnected BEFORE signalling the
|
|
// media-connected state to NDIS.
|
|
//
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read access*/, &LockState );
|
|
|
|
if( gBridgeMediaState == NdisMediaStateDisconnected )
|
|
{
|
|
DBGPRINT(MINI, ("Signalled media-disconnect from deferred function\n"));
|
|
NdisMIndicateStatus( MiniportHandle, NDIS_STATUS_MEDIA_DISCONNECT, NULL, 0L );
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(MINI, ("Aborted deferred media-disconnect: media state inconsistent\n"));
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
}
|
|
else
|
|
{
|
|
// Someone set us back to the connected state before we got executed
|
|
DBGPRINT(MINI, ("Aborted deferred media-disconnect: wait-ref reset\n"));
|
|
}
|
|
|
|
BrdgMiniReleaseMiniport();
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniDeferredMediaToggle(
|
|
IN PVOID arg
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Signals a media-disconnect to NDIS followed quickly by a media-connect. Used
|
|
to indicate to upper-layer protocols like TCPIP that the bridge may have
|
|
disconnected from a network segment it could previously reach, or that we may
|
|
now be able to reach a network segment that we couldn't before.
|
|
|
|
Must run at PASSIVE IRQL, since we have to wait for all packet indications
|
|
to complete before indicating media-disconnect.
|
|
|
|
Arguments:
|
|
|
|
arg The bridge miniport handle (must be released)
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NDIS_HANDLE MiniportHandle = (NDIS_HANDLE)arg;
|
|
|
|
// We need a guarantee that the miniport is media-connect to be able to do
|
|
// the toggle properly.
|
|
if( BrdgIncrementWaitRef(&gMiniPortConnectedRefcount) )
|
|
{
|
|
// Stop people from indicating packets
|
|
if( BrdgShutdownWaitRef(&gMiniPortToggleRefcount) )
|
|
{
|
|
DBGPRINT(MINI, ("Doing deferred media toggle\n"));
|
|
|
|
// Toggle our media state with NDIS
|
|
NdisMIndicateStatus( MiniportHandle, NDIS_STATUS_MEDIA_DISCONNECT, NULL, 0L );
|
|
NdisMIndicateStatus( MiniportHandle, NDIS_STATUS_MEDIA_CONNECT, NULL, 0L );
|
|
|
|
// Allow people to indicate packets again
|
|
BrdgResetWaitRef( &gMiniPortToggleRefcount );
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(MINI, ("Multiple toggles in progress simultaneously\n"));
|
|
}
|
|
|
|
BrdgDecrementWaitRef( &gMiniPortConnectedRefcount );
|
|
}
|
|
// else the miniport isn't media-connect, so the toggle makes no sense.
|
|
|
|
BrdgMiniReleaseMiniport();
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniUpdateCharacteristics(
|
|
IN BOOLEAN bConnectivityChange
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Recalculates the link speed and media status (connected / disconnected) that
|
|
our virtual NIC exposes to overlying protocols
|
|
|
|
Arguments:
|
|
|
|
bConnectivityChange Whether the change that prompted this call is a change
|
|
in connectivity (i.e., we acquired or lost an adapter).
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
LOCK_STATE LockState, ListLockState, AdaptersLockState;
|
|
PADAPT pAdapt;
|
|
ULONG MediaState = NdisMediaStateDisconnected;
|
|
ULONG FastestSpeed = 0L;
|
|
BOOLEAN UpdateSpeed = FALSE, UpdateMediaState = FALSE;
|
|
NDIS_HANDLE MiniportHandle;
|
|
|
|
// Need to read the adapter list and also have the adapters' characteristics not change
|
|
NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*Read-only*/, &ListLockState );
|
|
NdisAcquireReadWriteLock( &gAdapterCharacteristicsLock, FALSE /*Read-only*/, &AdaptersLockState );
|
|
|
|
pAdapt = gAdapterList;
|
|
|
|
while( pAdapt != NULL )
|
|
{
|
|
// An adapter must be connected and actively handling packets to change our
|
|
// virtual media state.
|
|
if( (pAdapt->MediaState == NdisMediaStateConnected) && (pAdapt->State == Forwarding) )
|
|
{
|
|
// We're connected if at least one NIC is connected
|
|
MediaState = NdisMediaStateConnected;
|
|
|
|
// The NIC must be connected for us to consider its speed
|
|
if( pAdapt->LinkSpeed > FastestSpeed )
|
|
{
|
|
FastestSpeed = pAdapt->LinkSpeed;
|
|
}
|
|
}
|
|
|
|
pAdapt = pAdapt->Next;
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gAdapterCharacteristicsLock, &AdaptersLockState );
|
|
NdisReleaseReadWriteLock( &gAdapterListLock, &ListLockState );
|
|
|
|
// Update the characteristics
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE /*Write access*/, &LockState );
|
|
|
|
//
|
|
// Only update our virtual link speed if we actually got at least one real speed
|
|
// from our NICs. If everything is disconnected, the resulting FastestSpeed is
|
|
// zero. In this case, we don't want to actually report a zero speed up to
|
|
// overlying protocols; we stick at the last known speed until someone reconnects.
|
|
//
|
|
if( (gBridgeLinkSpeed != FastestSpeed) && (FastestSpeed != 0L) )
|
|
{
|
|
UpdateSpeed = TRUE;
|
|
gBridgeLinkSpeed = FastestSpeed;
|
|
DBGPRINT(MINI, ("Updated bridge speed to %iMbps\n", FastestSpeed / 10000));
|
|
}
|
|
|
|
if( gBridgeMediaState != MediaState )
|
|
{
|
|
UpdateMediaState = TRUE;
|
|
gBridgeMediaState = MediaState;
|
|
|
|
if( MediaState == NdisMediaStateConnected )
|
|
{
|
|
DBGPRINT(MINI, ("CONNECT\n"));
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(MINI, ("DISCONNECT\n"));
|
|
}
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
MiniportHandle = BrdgMiniAcquireMiniport();
|
|
|
|
if( MiniportHandle != NULL )
|
|
{
|
|
if( UpdateMediaState )
|
|
{
|
|
// Our link state has changed.
|
|
if( MediaState == NdisMediaStateConnected )
|
|
{
|
|
//
|
|
// Tell NDIS we will be indicating packets again.
|
|
//
|
|
// NOTE: BrdgMiniDeferredMediaDisconnect RELIES on us doing this after
|
|
// having updated gBridgeMediaState inside gBridgeStateLock so it can
|
|
// close the timing window between this call and the BrdgResetWaitRef() call.
|
|
//
|
|
NdisMIndicateStatus( MiniportHandle, NDIS_STATUS_MEDIA_CONNECT, NULL, 0L );
|
|
|
|
// Re-enable packet indication.
|
|
BrdgResetWaitRef( &gMiniPortConnectedRefcount );
|
|
}
|
|
else
|
|
{
|
|
SAFEASSERT( MediaState == NdisMediaStateDisconnected );
|
|
|
|
// Stop people from indicating packets
|
|
BrdgBlockWaitRef( &gMiniPortConnectedRefcount );
|
|
|
|
// We hand MiniportHandle to our deferred function
|
|
BrdgMiniReAcquireMiniport();
|
|
|
|
// Have to do the media-disconnect indication at PASSIVE level, since we must
|
|
// first wait for everyone to finish indicating packets.
|
|
if( BrdgDeferFunction( BrdgMiniDeferredMediaDisconnect, MiniportHandle ) != NDIS_STATUS_SUCCESS )
|
|
{
|
|
// Failed to defer the function. Avoid leaking a refcount
|
|
BrdgMiniReleaseMiniport();
|
|
}
|
|
}
|
|
}
|
|
else if( bConnectivityChange )
|
|
{
|
|
//
|
|
// There was no actual change to our media state. However, if the change that prompted this call
|
|
// is a connectivity change and our media state is currently CONNECTED, we toggle it to
|
|
// DISCONNECTED and back again to "hint" to upper-layer protocols like IP that the underlying
|
|
// network may have changed. For example, in IP's case, a DHCP server may have become visible
|
|
// (or a previously visible server may have disappeared) because of a connectivity change.
|
|
// The hint causes IP to look for a DHCP server afresh.
|
|
//
|
|
if( MediaState == NdisMediaStateConnected )
|
|
{
|
|
// We hand MiniportHandle to our deferred function
|
|
BrdgMiniReAcquireMiniport();
|
|
|
|
// Toggle has to be done at PASSIVE level.
|
|
if( BrdgDeferFunction( BrdgMiniDeferredMediaToggle, MiniportHandle ) != NDIS_STATUS_SUCCESS )
|
|
{
|
|
// Failed to defer the function. Avoid leaking a refcount
|
|
BrdgMiniReleaseMiniport();
|
|
}
|
|
}
|
|
}
|
|
|
|
if( UpdateSpeed )
|
|
{
|
|
// Tell overlying protocols that our speed has changed
|
|
NdisMIndicateStatus( MiniportHandle, NDIS_STATUS_LINK_SPEED_CHANGE, &FastestSpeed, sizeof(ULONG) );
|
|
}
|
|
|
|
BrdgMiniReleaseMiniport();
|
|
}
|
|
}
|
|
|
|
NDIS_HANDLE
|
|
BrdgMiniAcquireMiniportForIndicate()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Acquires the bridge miniport handle for the purpose of indicating packets.
|
|
In addition to guaranteeing that the miniport will exist until the caller calls
|
|
BrdgMiniReleaseMiniportForIndicate(), the caller is also allowed to indicate
|
|
packets using the returned miniport handle until the miniport is released.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
The NDIS handle for the virtual NIC. This can be used to indicate packets
|
|
until a reciprocal call to BrdgMiniReleaseMiniportForIndicate().
|
|
|
|
--*/
|
|
{
|
|
if( BrdgIncrementWaitRef(&gMiniPortAdapterRefcount) )
|
|
{
|
|
SAFEASSERT( gMiniPortAdapterHandle != NULL );
|
|
|
|
// The miniport needs to be media-connect to indicate packets.
|
|
if( BrdgIncrementWaitRef(&gMiniPortConnectedRefcount) )
|
|
{
|
|
// A media-state toggle had better not be in progress
|
|
if( BrdgIncrementWaitRef(&gMiniPortToggleRefcount) )
|
|
{
|
|
// Caller can use the miniport
|
|
return gMiniPortAdapterHandle;
|
|
}
|
|
// else miniport exists but is toggling its state
|
|
|
|
BrdgDecrementWaitRef( &gMiniPortConnectedRefcount );
|
|
}
|
|
// else miniport exists but is media-disconnected
|
|
|
|
BrdgDecrementWaitRef( &gMiniPortAdapterRefcount );
|
|
}
|
|
// else miniport does not exist.
|
|
|
|
return NULL;
|
|
}
|
|
|
|
NDIS_HANDLE
|
|
BrdgMiniAcquireMiniport()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Increments the miniport's refcount so it cannot be torn down until a corresponding
|
|
BrdgMiniReleaseMiniport() call is made.
|
|
|
|
The caller may NOT use the returned miniport handle to indicate packets, since the
|
|
miniport is not guaranteed to be in an appropriate state.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
The NDIS handle for the virtual NIC. This can be used safely until a reciprocal call
|
|
to BrdgMiniReleaseMiniport().
|
|
|
|
--*/
|
|
{
|
|
if( BrdgIncrementWaitRef(&gMiniPortAdapterRefcount) )
|
|
{
|
|
SAFEASSERT( gMiniPortAdapterHandle != NULL );
|
|
return gMiniPortAdapterHandle;
|
|
}
|
|
// else miniport does not exist.
|
|
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniReAcquireMiniport()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reacquires the miniport (caller must have previously called BrdgMiniAcquireMiniport()
|
|
and not yet called BrdgMiniReleaseMiniport().
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None. The caller should already be holding a handle for the miniport.
|
|
|
|
--*/
|
|
{
|
|
BrdgReincrementWaitRef(&gMiniPortAdapterRefcount);
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniReleaseMiniport()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Decrements the miniport's refcount. The caller should no longer use the handle
|
|
previously returned by BrdgMiniAcquireMiniport().
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
BrdgDecrementWaitRef( &gMiniPortAdapterRefcount );
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniReleaseMiniportForIndicate()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Decrements the miniport's refcount. The caller should no longer use the handle
|
|
previously returned by BrdgMiniAcquireMiniportForIndicate().
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
BrdgDecrementWaitRef( &gMiniPortToggleRefcount );
|
|
BrdgDecrementWaitRef( &gMiniPortConnectedRefcount );
|
|
BrdgDecrementWaitRef( &gMiniPortAdapterRefcount );
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
BrdgMiniReadMACAddress(
|
|
OUT PUCHAR pAddr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads the bridge miniport's MAC address.
|
|
|
|
Arguments:
|
|
|
|
Address of a buffer to receive the address
|
|
|
|
Return Value:
|
|
|
|
TRUE if the value was copied out successfully
|
|
FALSE if we don't yet have a MAC address (nothing was copied)
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN rc;
|
|
|
|
if( gHaveAddress )
|
|
{
|
|
// Not necessary to acquire a lock to read the address since
|
|
// it cannot change once it is set
|
|
ETH_COPY_NETWORK_ADDRESS( pAddr, gBridgeAddress );
|
|
rc = TRUE;
|
|
}
|
|
else
|
|
{
|
|
rc = FALSE;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
// ===========================================================================
|
|
//
|
|
// PRIVATE FUNCTIONS
|
|
//
|
|
// ===========================================================================
|
|
|
|
VOID
|
|
BrdgMiniInitFromAdapter(
|
|
IN PADAPT pAdapt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called by the protocol section to give us a chance to establish the bridge's
|
|
MAC address when a new adapter arrives. If we succeed in determining a MAC
|
|
address from the given adapter, we in turn call the STA module to tell it
|
|
our MAC address, which it needs as early as possible.
|
|
|
|
The MAC address of the bridge is set as the MAC address of the given adapter
|
|
with the "locally administered" bit set. This should (hopefully) make the
|
|
address unique in the local network as well as unique within our machine.
|
|
|
|
This function is called for every new adapter but we only need to initialize
|
|
once.
|
|
|
|
Arguments:
|
|
|
|
pAdapt An adapter to use to initialize
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
--*/
|
|
{
|
|
if( ! gHaveAddress )
|
|
{
|
|
LOCK_STATE LockState;
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE/*Write access*/, &LockState );
|
|
|
|
// Possible for the gHaveAddress flag to have changed before acquiring the lock
|
|
if( ! gHaveAddress )
|
|
{
|
|
// Copy out the NIC's MAC address
|
|
ETH_COPY_NETWORK_ADDRESS( gBridgeAddress, pAdapt->MACAddr );
|
|
|
|
//
|
|
// Set the second-least significant bit of the NIC's MAC address. This moves the address
|
|
// into the locally administered space.
|
|
//
|
|
gBridgeAddress[0] |= (UCHAR)0x02;
|
|
|
|
DBGPRINT(MINI, ("Using MAC Address %02x-%02x-%02x-%02x-%02x-%02x\n",
|
|
(UINT)gBridgeAddress[0], (UINT)gBridgeAddress[1], (UINT)gBridgeAddress[2],
|
|
(UINT)gBridgeAddress[3], (UINT)gBridgeAddress[4], (UINT)gBridgeAddress[5]));
|
|
|
|
gHaveAddress = TRUE;
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
if( !gDisableSTA )
|
|
{
|
|
// We are responsible for calling the STA module to complete its initialization once
|
|
// we know our MAC address.
|
|
BrdgSTADeferredInit( gBridgeAddress );
|
|
}
|
|
|
|
// We are also responsible for letting the compatibility-mode code know about our
|
|
// MAC address once it is set.
|
|
BrdgCompNotifyMACAddress( gBridgeAddress );
|
|
}
|
|
else
|
|
{
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
BrdgMiniAddrIsInMultiList(
|
|
IN PUCHAR pTargetAddr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines whether a given multicast address is in the list of addresses that
|
|
we must indicate to overlying protocols
|
|
|
|
The caller is responsible for synchronization; it must have AT LEAST a read lock on
|
|
gBridgeStateLock.
|
|
|
|
Arguments:
|
|
|
|
pTargetAddr The address to analyze
|
|
|
|
Return Value:
|
|
|
|
TRUE : This address is a multicast address that we have been asked
|
|
to indicate
|
|
|
|
FALSE : The above is not true
|
|
|
|
--*/
|
|
{
|
|
PUCHAR pCurAddr = gMulticastList;
|
|
ULONG i;
|
|
BOOLEAN rc = FALSE;
|
|
|
|
// The list must have an integral number of addresses!
|
|
SAFEASSERT( (gMulticastListLength % ETH_LENGTH_OF_ADDRESS) == 0 );
|
|
|
|
for( i = 0;
|
|
i < (gMulticastListLength / ETH_LENGTH_OF_ADDRESS);
|
|
i++, pCurAddr += ETH_LENGTH_OF_ADDRESS
|
|
)
|
|
{
|
|
UINT Result;
|
|
ETH_COMPARE_NETWORK_ADDRESSES_EQ( pTargetAddr, pCurAddr, &Result );
|
|
|
|
if( Result == 0 )
|
|
{
|
|
rc = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniHalt(
|
|
IN NDIS_HANDLE MiniportAdapterContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called when the virtual NIC is de-instantiated. We NULL out the miniport handle and
|
|
stall the tear-down until everyone is done using the miniport.
|
|
|
|
Must be called at PASSIVE_LEVEL since we wait on an event
|
|
|
|
Arguments:
|
|
|
|
MiniportAdapterContext Ignored
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NDIS_HANDLE Scratch = gDeviceHandle;
|
|
LOCK_STATE LockState;
|
|
|
|
SAFEASSERT(CURRENT_IRQL == PASSIVE_LEVEL);
|
|
|
|
DBGPRINT(MINI, ("BrdgMiniHalt\n"));
|
|
|
|
if( Scratch != NULL )
|
|
{
|
|
// Tear down the device object
|
|
gDeviceHandle = gDeviceObject = NULL;
|
|
NdisMDeregisterDevice( Scratch );
|
|
}
|
|
|
|
if( gMiniPortAdapterHandle != NULL )
|
|
{
|
|
// Stall before returning until everyone is done using the miniport handle.
|
|
// This also prevents people from acquiring the miniport handle.
|
|
BrdgShutdownWaitRefOnce( &gMiniPortAdapterRefcount );
|
|
gMiniPortAdapterHandle = NULL;
|
|
DBGPRINT(MINI, ("Done stall\n"));
|
|
}
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE/*Write access*/, &LockState );
|
|
|
|
if( gBridgeDeviceName != NULL )
|
|
{
|
|
NdisFreeMemory( gBridgeDeviceName, gBridgeDeviceNameSize, 0 );
|
|
gBridgeDeviceName = NULL;
|
|
gBridgeDeviceNameSize = 0L;
|
|
}
|
|
|
|
// Ditch our packet filter and multicast list
|
|
gPacketFilter = 0L;
|
|
|
|
if( gMulticastList != NULL )
|
|
{
|
|
SAFEASSERT( gMulticastListLength > 0L );
|
|
NdisFreeMemory( gMulticastList, gMulticastListLength, 0 );
|
|
gMulticastList = NULL;
|
|
gMulticastListLength = 0L;
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
}
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniInitialize(
|
|
OUT PNDIS_STATUS OpenErrorStatus,
|
|
OUT PUINT SelectedMediumIndex,
|
|
IN PNDIS_MEDIUM MediumArray,
|
|
IN UINT MediumArraySize,
|
|
IN NDIS_HANDLE MiniPortAdapterHandle,
|
|
IN NDIS_HANDLE WrapperConfigurationContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NDIS entry point called to initialize our virtual NIC following a call to
|
|
NdisIMInitializeDeviceInstance
|
|
|
|
Must run at PASSIVE_LEVEL since we call NdisMSetAttributesEx
|
|
|
|
Arguments:
|
|
|
|
OpenErrorStatus Where to return the specific error code if an open fails
|
|
SelectedMediumIndex Where to specify which media we selected from MediumArray
|
|
MediumArray A list of media types to choose from
|
|
MediumArraySize Number of entries in MediumArray
|
|
MiniPortAdapterHandle The handle for our virtual NIC (we save this)
|
|
WrapperConfigurationContext Not used
|
|
|
|
Return Value:
|
|
|
|
Status of the initialization. A result != NDIS_STATUS_SUCCESS fails the NIC initialization
|
|
and the miniport is not exposed to upper-layer protocols
|
|
|
|
--*/
|
|
{
|
|
UINT i;
|
|
|
|
SAFEASSERT(CURRENT_IRQL == PASSIVE_LEVEL);
|
|
DBGPRINT(MINI, ("BrdgMiniInitialize\n"));
|
|
|
|
for( i = 0; i < MediumArraySize; i++ )
|
|
{
|
|
if( MediumArray[i] == NdisMedium802_3 ) // Ethernet
|
|
{
|
|
*SelectedMediumIndex = NdisMedium802_3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( i == MediumArraySize )
|
|
{
|
|
// Log this error since it's fatal
|
|
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_ETHERNET_NOT_OFFERED, 0L, 0L, NULL, 0L, NULL );
|
|
DBGPRINT(MINI, ("Ethernet not offered; failing\n"));
|
|
return NDIS_STATUS_UNSUPPORTED_MEDIA;
|
|
}
|
|
|
|
NdisMSetAttributesEx( MiniPortAdapterHandle,
|
|
NULL,
|
|
0, // CheckForHangTimeInSeconds
|
|
NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT |
|
|
NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
|
|
NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
|
|
NDIS_ATTRIBUTE_DESERIALIZE |
|
|
NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
|
|
0);
|
|
|
|
// Save the adapter handle for future use
|
|
gMiniPortAdapterHandle = MiniPortAdapterHandle;
|
|
|
|
// Allow people to acquire the miniport
|
|
BrdgResetWaitRef( &gMiniPortAdapterRefcount );
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniReset(
|
|
OUT PBOOLEAN AddressingReset,
|
|
IN NDIS_HANDLE MiniportAdapterContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NDIS entry point called reset our miniport. We do nothing in response to this.
|
|
|
|
Arguments:
|
|
|
|
AddressingReset Whether NDIS needs to prod us some more by calling MiniportSetInformation
|
|
after we return to restore various pieces of state
|
|
|
|
MiniportAdapterContext Ignored
|
|
|
|
Return Value:
|
|
|
|
Status of the reset
|
|
|
|
--*/
|
|
{
|
|
DBGPRINT(MINI, ("BrdgMiniReset\n"));
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniSendPackets(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN PPNDIS_PACKET PacketArray,
|
|
IN UINT NumberOfPackets
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NDIS entry point called to send packets through our virtual NIC.
|
|
|
|
We just call the forwarding logic code to handle each packet.
|
|
|
|
Arguments:
|
|
|
|
MiniportAdapterContext Ignored
|
|
PacketArray Array of packet pointers to send
|
|
NumberOfPacket Like it says
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
UINT i;
|
|
NDIS_STATUS Status;
|
|
|
|
for (i = 0; i < NumberOfPackets; i++)
|
|
{
|
|
PNDIS_PACKET pPacket = PacketArray[i];
|
|
|
|
// Hand this packet to the forwarding engine for processing
|
|
Status = BrdgFwdSendPacket( pPacket );
|
|
|
|
if( Status != NDIS_STATUS_PENDING )
|
|
{
|
|
// The forwarding engine completed immediately
|
|
|
|
// NDIS should prevent the miniport from being shut down
|
|
// until we return from this function
|
|
SAFEASSERT( gMiniPortAdapterHandle != NULL );
|
|
NdisMSendComplete(gMiniPortAdapterHandle, pPacket, Status);
|
|
}
|
|
// else the forwarding engine will call NdisMSendComplete()
|
|
}
|
|
}
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniQueryInfo(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN NDIS_OID Oid,
|
|
IN PVOID InformationBuffer,
|
|
IN ULONG InformationBufferLength,
|
|
OUT PULONG BytesWritten,
|
|
OUT PULONG BytesNeeded
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NDIS entry point called to retrieve various pieces of info from our miniport
|
|
|
|
Arguments:
|
|
|
|
MiniportAdapterContext Ignored
|
|
Oid The request code
|
|
InformationBuffer Place to return information
|
|
InformationBufferLength Size of InformationBuffer
|
|
BytesWritten Output of the number of written bytes
|
|
BytesNeeded If the provided buffer is too small, this is how many we need.
|
|
|
|
Return Value:
|
|
|
|
Status of the request
|
|
|
|
--*/
|
|
{
|
|
// Macros for use in this function alone
|
|
#define REQUIRE_AT_LEAST(n) \
|
|
{ \
|
|
if(InformationBufferLength < (n)) \
|
|
{ \
|
|
*BytesNeeded = (n); \
|
|
return NDIS_STATUS_INVALID_LENGTH; \
|
|
}\
|
|
}
|
|
|
|
#define RETURN_BYTES(p,n) \
|
|
{ \
|
|
NdisMoveMemory( InformationBuffer, (p), (n) ); \
|
|
*BytesWritten = (n); \
|
|
return NDIS_STATUS_SUCCESS; \
|
|
}
|
|
|
|
switch( Oid )
|
|
{
|
|
// General characteristics
|
|
case OID_GEN_SUPPORTED_LIST:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(gSupportedOIDs) );
|
|
RETURN_BYTES( gSupportedOIDs, sizeof(gSupportedOIDs));
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_HARDWARE_STATUS:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
*((ULONG*)InformationBuffer) = NdisHardwareStatusReady;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MEDIA_SUPPORTED:
|
|
case OID_GEN_MEDIA_IN_USE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// We support Ethernet only
|
|
*((ULONG*)InformationBuffer) = NdisMedium802_3;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_TRANSMIT_BUFFER_SPACE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Lie and claim to have 15K of send space, a common
|
|
// Ethernet card value.
|
|
// REVIEW: Is there a better value?
|
|
*((ULONG*)InformationBuffer) = 15 * 1024;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_RECEIVE_BUFFER_SPACE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Lie and claim to have 150K of receive space, a common
|
|
// Ethernet card value.
|
|
// REVIEW: Is there a better value?
|
|
*((ULONG*)InformationBuffer) = 150 * 1024;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MAXIMUM_SEND_PACKETS:
|
|
case OID_802_3_MAXIMUM_LIST_SIZE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Return a generic large integer
|
|
// REVIEW: Is there a better value to hand out?
|
|
*((ULONG*)InformationBuffer) = 0x000000FF;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MAXIMUM_FRAME_SIZE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Ethernet payloads can be up to 1500 bytes
|
|
*((ULONG*)InformationBuffer) = 1500L;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
// We indicate full packets up to NDIS, so these values are the same and
|
|
// equal to the maximum size of a packet
|
|
case OID_GEN_MAXIMUM_LOOKAHEAD:
|
|
case OID_GEN_CURRENT_LOOKAHEAD:
|
|
|
|
// These are also just the maximum total size of a frame
|
|
case OID_GEN_MAXIMUM_TOTAL_SIZE:
|
|
case OID_GEN_RECEIVE_BLOCK_SIZE:
|
|
case OID_GEN_TRANSMIT_BLOCK_SIZE:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
// Ethernet frames with header can be up to 1514 bytes
|
|
*((ULONG*)InformationBuffer) = 1514L;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MAC_OPTIONS:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
// We have no internal loopback support
|
|
*((ULONG*)InformationBuffer) = NDIS_MAC_OPTION_NO_LOOPBACK;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_LINK_SPEED:
|
|
{
|
|
LOCK_STATE LockState;
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read only*/, &LockState );
|
|
*((ULONG*)InformationBuffer) = gBridgeLinkSpeed;
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
// Ethernet characteristics
|
|
case OID_802_3_PERMANENT_ADDRESS:
|
|
case OID_802_3_CURRENT_ADDRESS:
|
|
{
|
|
SAFEASSERT( gHaveAddress );
|
|
|
|
// Don't need a read lock because the address shouldn't change once set
|
|
REQUIRE_AT_LEAST( sizeof(gBridgeAddress) );
|
|
RETURN_BYTES( gBridgeAddress, sizeof(gBridgeAddress));
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MEDIA_CONNECT_STATUS:
|
|
{
|
|
LOCK_STATE LockState;
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read only*/, &LockState );
|
|
*((ULONG*)InformationBuffer) = gBridgeMediaState;
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
|
|
case OID_GEN_VENDOR_ID:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
// We don't have an IEEE-assigned ID so use this constant
|
|
*((ULONG*)InformationBuffer) = 0xFFFFFF;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_VENDOR_DESCRIPTION:
|
|
{
|
|
UINT len = (UINT)strlen( gDriverDescription ) + 1;
|
|
REQUIRE_AT_LEAST( len );
|
|
RETURN_BYTES( gDriverDescription, len);
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_VENDOR_DRIVER_VERSION:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
// We are version 1.0
|
|
*((ULONG*)InformationBuffer) = 0x00010000;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_DRIVER_VERSION:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(USHORT) );
|
|
|
|
// We are using version 5.0 of NDIS
|
|
*((USHORT*)InformationBuffer) = 0x0500;
|
|
*BytesWritten = sizeof(USHORT);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// General Statistics
|
|
//
|
|
case OID_GEN_XMIT_OK:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of local-sourced sent frames
|
|
*((ULONG*)InformationBuffer) = gStatTransmittedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_XMIT_ERROR:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of local-sourced frames sent with errors
|
|
*((ULONG*)InformationBuffer) = gStatTransmittedErrorFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_RCV_OK:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of indicated frames
|
|
*((ULONG*)InformationBuffer) = gStatIndicatedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
// Answer the same for these two
|
|
case OID_GEN_RCV_NO_BUFFER:
|
|
case OID_GEN_RCV_ERROR:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatIndicatedDroppedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_DIRECTED_BYTES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
*((ULONG*)InformationBuffer) = gStatDirectedTransmittedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_DIRECTED_FRAMES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatDirectedTransmittedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MULTICAST_BYTES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatMulticastTransmittedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MULTICAST_FRAMES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatMulticastTransmittedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_BROADCAST_BYTES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatBroadcastTransmittedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_BROADCAST_FRAMES_XMIT:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatBroadcastTransmittedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_DIRECTED_BYTES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatDirectedIndicatedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_DIRECTED_FRAMES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatDirectedIndicatedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MULTICAST_BYTES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatMulticastIndicatedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_MULTICAST_FRAMES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatMulticastIndicatedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_BROADCAST_BYTES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatBroadcastIndicatedBytes.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_BROADCAST_FRAMES_RCV:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// Reply with the number of packets we wanted to indicate but couldn't
|
|
*((ULONG*)InformationBuffer) = gStatBroadcastIndicatedFrames.LowPart;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
// Ethernet statistics
|
|
case OID_802_3_RCV_ERROR_ALIGNMENT:
|
|
case OID_802_3_XMIT_ONE_COLLISION:
|
|
case OID_802_3_XMIT_MORE_COLLISIONS:
|
|
{
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
// We have no way of collecting this information sensibly from lower NICs, so
|
|
// pretend these types of events never happen.
|
|
*((ULONG*)InformationBuffer) = 0L;
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_CURRENT_PACKET_FILTER:
|
|
{
|
|
LOCK_STATE LockState;
|
|
|
|
REQUIRE_AT_LEAST( sizeof(ULONG) );
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read only*/, &LockState );
|
|
*((ULONG*)InformationBuffer) = gPacketFilter;
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
*BytesWritten = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_802_3_MULTICAST_LIST:
|
|
{
|
|
LOCK_STATE LockState;
|
|
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, FALSE /*Read only*/, &LockState );
|
|
|
|
if(InformationBufferLength < gMulticastListLength)
|
|
{
|
|
*BytesNeeded = gMulticastListLength;
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
return NDIS_STATUS_INVALID_LENGTH;
|
|
}
|
|
|
|
NdisMoveMemory( InformationBuffer, gMulticastList, gMulticastListLength );
|
|
*BytesWritten = gMulticastListLength;
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_PNP_QUERY_POWER:
|
|
{
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_TCP_TASK_OFFLOAD:
|
|
{
|
|
// Mark that Tcp.ip has been loaded
|
|
g_fIsTcpIpLoaded = TRUE;
|
|
// Set the underlying 1394 miniport to ON
|
|
BrdgSetMiniportsToBridgeMode(NULL,TRUE);
|
|
return NDIS_STATUS_NOT_SUPPORTED;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
// We don't understand the OID
|
|
return NDIS_STATUS_NOT_SUPPORTED;
|
|
|
|
#undef REQUIRE_AT_LEAST
|
|
#undef RETURN_BYTES
|
|
}
|
|
|
|
NDIS_STATUS
|
|
BrdgMiniSetInfo(
|
|
IN NDIS_HANDLE MiniportAdapterContext,
|
|
IN NDIS_OID Oid,
|
|
IN PVOID InformationBuffer,
|
|
IN ULONG InformationBufferLength,
|
|
OUT PULONG BytesRead,
|
|
OUT PULONG BytesNeeded
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NDIS entry point called to set various pieces of info to our miniport
|
|
|
|
Arguments:
|
|
|
|
MiniportAdapterContext Ignored
|
|
Oid The request code
|
|
InformationBuffer Input information buffer
|
|
InformationBufferLength Size of InformationBuffer
|
|
BytesRead Number of bytes read from InformationBuffer
|
|
BytesNeeded If the provided buffer is too small, this is how many we need.
|
|
|
|
Return Value:
|
|
|
|
Status of the request
|
|
|
|
--*/
|
|
{
|
|
LOCK_STATE LockState;
|
|
NDIS_STATUS Status;
|
|
|
|
switch( Oid )
|
|
{
|
|
case OID_GEN_CURRENT_PACKET_FILTER:
|
|
{
|
|
SAFEASSERT( InformationBufferLength == sizeof(ULONG) );
|
|
|
|
// Get write access to the packet filter
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE /*Read-Write*/, &LockState );
|
|
gPacketFilter = *((ULONG*)InformationBuffer);
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
DBGPRINT(MINI, ("Set the packet filter to %08x\n", gPacketFilter));
|
|
*BytesRead = sizeof(ULONG);
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_802_3_MULTICAST_LIST:
|
|
{
|
|
PUCHAR pOldList, pNewList;
|
|
ULONG oldListLength;
|
|
|
|
// The incoming buffer should contain an integral number of Ethernet MAC
|
|
// addresses
|
|
SAFEASSERT( (InformationBufferLength % ETH_LENGTH_OF_ADDRESS) == 0 );
|
|
|
|
DBGPRINT(MINI, ("Modifying the multicast list; now has %i entries\n",
|
|
InformationBufferLength / ETH_LENGTH_OF_ADDRESS));
|
|
|
|
// Alloc and copy to the new multicast list
|
|
if( InformationBufferLength > 0 )
|
|
{
|
|
Status = NdisAllocateMemoryWithTag( &pNewList, InformationBufferLength, 'gdrB' );
|
|
|
|
if( Status != NDIS_STATUS_SUCCESS )
|
|
{
|
|
DBGPRINT(MINI, ("NdisAllocateMemoryWithTag failed while recording multicast list\n"));
|
|
return NDIS_STATUS_NOT_ACCEPTED;
|
|
}
|
|
|
|
// Copy the list
|
|
NdisMoveMemory( pNewList, InformationBuffer, InformationBufferLength );
|
|
}
|
|
else
|
|
{
|
|
pNewList = NULL;
|
|
}
|
|
|
|
// Swap in the new list
|
|
NdisAcquireReadWriteLock( &gBridgeStateLock, TRUE /*Read-Write*/, &LockState );
|
|
|
|
pOldList = gMulticastList;
|
|
oldListLength = gMulticastListLength;
|
|
|
|
gMulticastList = pNewList;
|
|
gMulticastListLength = InformationBufferLength;
|
|
|
|
NdisReleaseReadWriteLock( &gBridgeStateLock, &LockState );
|
|
|
|
// Free the old multicast list if there was one
|
|
if( pOldList != NULL )
|
|
{
|
|
NdisFreeMemory( pOldList, oldListLength, 0 );
|
|
}
|
|
|
|
*BytesRead = InformationBufferLength;
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case OID_GEN_CURRENT_LOOKAHEAD:
|
|
case OID_GEN_PROTOCOL_OPTIONS:
|
|
{
|
|
// We accept these but do nothing
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
// Overlying protocols telling us about their network addresses
|
|
case OID_GEN_NETWORK_LAYER_ADDRESSES:
|
|
{
|
|
// Let the compatibility-mode code note the addresses
|
|
BrdgCompNotifyNetworkAddresses( InformationBuffer, InformationBufferLength );
|
|
}
|
|
//
|
|
// DELIBERATELY FALL THROUGH
|
|
//
|
|
|
|
// All relayed OIDs go here
|
|
case OID_GEN_TRANSPORT_HEADER_OFFSET:
|
|
{
|
|
LOCK_STATE LockState;
|
|
PADAPT Adapters[MAX_ADAPTERS], pAdapt;
|
|
LONG NumAdapters = 0L, i;
|
|
PNDIS_REQUEST_BETTER pRequest;
|
|
NDIS_STATUS Status, rc;
|
|
|
|
// We read the entire request
|
|
*BytesRead = InformationBufferLength;
|
|
|
|
// Pass these straight through to underlying NICs
|
|
NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*Read only*/, &LockState );
|
|
|
|
// Make a list of the adapters to send the request to
|
|
pAdapt = gAdapterList;
|
|
|
|
while( pAdapt != NULL )
|
|
{
|
|
if( NumAdapters < MAX_ADAPTERS )
|
|
{
|
|
Adapters[NumAdapters] = pAdapt;
|
|
|
|
// We will be using this adapter outside the list lock
|
|
BrdgAcquireAdapterInLock( pAdapt );
|
|
NumAdapters++;
|
|
}
|
|
else
|
|
{
|
|
SAFEASSERT( FALSE );
|
|
DBGPRINT(MINI, ("Too many adapters to relay a SetInfo request to!\n"));
|
|
}
|
|
|
|
pAdapt = pAdapt->Next;
|
|
}
|
|
|
|
// The refcount is the number of requests we will make
|
|
gRequestRefCount = NumAdapters;
|
|
|
|
NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
|
|
|
|
if( NumAdapters == 0 )
|
|
{
|
|
// Nothing to do!
|
|
rc = NDIS_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
// Request will pend unless all adapters return immediately
|
|
rc = NDIS_STATUS_PENDING;
|
|
|
|
for( i = 0L; i < NumAdapters; i++ )
|
|
{
|
|
// Allocate memory for the request
|
|
Status = NdisAllocateMemoryWithTag( &pRequest, sizeof(NDIS_REQUEST_BETTER), 'gdrB' );
|
|
|
|
if( Status != NDIS_STATUS_SUCCESS )
|
|
{
|
|
LONG NewCount = InterlockedDecrement( &gRequestRefCount );
|
|
|
|
DBGPRINT(MINI, ("NdisAllocateMemoryWithTag failed while relaying an OID\n"));
|
|
|
|
if( NewCount == 0 )
|
|
{
|
|
// This could only have happened with the last adapter
|
|
SAFEASSERT( i == NumAdapters - 1 );
|
|
|
|
// We're all done since everyone else has completed too
|
|
rc = NDIS_STATUS_SUCCESS;
|
|
}
|
|
|
|
// Let go of the adapter
|
|
BrdgReleaseAdapter( Adapters[i] );
|
|
continue;
|
|
}
|
|
|
|
// Set up the request as a mirror of ours
|
|
pRequest->Request.RequestType = NdisRequestSetInformation;
|
|
pRequest->Request.DATA.SET_INFORMATION.Oid = Oid ;
|
|
pRequest->Request.DATA.SET_INFORMATION.InformationBuffer = InformationBuffer;
|
|
pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength = InformationBufferLength;
|
|
NdisInitializeEvent( &pRequest->Event );
|
|
NdisResetEvent( &pRequest->Event );
|
|
pRequest->pFunc = BrdgMiniRelayedRequestComplete;
|
|
pRequest->FuncArg = NULL;
|
|
|
|
// Fire it off
|
|
NdisRequest( &Status, Adapters[i]->BindingHandle, &pRequest->Request );
|
|
|
|
// Let go of the adapter; NDIS should not permit it to be unbound while
|
|
// a request is in progress
|
|
BrdgReleaseAdapter( Adapters[i] );
|
|
|
|
if( Status != NDIS_STATUS_PENDING )
|
|
{
|
|
// The cleanup function won't get called
|
|
BrdgMiniRelayedRequestComplete( pRequest, NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Paranoia for future maintainance: can't refer to pointer parameters
|
|
// at this point, as the relayed requests may have completed already, making
|
|
// them stale.
|
|
//
|
|
InformationBuffer = NULL;
|
|
BytesRead = NULL;
|
|
BytesNeeded = NULL;
|
|
|
|
return rc;
|
|
}
|
|
break;
|
|
|
|
case OID_PNP_SET_POWER:
|
|
{
|
|
return NDIS_STATUS_SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return NDIS_STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
VOID
|
|
BrdgMiniRelayedRequestComplete(
|
|
PNDIS_REQUEST_BETTER pRequest,
|
|
PVOID unused
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called when a SetInformation request that we relayed completes.
|
|
|
|
Arguments:
|
|
|
|
pRequest The NDIS_REQUEST_BETTER structure we allocated
|
|
in BrdgMiniSetInformation().
|
|
|
|
unused Unused
|
|
|
|
Return Value:
|
|
|
|
Status of the request
|
|
|
|
--*/
|
|
{
|
|
LONG NewCount = InterlockedDecrement( &gRequestRefCount );
|
|
|
|
if( NewCount == 0 )
|
|
{
|
|
// NDIS Should not permit the miniport to shut down with a request
|
|
// in progress
|
|
SAFEASSERT( gMiniPortAdapterHandle != NULL );
|
|
|
|
// The operation always succeeds
|
|
NdisMSetInformationComplete( gMiniPortAdapterHandle, NDIS_STATUS_SUCCESS );
|
|
}
|
|
|
|
// Free the request structure since we allocated it ourselves
|
|
NdisFreeMemory( pRequest, sizeof(PNDIS_REQUEST_BETTER), 0 );
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID
|
|
BrdgMiniLocalRequestComplete(
|
|
PNDIS_REQUEST_BETTER pRequest,
|
|
PVOID pContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called when bridge allocated request completes.
|
|
|
|
Arguments:
|
|
|
|
pRequest The NDIS_REQUEST_BETTER structure we allocated
|
|
in BrdgSetMiniportsToBridgeMode.
|
|
Context pAdapt structure
|
|
|
|
Return Value:
|
|
|
|
Status of the request
|
|
|
|
--*/
|
|
{
|
|
PADAPT pAdapt = (PADAPT)pContext;
|
|
|
|
// Let go of the adapter;
|
|
BrdgReleaseAdapter( pAdapt);
|
|
|
|
// Free the request structure since we allocated it ourselves
|
|
NdisFreeMemory( pRequest, sizeof(PNDIS_REQUEST_BETTER), 0 );
|
|
}
|
|
|
|
VOID
|
|
BrdgSetMiniportsToBridgeMode(
|
|
PADAPT pAdapt,
|
|
BOOLEAN fSet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends a 1394 specific OID to the miniport informing it that TCP/IP
|
|
has been activated
|
|
|
|
Arguments:
|
|
|
|
pAdapt - If adapt is not NULL, send Request to this adapt.
|
|
Otherwise send it to all of them.
|
|
fSet - if True, then set Bridge Mode ON, otherwise set it OFF
|
|
|
|
Return Value:
|
|
|
|
Status of the request
|
|
|
|
--*/
|
|
{
|
|
|
|
LOCK_STATE LockState;
|
|
PADAPT Adapters[MAX_ADAPTERS];
|
|
LONG NumAdapters = 0L, i;
|
|
NDIS_OID Oid;
|
|
|
|
if (pAdapt != NULL)
|
|
{
|
|
if (pAdapt->PhysicalMedium == NdisPhysicalMedium1394)
|
|
{
|
|
// We have a 1394 adapt, ref it and send the request to it
|
|
if (BrdgAcquireAdapter (pAdapt))
|
|
{
|
|
Adapters[0] = pAdapt;
|
|
NumAdapters = 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// walk through the list and Acquire all the 1394 adapts
|
|
NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*Read only*/, &LockState );
|
|
|
|
// Make a list of the adapters to send the request to
|
|
pAdapt = gAdapterList;
|
|
|
|
while( pAdapt != NULL )
|
|
{
|
|
if( NumAdapters < MAX_ADAPTERS && pAdapt->PhysicalMedium == NdisPhysicalMedium1394)
|
|
{
|
|
Adapters[NumAdapters] = pAdapt;
|
|
|
|
// We will be using this adapter outside the list lock
|
|
BrdgAcquireAdapterInLock( pAdapt ); // cannot fail
|
|
NumAdapters++;
|
|
}
|
|
pAdapt = pAdapt->Next;
|
|
}
|
|
|
|
NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
|
|
}
|
|
|
|
if (NumAdapters == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (fSet == TRUE)
|
|
{
|
|
Oid = OID_1394_ENTER_BRIDGE_MODE ;
|
|
DBGPRINT(MINI, ("Setting 1394 miniport bridge mode - ON !\n"));
|
|
}
|
|
else
|
|
{
|
|
Oid = OID_1394_EXIT_BRIDGE_MODE ;
|
|
DBGPRINT(MINI, ("Setting 1394 miniport bridge mode - OFF !\n"));
|
|
}
|
|
|
|
for( i = 0L; i < NumAdapters; i++ )
|
|
{
|
|
NDIS_STATUS Status;
|
|
PNDIS_REQUEST_BETTER pRequest;
|
|
|
|
Status = NdisAllocateMemoryWithTag( &pRequest, sizeof(NDIS_REQUEST_BETTER), 'gdrB' );
|
|
|
|
if( Status != NDIS_STATUS_SUCCESS )
|
|
{
|
|
DBGPRINT(MINI, ("NdisAllocateMemoryWithTag failed while allocating a request structure \n"));
|
|
|
|
// Let go of the adapter
|
|
BrdgReleaseAdapter( Adapters[i] );
|
|
continue;
|
|
}
|
|
|
|
// Set up the request
|
|
pRequest->Request.RequestType = NdisRequestSetInformation;
|
|
pRequest->Request.DATA.SET_INFORMATION.Oid = Oid;
|
|
pRequest->Request.DATA.SET_INFORMATION.InformationBuffer = NULL;
|
|
pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength = 0 ;
|
|
NdisInitializeEvent( &pRequest->Event );
|
|
NdisResetEvent( &pRequest->Event );
|
|
pRequest->pFunc = BrdgMiniLocalRequestComplete;
|
|
pRequest->FuncArg = Adapters[i];
|
|
|
|
// Fire it off
|
|
NdisRequest( &Status, Adapters[i]->BindingHandle, &pRequest->Request );
|
|
|
|
if( Status != NDIS_STATUS_PENDING )
|
|
{
|
|
// The cleanup function won't get called
|
|
BrdgMiniLocalRequestComplete( pRequest, Adapters[i] );
|
|
}
|
|
|
|
} // end of for loop
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|