windows-server-2003/net/homenet/bridge/sys/brdgsta.c

/*++

Copyright(c) 2000  Microsoft Corporation

Module Name:

    brdgsta.c

Abstract:

    Ethernet MAC level bridge.
    Spanning Tree Algorithm section

Author:

    Mark Aiken

Environment:

    Kernel mode driver

Revision History:

    June 2000 - Original version

--*/

#define NDIS_MINIPORT_DRIVER
#define NDIS50_MINIPORT   1
#define NDIS_WDM 1

#pragma warning( push, 3 )
#include <ndis.h>
#pragma warning( pop )

#include "bridge.h"
#include "brdgsta.h"

#include "brdgmini.h"
#include "brdgprot.h"
#include "brdgbuf.h"
#include "brdgfwd.h"
#include "brdgtbl.h"
#include "brdgctl.h"

// ===========================================================================
//
// TYPES
//
// ===========================================================================

// BPDU types
typedef enum
{
    ConfigBPDU,
    TopologyChangeBPDU
} BPDU_TYPE;

// ===========================================================================
//
// CONSTANTS
//
// ===========================================================================

// These values measured in STA units (1/256ths of a second)
#define DEFAULT_MAX_AGE                 (8 * 256)       // 8 seconds
#define DEFAULT_HELLO_TIME              (2 * 256)       // 2 seconds
#define DEFAULT_FORWARD_DELAY           (5 * 256)       // 5 seconds
#define MESSAGE_AGE_INCREMENT           1               // 1 STA time unit

// These values measured in milliseconds
#define HOLD_TIMER_PERIOD               (1 * 1000)      // 1 second in milliseconds

// Normal size, in bytes, of a full-size (non-TCN) STA packet
#define CONFIG_BPDU_PACKET_SIZE         35

// Size, in bytes, of a TCN STA packet
#define TCN_BPDU_PACKET_SIZE            4

// The name of the registry entry that causes the STA to be disabled
const PWCHAR                            gDisableSTAParameterName = L"DisableSTA";

// The size of an 802.3 header with LLC
#define _802_3_HEADER_SIZE              17

// Value to be added to port IDs; must leave the bottom byte clear to store
// actual port ID
#define PORT_PRIORITY                   0x8000

// ===========================================================================
//
// STRUCTURES
//
// ===========================================================================

//
// This structure holds the information for a complete BPDU (although
// it is not laid out as the BPDU is actually transmitted on the wire)
//
typedef struct _CONFIG_BPDU
{
    BPDU_TYPE           Type;
    UCHAR               RootID[BRIDGE_ID_LEN];
    PATH_COST           RootCost;
    UCHAR               BridgeID[BRIDGE_ID_LEN];
    PORT_ID             PortID;
    STA_TIME            MessageAge;
    STA_TIME            MaxAge;
    STA_TIME            HelloTime;
    STA_TIME            ForwardDelay;
    BOOLEAN             bTopologyChangeAck;
    BOOLEAN             bTopologyChange;
} CONFIG_BPDU, *PCONFIG_BPDU;

// ===========================================================================
//
// GLOBALS
//
// ===========================================================================

// Global spin lock protects all STA data accesses (for data stored in adapters
// as well as globals)
NDIS_SPIN_LOCK          gSTALock;

// The bridge we believe is the root bridge
UCHAR                   gDesignatedRootID[BRIDGE_ID_LEN];

// Our own unique ID
UCHAR                   gOurID[BRIDGE_ID_LEN];

// Whether our ID has been set yet
BOOLEAN                 gHaveID = FALSE;

// Our cost to reach the root
PATH_COST               gRootCost = 0;

// Our root port (adapter)
PADAPT                  gRootAdapter = NULL;

// Whether we have detected a topology change
BOOLEAN                 gTopologyChangeDetected = FALSE;

// Whether we tell other bridges that the topology has changed
BOOLEAN                 gTopologyChange = FALSE;

// Current bridge maximum message age
STA_TIME                gMaxAge = DEFAULT_MAX_AGE;

// Current bridge Hello time
STA_TIME                gHelloTime = DEFAULT_HELLO_TIME;

// Current bridge forward delay
STA_TIME                gForwardDelay = DEFAULT_FORWARD_DELAY;

// Every adapter must have a unique ID number, but there is no requirement that
// that number be unique over the lifetime of the bridge. This array is used as
// a bitfield that records which IDs are in use.
ULONG                   gUsedPortIDs[MAX_ADAPTERS / sizeof(ULONG) / 8];

//
// Timers
//
BRIDGE_TIMER            gTopologyChangeTimer;
BRIDGE_TIMER            gTopologyChangeNotificationTimer;
BRIDGE_TIMER            gHelloTimer;

// TRUE if the STA is disabled for the lifetime of the bridge
BOOLEAN                 gDisableSTA = FALSE;

// ===========================================================================
//
// PRIVATE PROTOTYPES
//
// ===========================================================================

VOID
BrdgSTARootSelection();

VOID
BrdgSTADesignatedPortSelection();

BOOLEAN
BrdgSTAPortStateSelection();

VOID
BrdgSTAGenerateConfigBPDUs();

VOID
BrdgSTABecomeDesignatedPort(
    IN PADAPT           pAdapt
    );

VOID
BrdgSTAProcessTCNBPDU(
    IN PADAPT           pAdapt
    );

VOID
BrdgSTAProcessConfigBPDU(
    IN PADAPT       pAdapt,
    IN PCONFIG_BPDU pbpdu
    );

BOOLEAN
BrdgSTATopologyChangeDetected();

VOID
BrdgSTACopyFromPacketToBuffer(
    OUT PUCHAR                      pPacketOut,
    IN ULONG                        BufferSize,
    OUT PULONG                      pWrittenCount,
    IN PNDIS_PACKET                 pPacketIn
    );

VOID
BrdgSTADeferredSetAdapterState(
    IN PVOID                Arg
    );

VOID
BrdgSTAHelloTimerExpiry(
    IN PVOID            Unused
    );

VOID
BrdgSTAMessageAgeTimerExpiry(
    IN PVOID            Context
    );

VOID
BrdgSTAForwardDelayTimerExpiry(
    IN PVOID            Context
    );

VOID
BrdgSTATopologyChangeNotificationTimerExpiry(
    IN PVOID            Unused
    );

VOID
BrdgSTATopologyChangeTimerExpiry(
    IN PVOID            Unused
    );

VOID
BrdgSTAHoldTimerExpiry(
    IN PVOID            Context
    );

VOID
BrdgSTATransmitTCNPacket();

VOID
BrdgSTASetAdapterState(
    IN PADAPT               pAdapt,
    IN PORT_STATE           NewState
    );

// ===========================================================================
//
// INLINES / MACROS
//
// ===========================================================================

//
// Does a complete re-evaluation of STA info
//
// ASSUMES the caller has acquired gSTALock
//
__forceinline
VOID
BrdgSTAConfigUpdate()
{
    BrdgSTARootSelection();
    BrdgSTADesignatedPortSelection();
}

//
// Sets an NDIS timer using a time expressed in STA units
//
// No requirements on caller-held locks
//
__forceinline
VOID
BrdgSTASetTimerWithSTATime(
    IN PBRIDGE_TIMER    pTimer,
    IN STA_TIME         Time,
    IN BOOLEAN          bRecurring
    )
{
    BrdgSetTimer( pTimer, Time * 1000 / 256, bRecurring );
}

//
// Compares two bridge IDs.
//
//      -1      :       A < B
//      0       :       A == B
//      1       :       A > B
//
// No requirements on caller-held locks
//
__forceinline
INT
BrdgSTABridgeIDCmp(
    IN PUCHAR           pIDa,
    IN PUCHAR           pIDb
    )
{
    UINT        i;

    for( i = 0; i < BRIDGE_ID_LEN; i++ )
    {
        if( pIDa[i] > pIDb[i] )
        {
            return 1;
        }
        else if( pIDa[i] < pIDb[i] )
        {
            return -1;
        }
    }

    return 0;
}

//
// Returns whether or not we currently believe ourselves to be the root
// bridge.
//
// ASSUMES the caller has acquired gSTALock
//
__forceinline
BOOLEAN
BrdgSTAWeAreRoot()
{
    SAFEASSERT( gHaveID );
    return (BOOLEAN)(BrdgSTABridgeIDCmp( gOurID, gDesignatedRootID ) == 0);
}

//
// Copies a bridge ID from pIDSrc to pIDDest.
//
// No requirements on caller-held locks
//
__forceinline
VOID
BrdgSTACopyID(
    IN PUCHAR           pIDDest,
    IN PUCHAR           pIDSrc
    )
{
    UINT        i;

    for( i = 0; i < BRIDGE_ID_LEN; i++ )
    {
        pIDDest[i] = pIDSrc[i];
    }
}

//
// Calculates the STA path cost from an adapter's link speed.
// Follows IEEE 802.1D-1990 recommendation that the link cost be set
// to 1000 / (Speed in Mbits/s).
//
// No requirements on caller-held locks
//
__forceinline
PATH_COST
BrdgSTALinkCostFromLinkSpeed(
    IN ULONG            LinkSpeed
    )
{
    ULONG               retVal;

    // Link speed is reported in units of 100bps
    if( LinkSpeed == 0L )
    {
        // Avoid div by zero and return very high path cost
        DBGPRINT(STA, ("Zero link speed reported\n"));
        retVal = 0xFFFFFFFF;
    }
    else
    {
        retVal = (PATH_COST)(10000000L / LinkSpeed);
    }

    if( retVal == 0L )
    {
        // STA spec calls for path costs to always be at least 1
        return 1L;
    }
    else
    {
        return retVal;
    }
}

//
// Updates the global gTopologyChange flag. When this flag is set,
// we must use a forwarding table timeout value equal to the bridge's
// current forwarding delay. When the flag is not set, we use
// the table's default timeout value.
//
// ASSUMES the caller has acquired gSTALock
//
__forceinline
VOID
BrdgSTAUpdateTopologyChange(
    IN BOOLEAN          NewValue
    )
{
    if( gTopologyChange != NewValue )
    {
        gTopologyChange = NewValue;

        if( gTopologyChange )
        {
            // Convert the forward delay to ms
            BrdgTblSetTimeout( gForwardDelay * 1000 / 256 );
        }
        else
        {
            BrdgTblRevertTimeout();
        }
    }
}

// ===========================================================================
//
// PUBLIC FUNCTIONS
//
// ===========================================================================

VOID
BrdgSTAGetAdapterSTAInfo(
    IN PADAPT                   pAdapt,
    PBRIDGE_STA_ADAPTER_INFO    pInfo
    )
/*++

Routine Description:

    Copies STA information for a particular adapter into a structure

    Called to collect information for user-mode components

Arguments:

    pAdapt                      The adapter
    pInfo                       Structure to receive STA information

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    NdisAcquireSpinLock( &gSTALock );

    pInfo->ID = pAdapt->STAInfo.ID;
    pInfo->PathCost = pAdapt->STAInfo.PathCost;
    BrdgSTACopyID( pInfo->DesignatedRootID, pAdapt->STAInfo.DesignatedRootID );
    pInfo->DesignatedCost = pAdapt->STAInfo.DesignatedCost;
    BrdgSTACopyID( pInfo->DesignatedBridgeID, pAdapt->STAInfo.DesignatedBridgeID );
    pInfo->DesignatedPort = pAdapt->STAInfo.DesignatedPort;

    NdisReleaseSpinLock( &gSTALock );
}

VOID
BrdgSTAGetSTAInfo(
    PBRIDGE_STA_GLOBAL_INFO     pInfo
    )
/*++

Routine Description:

    Copies global STA information into a structure

    Called to collect information for user-mode components

Arguments:

    pInfo                       Structure to receive STA information

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    NdisAcquireSpinLock( &gSTALock );

    SAFEASSERT( gHaveID );

    BrdgSTACopyID( pInfo->OurID, gOurID );
    BrdgSTACopyID( pInfo->DesignatedRootID, gDesignatedRootID );
    pInfo->RootCost = gRootCost;
    pInfo->RootAdapter = (BRIDGE_ADAPTER_HANDLE)gRootAdapter;
    pInfo->bTopologyChangeDetected = gTopologyChangeDetected;
    pInfo->bTopologyChange = gTopologyChange;
    pInfo->MaxAge = gMaxAge;
    pInfo->HelloTime = gHelloTime;
    pInfo->ForwardDelay = gForwardDelay;

    NdisReleaseSpinLock( &gSTALock );
}

VOID
BrdgSTAUpdateAdapterCost(
    IN PADAPT           pAdapt,
    ULONG               LinkSpeed
    )
/*++

Routine Description:

    Updates an adapter's path cost to reflect an updated link speed

Arguments:

    pAdapt              The adapter
    LinkSpeed           The adapter's new link speed

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    BOOLEAN             bTransmitTCN = FALSE;

    NdisAcquireSpinLock( &gSTALock );

    if( pAdapt->bSTAInited )
    {
        pAdapt->STAInfo.PathCost = BrdgSTALinkCostFromLinkSpeed(LinkSpeed);

        // Do a global re-evaluation of STA info
        BrdgSTAConfigUpdate();
        bTransmitTCN = BrdgSTAPortStateSelection();
    }
    else
    {
        DBGPRINT(STA, ("BrdgSTAUpdateAdapterCost() called with uninitialized adapter; ignoring!\n"));
    }

    NdisReleaseSpinLock( &gSTALock );

    if( bTransmitTCN )
    {
        BrdgSTATransmitTCNPacket();
    }
}

NTSTATUS
BrdgSTADriverInit()
/*++

Routine Description:

    Driver load-time initialization

Return Value:

    Status of initialization

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    NTSTATUS            NtStatus;
    UINT                i;
    ULONG               regValue;

    NdisAllocateSpinLock( &gSTALock );

    BrdgInitializeTimer( &gTopologyChangeTimer, BrdgSTATopologyChangeTimerExpiry, NULL );
    BrdgInitializeTimer( &gTopologyChangeNotificationTimer, BrdgSTATopologyChangeNotificationTimerExpiry, NULL );
    BrdgInitializeTimer( &gHelloTimer, BrdgSTAHelloTimerExpiry, NULL );

    // We haven't used any port IDs yet...
    for( i = 0; i < sizeof(gUsedPortIDs) / sizeof(ULONG); i++ )
    {
        gUsedPortIDs[i] = 0;
    }

    // Check if we're supposed to disable the STA
    NtStatus = BrdgReadRegDWord( &gRegistryPath, gDisableSTAParameterName, &regValue );

    if( (NtStatus == STATUS_SUCCESS) &&
        (regValue != 0L) )
    {
        gDisableSTA = TRUE;
        DBGPRINT(STA, ("DISABLING SPANNING TREE ALGORITHM\n"));
    }

    return STATUS_SUCCESS;
}

VOID
BrdgSTADeferredInit(
    IN PUCHAR           pBridgeMACAddress
    )
/*++

Routine Description:

    Second initialization pass; called when we determine the bridge's
    MAC address (which is needed for STA operations)

Arguments:

    pBridgeMACAddress   The bridge miniport's MAC address

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    UINT                i;

    // Our identifier consists of our MAC address preceeded with 0x8000
    gOurID[0] = 0x80;
    gOurID[1] = 0x00;

    for( i = BRIDGE_ID_LEN - ETH_LENGTH_OF_ADDRESS; i < BRIDGE_ID_LEN; i++ )
    {
        gOurID[i] = pBridgeMACAddress[i - (BRIDGE_ID_LEN - ETH_LENGTH_OF_ADDRESS)];
    }

    // Set the root bridge ID as our own to start out with
    BrdgSTACopyID( gDesignatedRootID, gOurID );
    gHaveID = TRUE;

    if (BrdgFwdBridgingNetworks())
    {
        // Don't use locks; rely on this function being non-reentrant and always run
        // before any other functions
        if( BrdgSTAPortStateSelection() )
        {
            BrdgSTATransmitTCNPacket();
        }

        BrdgSTAGenerateConfigBPDUs();
        BrdgSTASetTimerWithSTATime( &gHelloTimer, gHelloTime, TRUE );   
    }
}

VOID
BrdgSTACleanup()
/*++

Routine Description:

    Driver unload-time cleanup

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    BrdgShutdownTimer( &gTopologyChangeTimer );
    BrdgShutdownTimer( &gTopologyChangeNotificationTimer );
    BrdgShutdownTimer( &gHelloTimer );
}

VOID
BrdgSTAEnableAdapter(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Enables STA operations on an adapter. Can be called multiple times
    (in conjunction with BrdgSTADisableAdapter()) for a given adapter

Arguments:

    pAdapt              The adapter

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    BOOLEAN             bTransmitTCN = FALSE;

    DBGPRINT(STA, ("ENABLING adapter %p\n", pAdapt));

    NdisAcquireSpinLock( &gSTALock );

    if( pAdapt->bSTAInited )
    {
        BrdgSTABecomeDesignatedPort(pAdapt);
        BrdgSTASetAdapterState( pAdapt, Blocking );

        pAdapt->STAInfo.bTopologyChangeAck = FALSE;
        pAdapt->STAInfo.bConfigPending = FALSE;

        bTransmitTCN = BrdgSTAPortStateSelection();
    }
    else
    {
        DBGPRINT(STA, ("BrdgSTAEnableAdapter() called with uninitialized adapter; ignoring!\n"));
    }

    NdisReleaseSpinLock( &gSTALock );

    if( bTransmitTCN && BrdgFwdBridgingNetworks())
    {
        BrdgSTATransmitTCNPacket();
    }
}

VOID
BrdgSTAInitializeAdapter(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    One-time initialization for a new adatper

Arguments:

    pAdapt              The adapter

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.
    ASSUMES the adapter has already been added to the global list

--*/
{
    if( BrdgAcquireAdapter(pAdapt) )
    {
        UINT            i, j;

        // Adapters should always be disabled when being initialized, either because they are
        // brand new and this is how they start out, or as a way of checking that they were
        // correctly stopped when they were last disconnected.
        SAFEASSERT( pAdapt->State == Disabled );

        pAdapt->STAInfo.PathCost = BrdgSTALinkCostFromLinkSpeed(pAdapt->LinkSpeed);

        BrdgInitializeTimer( &pAdapt->STAInfo.MessageAgeTimer, BrdgSTAMessageAgeTimerExpiry, pAdapt );
        BrdgInitializeTimer( &pAdapt->STAInfo.ForwardDelayTimer, BrdgSTAForwardDelayTimerExpiry, pAdapt );
        BrdgInitializeTimer( &pAdapt->STAInfo.HoldTimer, BrdgSTAHoldTimerExpiry, pAdapt );
        pAdapt->STAInfo.LastConfigTime = 0L;

        // Find an unused port number in the bitfield
        NdisAcquireSpinLock( &gSTALock );
        for( i = 0; i < sizeof(gUsedPortIDs) / sizeof(ULONG); i++ )
        {
            for( j = 0; j < sizeof(ULONG) * 8; j++ )
            {
                if( (gUsedPortIDs[i] & (1 << j)) == 0 )
                {
                    pAdapt->STAInfo.ID = (PORT_ID)(PORT_PRIORITY | ((i * sizeof(ULONG) * 8) + j));
                    DBGPRINT(STA, ("Adapter %p gets ID %i\n", pAdapt, pAdapt->STAInfo.ID));
                    gUsedPortIDs[i] |= (1 << j);
                    goto doneID;
                }
            }
        }

        // Should be impossible to not have an available ID
        SAFEASSERT( FALSE );
        pAdapt->STAInfo.ID = PORT_PRIORITY | 0xFF;

doneID:
        // Set this before releasing the lock
        pAdapt->bSTAInited = TRUE;

        NdisReleaseSpinLock( &gSTALock );

        // Start the adapter off enabled / disabled based on its media state
        // The enable / disable functions take locks
        if( pAdapt->MediaState == NdisMediaStateConnected )
        {
            BrdgSTAEnableAdapter( pAdapt );
        }
        else
        {
            SAFEASSERT( pAdapt->MediaState == NdisMediaStateDisconnected );
            BrdgSTADisableAdapter( pAdapt );
        }
    }
    else
    {
        SAFEASSERT( FALSE );
    }
}

VOID
BrdgSTADisableAdapter(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Disable STA operation on an adapter. Can be called multiple times
    (in conjunction with BrdgSTAEnableAdapter()) on a given adapter

Arguments:

    pAdapt              The adapter

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    BOOLEAN             bWereRoot, bTransmitTCN = FALSE;

    DBGPRINT(STA, ("DISABLING adapter %p\n", pAdapt));

    NdisAcquireSpinLock( &gSTALock );

    if( pAdapt->bSTAInited )
    {
        bWereRoot = BrdgSTAWeAreRoot();

        BrdgSTABecomeDesignatedPort(pAdapt);
        BrdgSTASetAdapterState( pAdapt, Disabled );

        pAdapt->STAInfo.bTopologyChangeAck = FALSE;
        pAdapt->STAInfo.bConfigPending = FALSE;

        BrdgCancelTimer( &pAdapt->STAInfo.MessageAgeTimer );
        pAdapt->STAInfo.LastConfigTime = 0L;
        BrdgCancelTimer( &pAdapt->STAInfo.ForwardDelayTimer );

        BrdgSTAConfigUpdate();
        bTransmitTCN = BrdgSTAPortStateSelection();

        if( BrdgSTAWeAreRoot() && (! bWereRoot) )
        {
            // We're the root bridge now
            DBGPRINT(STA, ("Became root through disabling of adapter %p\n", pAdapt));

            gMaxAge = DEFAULT_MAX_AGE;
            gHelloTime = DEFAULT_HELLO_TIME;
            gForwardDelay = DEFAULT_FORWARD_DELAY;

            bTransmitTCN = BrdgSTATopologyChangeDetected();
            BrdgCancelTimer( &gTopologyChangeNotificationTimer );

            // Don't do packet sends with a spin lock held
            NdisReleaseSpinLock( &gSTALock );

            if (BrdgFwdBridgingNetworks())
            {
                BrdgSTAGenerateConfigBPDUs();
                BrdgSTASetTimerWithSTATime( &gHelloTimer, gHelloTime, TRUE );
            }
        }
        else
        {
            NdisReleaseSpinLock( &gSTALock );
        }
    }
    else
    {
        NdisReleaseSpinLock( &gSTALock );
        DBGPRINT(STA, ("BrdgSTADisableAdapter() called with uninitialized adapter; ignoring!\n"));
    }

    if( bTransmitTCN )
    {
        BrdgSTATransmitTCNPacket();
    }
}

VOID
BrdgSTAShutdownAdapter(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    One-time teardown of an adapter

Arguments:

    pAdapt              The adapter

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.
    ASSUMES the adapter has been taken out of the global list

--*/
{
    UINT                i;
    PORT_ID             ActualID = pAdapt->STAInfo.ID & (~PORT_PRIORITY);

    // Shouldn't be possible to go through a formal shutdown without
    // having completed initialization.
    SAFEASSERT( pAdapt->bSTAInited );

    // Shutdown all this adapter's timers
    BrdgShutdownTimer( &pAdapt->STAInfo.HoldTimer );
    BrdgShutdownTimer( &pAdapt->STAInfo.ForwardDelayTimer );
    BrdgShutdownTimer( &pAdapt->STAInfo.MessageAgeTimer );

    // Disable the adapter
    BrdgSTADisableAdapter( pAdapt );

    // Note that this adapter's port ID is now free
    NdisAcquireSpinLock( &gSTALock );
    i = (UINT)(ActualID / (sizeof(ULONG) * 8));
    SAFEASSERT( i < sizeof(gUsedPortIDs) / sizeof(ULONG) );
    gUsedPortIDs[i] &= ~(1 << (ActualID % (sizeof(ULONG) * 8)));
    NdisReleaseSpinLock( &gSTALock );

    // We're all done with this adapter structure
    SAFEASSERT( gRootAdapter != pAdapt );
    BrdgReleaseAdapter( pAdapt );
}

VOID
BrdgSTAReceivePacket(
    IN PADAPT           pAdapt,
    IN PNDIS_PACKET     pPacket
    )
/*++

Routine Description:

    Function to handle the processing of a packet received on the reserved
    STA multicast channel

Arguments:

    pAdapt              The adapter the packet was received on
    pPacket             The received packet

Return Value:

    None

Locking Constraints:

    Top-level function. Assumes no locks are held by caller.

--*/
{
    UCHAR               STAPacket[CONFIG_BPDU_PACKET_SIZE + _802_3_HEADER_SIZE];
    ULONG               written;
    SHORT               dataLen;

    // Copy the data from the packet into our data buffer
    BrdgSTACopyFromPacketToBuffer( STAPacket, sizeof(STAPacket), &written, pPacket );

    if( written < TCN_BPDU_PACKET_SIZE + _802_3_HEADER_SIZE )
    {
        THROTTLED_DBGPRINT(STA, ("Undersize STA packet received on %p\n", pAdapt));
        return;
    }

    // The LLC header must identify the STA protocol
    if( (STAPacket[14] != 0x42) || (STAPacket[15] != 0x42) )
    {
        THROTTLED_DBGPRINT(STA, ("Packet with bad protocol type received on %p\n", pAdapt));
        return;
    }

    // Bytes 13 and 14 encode the length of data.
    dataLen = STAPacket[12] << 8;
    dataLen |= STAPacket[13];

    // The first two bytes are the protocol identifier and must be zero.
    // The third byte is the version identifier and must be zero.

    if( (STAPacket[_802_3_HEADER_SIZE] != 0) ||
        (STAPacket[_802_3_HEADER_SIZE + 1] != 0) ||
        (STAPacket[_802_3_HEADER_SIZE + 2] != 0) )
    {
        THROTTLED_DBGPRINT(STA, ("Invalid STA packet received\n"));
        return;
    }

    if( STAPacket[_802_3_HEADER_SIZE + 3] == 0x80 )
    {
        // The length of the frame with LLC header must be 7 bytes for a TCN BPDU
        if( dataLen != 7 )
        {
            THROTTLED_DBGPRINT(STA, ("Bad header size for TCN BPDU on %p\n", pAdapt));
            return;
        }

        // This is a Topology Change BPDU.
        BrdgSTAProcessTCNBPDU( pAdapt );
    }
    else if( STAPacket[_802_3_HEADER_SIZE + 3] == 0x00 )
    {
        CONFIG_BPDU         bpdu;

        if( written < CONFIG_BPDU_PACKET_SIZE + _802_3_HEADER_SIZE )
        {
            THROTTLED_DBGPRINT(STA, ("Undersize config BPDU received on %p\n", pAdapt));
            return;
        }

        // The length of the frame with LLC header must be 38 bytes for a Config BPDU
        if( dataLen != 38 )
        {
            THROTTLED_DBGPRINT(STA, ("Bad header size for Config BPDU on %p\n", pAdapt));
            return;
        }

        bpdu.Type = ConfigBPDU;

        // The high bit of byte 5 encodes the topology change acknowledge flag
        bpdu.bTopologyChangeAck = (BOOLEAN)((STAPacket[_802_3_HEADER_SIZE + 4] & 0x80) != 0);

        // The low bit of byte 5 encodes the topology change flag
        bpdu.bTopologyChange = (BOOLEAN)((STAPacket[_802_3_HEADER_SIZE + 4] & 0x01) != 0);

        // Bytes 6 thru 13 encode the root bridge ID
        bpdu.RootID[0] = STAPacket[_802_3_HEADER_SIZE + 5];
        bpdu.RootID[1] = STAPacket[_802_3_HEADER_SIZE + 6];
        bpdu.RootID[2] = STAPacket[_802_3_HEADER_SIZE + 7];
        bpdu.RootID[3] = STAPacket[_802_3_HEADER_SIZE + 8];
        bpdu.RootID[4] = STAPacket[_802_3_HEADER_SIZE + 9];
        bpdu.RootID[5] = STAPacket[_802_3_HEADER_SIZE + 10];
        bpdu.RootID[6] = STAPacket[_802_3_HEADER_SIZE + 11];
        bpdu.RootID[7] = STAPacket[_802_3_HEADER_SIZE + 12];

        // Bytes 14 thru 17 encode the root path cost
        bpdu.RootCost = 0;
        bpdu.RootCost |= STAPacket[_802_3_HEADER_SIZE + 13] << 24;
        bpdu.RootCost |= STAPacket[_802_3_HEADER_SIZE + 14] << 16;
        bpdu.RootCost |= STAPacket[_802_3_HEADER_SIZE + 15] << 8;
        bpdu.RootCost |= STAPacket[_802_3_HEADER_SIZE + 16];

        // Bytes 18 thru 15 encode the designated bridge ID
        bpdu.BridgeID[0] = STAPacket[_802_3_HEADER_SIZE + 17];
        bpdu.BridgeID[1] = STAPacket[_802_3_HEADER_SIZE + 18];
        bpdu.BridgeID[2] = STAPacket[_802_3_HEADER_SIZE + 19];
        bpdu.BridgeID[3] = STAPacket[_802_3_HEADER_SIZE + 20];
        bpdu.BridgeID[4] = STAPacket[_802_3_HEADER_SIZE + 21];
        bpdu.BridgeID[5] = STAPacket[_802_3_HEADER_SIZE + 22];
        bpdu.BridgeID[6] = STAPacket[_802_3_HEADER_SIZE + 23];
        bpdu.BridgeID[7] = STAPacket[_802_3_HEADER_SIZE + 24];

        // Bytes 26 and 27 encode the port identifier
        bpdu.PortID = 0;
        bpdu.PortID |= STAPacket[_802_3_HEADER_SIZE + 25] << 8;
        bpdu.PortID |= STAPacket[_802_3_HEADER_SIZE + 26];

        // Bytes 28 and 29 encode the message age
        bpdu.MessageAge = 0;
        bpdu.MessageAge |= STAPacket[_802_3_HEADER_SIZE + 27] << 8;
        bpdu.MessageAge |= STAPacket[_802_3_HEADER_SIZE + 28];

        // Bytes 30 and 31 encode the Max Age
        bpdu.MaxAge = 0;
        bpdu.MaxAge |= STAPacket[_802_3_HEADER_SIZE + 29] << 8;
        bpdu.MaxAge |= STAPacket[_802_3_HEADER_SIZE + 30];

        if( bpdu.MaxAge == 0 )
        {
            THROTTLED_DBGPRINT(STA, ("Ignoring BPDU packet with zero MaxAge on adapter %p\n", pAdapt));
            return;
        }

        // Bytes 32 and 33 encode the Hello Time
        bpdu.HelloTime = 0;
        bpdu.HelloTime |= STAPacket[_802_3_HEADER_SIZE + 31] << 8;
        bpdu.HelloTime |= STAPacket[_802_3_HEADER_SIZE + 32];

        if( bpdu.HelloTime == 0 )
        {
            THROTTLED_DBGPRINT(STA, ("Ignoring BPDU packet with zero HelloTime on adapter %p\n", pAdapt));
            return;
        }

        // Bytes 34 and 35 encode the forwarding delay
        bpdu.ForwardDelay = 0;
        bpdu.ForwardDelay |= STAPacket[_802_3_HEADER_SIZE + 33] << 8;
        bpdu.ForwardDelay |= STAPacket[_802_3_HEADER_SIZE + 34];

        if( bpdu.ForwardDelay == 0 )
        {
            THROTTLED_DBGPRINT(STA, ("Ignoring BPDU packet with zero ForwardDelay on adapter %p\n", pAdapt));
            return;
        }

        BrdgSTAProcessConfigBPDU( pAdapt, &bpdu );
    }
    else
    {
        THROTTLED_DBGPRINT(STA, ("Packet with unrecognized BPDU type received on %p\n", pAdapt));
        return;
    }
}

// ===========================================================================
//
// PRIVATE FUNCTIONS
//
// ===========================================================================

VOID
BrdgSTASetAdapterState(
    IN PADAPT               pAdapt,
    IN PORT_STATE           NewState
    )
/*++

Routine Description:

    Updates an adapter's forwarding state correctly

    This function is designed to be callable at high IRQL, so it defers
    the actual call to BrdgProtDoAdapterStateChange, which must be called
    at low IRQL.

Arguments:

    pAdapt              The adapter the packet was received on
    pPacket             The received packet

Return Value:

    None

Locking Constraints:

    No requirements on caller-held locks

--*/

{
    LOCK_STATE              LockState;
    BOOLEAN                 bailOut = FALSE;
    
    // Set the adapter's new state.
    NdisAcquireReadWriteLock( &gAdapterCharacteristicsLock, TRUE/*Write access*/, &LockState );
    if( pAdapt->State == NewState )
    {
        bailOut = TRUE;
    }
    else
    {
        pAdapt->State = NewState;
    }
    NdisReleaseReadWriteLock( &gAdapterCharacteristicsLock, &LockState );

    // Don't do additional work if the adapter is already in the requested state
    if( bailOut )
    {
        return;
    }

#if DBG
    switch( NewState )
    {
    case Blocking:
        DBGPRINT(STA, ("Adapter %p becomes BLOCKING\n", pAdapt));
        break;

    case Listening:
        DBGPRINT(STA, ("Adapter %p becomes LISTENING\n", pAdapt));
        break;

    case Learning:
        DBGPRINT(STA, ("Adapter %p becomes LEARNING\n", pAdapt));
        break;

    case Forwarding:
        DBGPRINT(STA, ("Adapter %p becomes FORWARDING\n", pAdapt));
        break;
    }
#endif

    //
    // We will be hanging onto the adapter pointer in order to defer the call
    // to BrdgSTADeferredSetAdapterState.
    //
    if( BrdgAcquireAdapter(pAdapt) )
    {
        NDIS_STATUS     Status;

        // We need to defer the call to BrdgProtDoAdapterStateChange since it must run
        // at PASSIVE_IRQL
        Status = BrdgDeferFunction( BrdgSTADeferredSetAdapterState, pAdapt );

        if( Status != NDIS_STATUS_SUCCESS )
        {
            DBGPRINT(STA, ("Unable to defer call to BrdgSTADeferredSetAdapterState\n", pAdapt));
            BrdgReleaseAdapter( pAdapt );
        }
        // else adapter will be released in BrdgSTADeferredSetAdapterState
    }
    else
    {
        DBGPRINT(STA, ("Adapter %p already shutting down when attempted to set adapter state\n", pAdapt));
    }
}

VOID
BrdgSTADeferredSetAdapterState(
    IN PVOID                Arg
    )
/*++

Routine Description:

    Deferred function from BrdgSTASetAdapterState; does housekeeping associated with
    changing an adapter's forwarding state.

    Must be called at PASSIVE

Arguments:

    Arg                     The adapter that needs updating

Return Value:

    None

Locking Constraints:

    No requirements on caller-held locks

--*/
{
    PADAPT                  pAdapt = (PADAPT)Arg;

    SAFEASSERT( CURRENT_IRQL == PASSIVE_LEVEL );

    BrdgProtDoAdapterStateChange( pAdapt );

    // Tell user-mode about the change
    BrdgCtlNotifyAdapterChange( pAdapt, BrdgNotifyAdapterStateChange );

    // Adapter was acquired in BrdgSTASetAdapterState()
    BrdgReleaseAdapter( pAdapt );
}

VOID
BrdgSTATransmitConfigBPDUPacket(
    IN PADAPT                       pAdapt,
    PCONFIG_BPDU                    pbpdu
    )
/*++

Routine Description:

    Transmits a config BPDU packet on a particular adapter

Arguments:

    pAdapt                          The adapter to transmit on
    pbpdu                           A structure describing the BPDU information

Return Value:

    None

Locking Constraints:

    No requirements on caller-held locks

--*/
{
    UCHAR                           STAPacket[CONFIG_BPDU_PACKET_SIZE + _802_3_HEADER_SIZE];
    NDIS_STATUS                     Status;

    if (BrdgProtGetAdapterCount() < 2)
    {
        return;
    }

    if (!BrdgFwdBridgingNetworks())
    {
        DBGPRINT(STA, ("Not Transmitting STA Packet (we're not bridging)\r\n"));
        return;
    }

    //
    // First encode the Ethernet header.
    //
    // Destination MAC address of packet must be STA multicast address
    STAPacket[0] = STA_MAC_ADDR[0];
    STAPacket[1] = STA_MAC_ADDR[1];
    STAPacket[2] = STA_MAC_ADDR[2];
    STAPacket[3] = STA_MAC_ADDR[3];
    STAPacket[4] = STA_MAC_ADDR[4];
    STAPacket[5] = STA_MAC_ADDR[5];

    // The the source MAC address to the adapter's own MAC address
    STAPacket[6] = pAdapt->MACAddr[0];
    STAPacket[7] = pAdapt->MACAddr[1];
    STAPacket[8] = pAdapt->MACAddr[2];
    STAPacket[9] = pAdapt->MACAddr[3];
    STAPacket[10] = pAdapt->MACAddr[4];
    STAPacket[11] = pAdapt->MACAddr[5];

    // Next two bytes are the size of the frame (38 bytes)
    STAPacket[12] = 0x00;
    STAPacket[13] = 0x26;

    // Next two bytes are the LLC DSAP and SSAP fields, set to 0x42 for STA
    STAPacket[14] = 0x42;
    STAPacket[15] = 0x42;

    // Next byte is the LLC frame type, 3 for unnumbered
    STAPacket[16] = 0x03;

    //
    // Now we are encoding the payload.
    //
    // First 4 bytes are the protocol identifier, version and BPDU type, all zero
    STAPacket[_802_3_HEADER_SIZE] = STAPacket[_802_3_HEADER_SIZE + 1] =
        STAPacket[_802_3_HEADER_SIZE + 2] = STAPacket[_802_3_HEADER_SIZE + 3] = 0x00;

    // Byte 5 encodes the Topology Change Ack flag in the high bit and the
    // Topology Change flag in the low bit.
    STAPacket[_802_3_HEADER_SIZE + 4] = 0;

    if( pbpdu->bTopologyChangeAck )
    {
        STAPacket[_802_3_HEADER_SIZE + 4] |= 0x80;
    }

    if( pbpdu->bTopologyChange )
    {
        STAPacket[_802_3_HEADER_SIZE + 4] |= 0x01;
    }

    // Bytes 6-13 encode the root bridge ID
    STAPacket[_802_3_HEADER_SIZE + 5] = pbpdu->RootID[0];
    STAPacket[_802_3_HEADER_SIZE + 6] = pbpdu->RootID[1];
    STAPacket[_802_3_HEADER_SIZE + 7] = pbpdu->RootID[2];
    STAPacket[_802_3_HEADER_SIZE + 8] = pbpdu->RootID[3];
    STAPacket[_802_3_HEADER_SIZE + 9] = pbpdu->RootID[4];
    STAPacket[_802_3_HEADER_SIZE + 10] = pbpdu->RootID[5];
    STAPacket[_802_3_HEADER_SIZE + 11] = pbpdu->RootID[6];
    STAPacket[_802_3_HEADER_SIZE + 12] = pbpdu->RootID[7];

    // Bytes 14 - 17 encode the root path cost
    STAPacket[_802_3_HEADER_SIZE + 13] = (UCHAR)(pbpdu->RootCost >> 24);
    STAPacket[_802_3_HEADER_SIZE + 14] = (UCHAR)(pbpdu->RootCost >> 16);
    STAPacket[_802_3_HEADER_SIZE + 15] = (UCHAR)(pbpdu->RootCost >> 8);
    STAPacket[_802_3_HEADER_SIZE + 16] = (UCHAR)(pbpdu->RootCost);

    // Bytes 18-25 encode the designated bridge ID
    STAPacket[_802_3_HEADER_SIZE + 17] = pbpdu->BridgeID[0];
    STAPacket[_802_3_HEADER_SIZE + 18] = pbpdu->BridgeID[1];
    STAPacket[_802_3_HEADER_SIZE + 19] = pbpdu->BridgeID[2];
    STAPacket[_802_3_HEADER_SIZE + 20] = pbpdu->BridgeID[3];
    STAPacket[_802_3_HEADER_SIZE + 21] = pbpdu->BridgeID[4];
    STAPacket[_802_3_HEADER_SIZE + 22] = pbpdu->BridgeID[5];
    STAPacket[_802_3_HEADER_SIZE + 23] = pbpdu->BridgeID[6];
    STAPacket[_802_3_HEADER_SIZE + 24] = pbpdu->BridgeID[7];

    // Bytes 26 and 27 encode the port identifier
    STAPacket[_802_3_HEADER_SIZE + 25] = (UCHAR)(pbpdu->PortID >> 8);
    STAPacket[_802_3_HEADER_SIZE + 26] = (UCHAR)(pbpdu->PortID);

    // Bytes 28 and 29 encode the message age
    STAPacket[_802_3_HEADER_SIZE + 27] = (UCHAR)(pbpdu->MessageAge >> 8);
    STAPacket[_802_3_HEADER_SIZE + 28] = (UCHAR)(pbpdu->MessageAge);

    // Bytes 30 and 31 encode the max age
    STAPacket[_802_3_HEADER_SIZE + 29] = (UCHAR)(pbpdu->MaxAge >> 8);
    STAPacket[_802_3_HEADER_SIZE + 30] = (UCHAR)(pbpdu->MaxAge);

    // Bytes 32 and 33 encode the hello time
    STAPacket[_802_3_HEADER_SIZE + 31] = (UCHAR)(pbpdu->HelloTime >> 8);
    STAPacket[_802_3_HEADER_SIZE + 32] = (UCHAR)(pbpdu->HelloTime);

    // Bytes 34 and 35 encode the forward delay
    STAPacket[_802_3_HEADER_SIZE + 33] = (UCHAR)(pbpdu->ForwardDelay >> 8);
    STAPacket[_802_3_HEADER_SIZE + 34] = (UCHAR)(pbpdu->ForwardDelay);

    // Send the finished packet
    Status = BrdgFwdSendBuffer( pAdapt, STAPacket, sizeof(STAPacket) );

    if( Status != NDIS_STATUS_SUCCESS )
    {
        THROTTLED_DBGPRINT(STA, ("BPDU packet send failed: %08x\n", Status));
    }
}

VOID
BrdgSTATransmitTCNPacket()
/*++

Routine Description:

    Transmits a Topology Change Notification BPDU packet on the root adapter

Arguments:

    None

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has NOT acquired gSTALock

--*/
{
    UCHAR                           STAPacket[TCN_BPDU_PACKET_SIZE + _802_3_HEADER_SIZE];
    NDIS_STATUS                     Status;
    PADAPT                          pRootAdapter;
    BOOLEAN                         bAcquired;

    if (BrdgProtGetAdapterCount() < 2)
    {
        return;
    }

    if (!BrdgFwdBridgingNetworks())
    {
        DBGPRINT(STA, ("Not Transmitting STA Packet (we're not bridging)\r\n"));
        return;
    }

    NdisAcquireSpinLock( &gSTALock );

    // Freeze this value for the rest of the function
    pRootAdapter = gRootAdapter;

    if( pRootAdapter == NULL )
    {
        NdisReleaseSpinLock( &gSTALock );
        return;
    }

    bAcquired = BrdgAcquireAdapter( pRootAdapter );
    NdisReleaseSpinLock( &gSTALock );

    if( ! bAcquired )
    {
        SAFEASSERT( FALSE );
        return;
    }

    SAFEASSERT( gHaveID );

    //
    // First encode the Ethernet header.
    //
    // Destination MAC address of packet must be STA multicast address
    STAPacket[0] = STA_MAC_ADDR[0];
    STAPacket[1] = STA_MAC_ADDR[1];
    STAPacket[2] = STA_MAC_ADDR[2];
    STAPacket[3] = STA_MAC_ADDR[3];
    STAPacket[4] = STA_MAC_ADDR[4];
    STAPacket[5] = STA_MAC_ADDR[5];

    // Set the packet's MAC address to the adapter's own MAC address
    STAPacket[6] = pRootAdapter->MACAddr[0];
    STAPacket[7] = pRootAdapter->MACAddr[1];
    STAPacket[8] = pRootAdapter->MACAddr[2];
    STAPacket[9] = pRootAdapter->MACAddr[3];
    STAPacket[10] = pRootAdapter->MACAddr[4];
    STAPacket[11] = pRootAdapter->MACAddr[5];

    // Next two bytes are the size of the frame (7 bytes)
    STAPacket[12] = 0x00;
    STAPacket[13] = 0x07;

    // Next two bytes are the LLC DSAP and SSAP fields, set to 0x42 for STA
    STAPacket[14] = 0x42;
    STAPacket[15] = 0x42;

    // Next byte is the LLC frame type, 3 for unnumbered
    STAPacket[16] = 0x03;

    //
    // Now we are encoding the payload.
    //
    // First 3 bytes are the protocol identifier and protocol version number, all zero
    STAPacket[_802_3_HEADER_SIZE] = STAPacket[_802_3_HEADER_SIZE + 1] =
        STAPacket[_802_3_HEADER_SIZE + 2] = 0x00;

    // Byte 4 is the BPDU type, which is 0x80 for TCN.
    STAPacket[_802_3_HEADER_SIZE + 3] = 0x80;

    // Send the finished packet
    Status = BrdgFwdSendBuffer( pRootAdapter, STAPacket, sizeof(STAPacket) );

    // We are done with the root adapter
    BrdgReleaseAdapter( pRootAdapter );

    if( Status != NDIS_STATUS_SUCCESS )
    {
        THROTTLED_DBGPRINT(STA, ("BPDU packet send failed: %08x\n", Status));
    }
}

VOID
BrdgSTACopyFromPacketToBuffer(
    OUT PUCHAR                      pPacketOut,
    IN ULONG                        BufferSize,
    OUT PULONG                      pWrittenCount,
    IN PNDIS_PACKET                 pPacketIn
    )
/*++

Routine Description:

    Copies data out of a packet descriptor into a flat buffer

Arguments:

    pPacketOut                      Data buffer to copy info
    BufferSize                      Size of pPacketOut
    pWrittenCount                   Number of bytes actually written
    pPacketIn                       Packet to copy from

Return Value:

    None

Locking Constraints:

    No requirements on caller-held locks

--*/
{
    PNDIS_BUFFER                    pBuf;

    *pWrittenCount = 0L;
    pBuf = BrdgBufPacketHeadBuffer(pPacketIn);

    while( pBuf != NULL )
    {
        PVOID                       pData;
        UINT                        Len;

        NdisQueryBufferSafe( pBuf, &pData, &Len, NormalPagePriority );

        if( pData != NULL )
        {
            ULONG                   BytesToWrite;

            if( *pWrittenCount + Len > BufferSize )
            {
                BytesToWrite = BufferSize - *pWrittenCount;
            }
            else
            {
                BytesToWrite = Len;
            }

            NdisMoveMemory( pPacketOut, pData, BytesToWrite );
            pPacketOut += BytesToWrite;
            *pWrittenCount += BytesToWrite;

            if( BytesToWrite < Len )
            {
                // We're full, so we're done.
                return;
            }
        }
        else
        {
            // Shouldn't happen
            SAFEASSERT( FALSE );
        }

        NdisGetNextBuffer( pBuf, &pBuf );
    }
}

VOID
BrdgSTATransmitConfig(
    PADAPT      pAdapt
    )
/*++

Routine Description:

    Transmits a config BPDU on a particular adapter. Collects appropriate
    information and calls BrdgSTATransmitConfigBPDUPacket().

Arguments:

    pAdapt                      The adapter to transmit on

Return Value:

    None

Locking Constraints:

    ASSUMES the caller DOES NOT hold gSTALock

--*/
{
    NdisAcquireSpinLock( &gSTALock );

    if( BrdgTimerIsRunning( &pAdapt->STAInfo.HoldTimer ) )
    {
        // We have sent a config packet recently. Wait until the hold timer
        // expires before sending another one so we don't flood other bridges.
        pAdapt->STAInfo.bConfigPending = TRUE;

        NdisReleaseSpinLock( &gSTALock );
    }
    else
    {
        CONFIG_BPDU     bpdu;

        // Fill out the BPDU information structure
        bpdu.Type = ConfigBPDU;
        SAFEASSERT( gHaveID );
        BrdgSTACopyID( bpdu.RootID, gDesignatedRootID );
        bpdu.RootCost = gRootCost;
        BrdgSTACopyID( bpdu.BridgeID, gOurID );
        bpdu.PortID = pAdapt->STAInfo.ID;

        if( BrdgSTAWeAreRoot() )
        {
            // We are the root, so the age of this config information is zero.
            bpdu.MessageAge = 0;
        }
        else
        {
            // The MessageAge field is to be set to the age of the last received
            // config BPDU on the root port.
            if( (gRootAdapter != NULL) && BrdgAcquireAdapter(gRootAdapter) )
            {
                ULONG       CurrentTime, deltaTime;

                NdisGetSystemUpTime( &CurrentTime );

                // The message age timer should be running on the root adapter if
                // we are not root.
                SAFEASSERT( BrdgTimerIsRunning(&gRootAdapter->STAInfo.MessageAgeTimer) );
                SAFEASSERT( gRootAdapter->STAInfo.LastConfigTime != 0L );

                // The last parameter is the max acceptable delta. We should have
                // received the last piece of config information from the root no more
                // than gMaxAge STA units ago, since if it was longer than that, we
                // should have become root. Allow an additional second for processing.
                deltaTime = BrdgDeltaSafe( gRootAdapter->STAInfo.LastConfigTime, CurrentTime,
                                           (ULONG)(((gMaxAge * 1000) / 256) + 1000) );

                // STA times are in 1/256ths of a second.
                bpdu.MessageAge = (STA_TIME)((deltaTime * 256) / 1000);

                // MESSAGE_AGE_INCREMENT allows for the transmission time, etc.
                bpdu.MessageAge += MESSAGE_AGE_INCREMENT;

                BrdgReleaseAdapter(gRootAdapter);
            }
            else
            {
                // Why isn't there a root port if we're not root?
                SAFEASSERT( FALSE );
                bpdu.MessageAge = 0;
            }

        }

        bpdu.MaxAge = gMaxAge;
        bpdu.HelloTime = gHelloTime;
        bpdu.ForwardDelay = gForwardDelay;

        // Are we supposed to acknowledge a topology change signal?
        bpdu.bTopologyChangeAck = pAdapt->STAInfo.bTopologyChangeAck;

        // We just sent out the topology change ack if there was one to send
        pAdapt->STAInfo.bTopologyChangeAck = FALSE;

        bpdu.bTopologyChange = gTopologyChange;

        // Start the hold timer to make sure another BPDU isn't sent prematurely
        pAdapt->STAInfo.bConfigPending = FALSE;

        // Don't send a packet with the spin lock held
        NdisReleaseSpinLock( &gSTALock );

        // Send off the config BPDU
        BrdgSTATransmitConfigBPDUPacket( pAdapt, &bpdu );

        BrdgSetTimer( &pAdapt->STAInfo.HoldTimer, HOLD_TIMER_PERIOD, FALSE /*Not periodic*/ );
    }
}

BOOLEAN
BrdgSTASupersedesPortInfo(
    IN PADAPT               pAdapt,
    IN PCONFIG_BPDU         pbpdu
    )
/*++

Routine Description:

    Determines whether a given bpdu's information supersedes the information
    already associated with a particular adapter

Arguments:

    pAdapt                  The adapter
    pbpdu                   Received BPDU information to examine

Return Value:

    TRUE if the given information supersedes (i.e., is better) than the information
    previously held by the adapter. FALSE otherwise.

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    INT                     cmp;

    /*  The information advertised on a given link supersedes the existing information for that
        link if the following conditions hold (applied in order; TRUE at any step causes immediate
        success)

        (1) The advertised root has a lower ID than the previous root
        (2) The advertised root is the same as the previous root and the new cost-to-root is
            lower than the previous value
        (3) The root IDs and costs are the same, and the ID of the advertising bridge is
            lower than the previous value
        (4) The root ID, cost-to-root and bridge IDs are the same and the advertising bridge
            is not us
        (5) The root ID, cost-to-root, bridge IDs are the same, the bridge is us, and the
            advertised port number is lower than the previous value (this happens if we have
            more than one port on the same physical link and we see the advertisement from
            our other port).
    */

    // Compare the advertised root ID to the adapter's previous designated root ID
    cmp = BrdgSTABridgeIDCmp( pbpdu->RootID, pAdapt->STAInfo.DesignatedRootID );

    if( cmp == -1 )                                                             // (1)
    {
        return TRUE;
    }
    else if( cmp == 0 )
    {
        if( pbpdu->RootCost < pAdapt->STAInfo.DesignatedCost )                  // (2)
        {
            return TRUE;
        }
        else if( pbpdu->RootCost == pAdapt->STAInfo.DesignatedCost )
        {
            // Compare the advertised bridge ID to the previous designated bridge ID
            cmp = BrdgSTABridgeIDCmp( pbpdu->BridgeID, pAdapt->STAInfo.DesignatedBridgeID );

            if( cmp == -1 )
            {
                return TRUE;                                                    // (3)
            }
            else if( cmp == 0 )
            {
                SAFEASSERT( gHaveID );

                // Compare the advertised bridge ID to our own ID
                cmp = BrdgSTABridgeIDCmp( pbpdu->BridgeID, gOurID );

                if( cmp != 0 )
                {
                    return TRUE;                                                // (4)
                }
                else if( cmp == 0 )
                {
                    return (BOOLEAN)(pbpdu->PortID <= pAdapt->STAInfo.DesignatedPort); // (5)
                }
            }
        }
    }

    return FALSE;
}

VOID
BrdgSTARecordConfigInfo(
    IN PADAPT               pAdapt,
    IN PCONFIG_BPDU         pbpdu
    )
/*++

Routine Description:

    Associates the information from a received BPDU with a particular adapter

Arguments:

    pAdapt                  The adapter
    pbpdu                   Received BPDU information to record

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    ULONG                   msgAgeInMs = (pbpdu->MessageAge / 256) * 1000;

    // Update the port's information with the new data
    BrdgSTACopyID( pAdapt->STAInfo.DesignatedRootID, pbpdu->RootID );
    pAdapt->STAInfo.DesignatedCost = pbpdu->RootCost;
    BrdgSTACopyID( pAdapt->STAInfo.DesignatedBridgeID, pbpdu->BridgeID );
    pAdapt->STAInfo.DesignatedPort = pbpdu->PortID;

    // Start the message age timer. It is specified to expire after
    // gMaxAge - MessageAge STA time units.
    if( pbpdu->MessageAge < gMaxAge )
    {
        BrdgSTASetTimerWithSTATime( &pAdapt->STAInfo.MessageAgeTimer,
                                    gMaxAge - pbpdu->MessageAge, FALSE /*Not periodic*/ );
    }
    else
    {
        // How odd. The message was already too old. Start the timer so that it
        // will expire immediately.

        THROTTLED_DBGPRINT(STA, ("Received over-age BPDU (%i / %i) on adapter %p", pbpdu->MessageAge,
                            gMaxAge, pAdapt));

        BrdgSTASetTimerWithSTATime( &pAdapt->STAInfo.MessageAgeTimer, 0, FALSE /*Not periodic*/ );
    }

    NdisGetSystemUpTime( &pAdapt->STAInfo.LastConfigTime );

    // Roll back by the age of the info we got.
    SAFEASSERT( msgAgeInMs < pAdapt->STAInfo.LastConfigTime );
    pAdapt->STAInfo.LastConfigTime -= msgAgeInMs;
}

VOID
BrdgSTARecordTimeoutInfo(
    IN PCONFIG_BPDU         pbpdu
    )
/*++

Routine Description:

    Records timeout information conveyed by a BPDU received from the root bridge

Arguments:

    pbpdu                   Received BPDU information to record

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    gMaxAge = pbpdu->MaxAge;
    gHelloTime = pbpdu->HelloTime;
    gForwardDelay = pbpdu->ForwardDelay;
    BrdgSTAUpdateTopologyChange( pbpdu->bTopologyChange );
}

VOID
BrdgSTAGenerateConfigBPDUs()
/*++

Routine Description:

    Sends configuration BPDUs out every designated port

Arguments:

    pbpdu                   Received BPDU information to record

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT hold gSTALock

--*/
{
    LOCK_STATE          LockState;
    PADAPT              Adapters[MAX_ADAPTERS];
    INT                 cmpID;
    PADAPT              pAdapt;
    UINT                numAdapters = 0, i;

    NdisAcquireSpinLock( &gSTALock );
    SAFEASSERT( gHaveID );
    NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*read only*/, &LockState );

    for( pAdapt = gAdapterList; pAdapt != NULL; pAdapt = pAdapt->Next )
    {
        if( (pAdapt->bSTAInited) && (pAdapt->State != Disabled) )
        {
            cmpID = BrdgSTABridgeIDCmp( pAdapt->STAInfo.DesignatedBridgeID, gOurID );

            if( (cmpID == 0) && (pAdapt->STAInfo.ID == pAdapt->STAInfo.DesignatedPort) )
            {
                // This adapter is a designated port. We will send a config BPDU out it.
                BrdgAcquireAdapterInLock( pAdapt );
                Adapters[numAdapters] = pAdapt;
                numAdapters++;
            }
        }
    }

    NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
    NdisReleaseSpinLock( &gSTALock );

    // Send a BPDU out every adapter that we chose
    for( i = 0; i < numAdapters; i++ )
    {
        BrdgSTATransmitConfig(Adapters[i]);
        BrdgReleaseAdapter(Adapters[i]);
    }
}

VOID
BrdgSTARootSelection()
/*++

Routine Description:

    Examines the information associated with every bridge port to determine
    the root bridge ID and root port

Arguments:

    None

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    LOCK_STATE          LockState;
    PADAPT              pAdapt, pRootAdapt = NULL;
    INT                 cmp;

    SAFEASSERT( gHaveID );
    NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*read only*/, &LockState );

    for( pAdapt = gAdapterList; pAdapt != NULL; pAdapt = pAdapt->Next )
    {
        if( (pAdapt->bSTAInited) &&  (pAdapt->State != Disabled) )
        {
            /*
                We consider the information advertised on each link to determine which port should
                be the new root port. If no link advertises sufficiently attractive information, we declare
                ourselves to be the root. A port is acceptable as the root port if all the following
                conditions hold:

                (1) The port receiving the advertisement must not be a designated port
                (2) The link's advertised root must have a lower ID than us
                (3) The link's advertised root ID must be lower than the advertised root ID on any other link
                (4) If the advertised root ID is the same as another advertised root, the cost-to-root
                    must be lower
                (5) If the root ID and cost are the same, the designated bridge on the port must have a
                    lower ID than the designated bridge on other ports (this chooses arbitrarily
                    between two bridges that can reach the root with the same cost)
                (6) If the root ID, cost-to-root and designated bridge IDs are the same, the designated
                    port must be less than on other ports (this happens if two links have the same
                    designated bridge)
                (7) If the root ID, cost-to-root, designated bridge ID and designated port IDs are all
                    the same, the port number of the port itself must be lower (this only happens if
                    we have more than one port onto the same physical link; we pick the lower-numbered
                    one as the root port)
            */

            cmp = BrdgSTABridgeIDCmp( pAdapt->STAInfo.DesignatedBridgeID, gOurID );

            if( (cmp != 0) || (pAdapt->STAInfo.ID != pAdapt->STAInfo.DesignatedPort) )          // (1)
            {
                cmp = BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedRootID, gOurID);

                if( cmp == -1 )                                                                 // (2)
                {
                    BOOLEAN         betterRoot = FALSE;

                    if( pRootAdapt == NULL )
                    {
                        // Hadn't seen a root better than ourselves before now; take this one.
                        betterRoot = TRUE;
                    }
                    else
                    {
                        // Compare the advertised root ID to our previous best
                        cmp = BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedRootID, pRootAdapt->STAInfo.DesignatedRootID);

                        if( cmp == -1 )                                                         // (3)
                        {
                            betterRoot = TRUE;
                        }
                        else if( cmp == 0 )
                        {
                            PATH_COST       thisCost = pAdapt->STAInfo.DesignatedCost + pAdapt->STAInfo.PathCost,
                                            prevBestCost = pRootAdapt->STAInfo.DesignatedCost + pRootAdapt->STAInfo.PathCost;

                            if( thisCost < prevBestCost )
                            {
                                betterRoot = TRUE;                                              // (4)
                            }
                            else if( thisCost == prevBestCost )
                            {
                                // Compare the IDs of the designated bridge
                                cmp = BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedBridgeID, pRootAdapt->STAInfo.DesignatedBridgeID);

                                if( cmp == -1 )
                                {
                                    betterRoot = TRUE;                                          // (5)
                                }
                                else if( cmp == 0 )
                                {
                                    if( pAdapt->STAInfo.DesignatedPort < pRootAdapt->STAInfo.DesignatedPort )
                                    {
                                        betterRoot = TRUE;                                      // (6)
                                    }
                                    else if( pAdapt->STAInfo.DesignatedPort == pRootAdapt->STAInfo.DesignatedPort )
                                    {
                                        if( pAdapt->STAInfo.ID < pRootAdapt->STAInfo.ID )
                                        {
                                            betterRoot = TRUE;                                  // (7)
                                        }
                                        else
                                        {
                                            // Sanity-check that the two adapters' IDs are different!
                                            SAFEASSERT( pAdapt->STAInfo.ID != pRootAdapt->STAInfo.ID );
                                        }
                                    }
                                }
                            }
                        }
                    }

                    if( betterRoot )
                    {
                        // We have a better root port.
                        pRootAdapt = pAdapt;
                    }
                }
            }
        }
    }

    if( pRootAdapt == NULL )
    {
        gRootAdapter = NULL;
        BrdgSTACopyID( gDesignatedRootID, gOurID );
        gRootCost = 0;
    }
    else
    {
        gRootAdapter = pRootAdapt;
        BrdgSTACopyID( gDesignatedRootID, pRootAdapt->STAInfo.DesignatedRootID );
        gRootCost = pRootAdapt->STAInfo.DesignatedCost + pRootAdapt->STAInfo.PathCost;
    }

    NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
}

VOID
BrdgSTABecomeDesignatedPort(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Sets the information associated with an adapter to make it a designated port

Arguments:

    pAdapt              The adapter to make designated

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    SAFEASSERT( gHaveID );
    BrdgSTACopyID( pAdapt->STAInfo.DesignatedRootID, gDesignatedRootID );
    pAdapt->STAInfo.DesignatedCost = gRootCost;
    BrdgSTACopyID( pAdapt->STAInfo.DesignatedBridgeID, gOurID );
    pAdapt->STAInfo.DesignatedPort = pAdapt->STAInfo.ID;
}

VOID
BrdgSTADesignatedPortSelection()
/*++

Routine Description:

    Examines the information associated with each port to determine
    which should become designated ports

Arguments:

    None

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    LOCK_STATE          LockState;
    PADAPT              pAdapt;
    INT                 cmp;

    SAFEASSERT( gHaveID );
    NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*read only*/, &LockState );

    for( pAdapt = gAdapterList; pAdapt != NULL; pAdapt = pAdapt->Next )
    {
        if( pAdapt->bSTAInited )
        {
            BOOLEAN         becomeDesignated = FALSE;

            /*  We consider each port to determine whether it should become a designated port
                (if it previously was not one). A port becomes a designated port if the
                following conditions hold:

                (1) The port is the link's designated port by advertised info
                (2) The link's previous designated root is not the correct root
                (3) Our cost-to-root is lower than the current cost advertised on the link
                (4) We have a same cost-to-root but a lower ID than the current designated
                    bridge on the link
                (5) We have the same cost-to-root and ID as the designated bridge on the link
                    but a lower port number (this only happens if we have two or more ports
                    on the same physical link)
            */

            // See if the link's designated bridge is already us
            cmp = BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedBridgeID, gOurID);

            if( (cmp == 0) && (pAdapt->STAInfo.DesignatedPort == pAdapt->STAInfo.ID) )
            {
                becomeDesignated = TRUE;                                    // (1)
            }
            else
            {
                // Compare the link's advertised root to the one we believe is root
                cmp = BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedRootID, gDesignatedRootID);

                if( cmp != 0 )
                {
                    becomeDesignated = TRUE;                                    // (2)
                }
                else if( gRootCost < pAdapt->STAInfo.DesignatedCost )
                {
                    becomeDesignated = TRUE;                                    // (3)
                }
                else if( gRootCost == pAdapt->STAInfo.DesignatedCost )
                {
                    // Compare the link's designated bridge to our own ID
                    cmp = BrdgSTABridgeIDCmp(gOurID, pAdapt->STAInfo.DesignatedBridgeID);

                    if( cmp == -1 )
                    {
                        becomeDesignated = TRUE;                                // (4)
                    }
                    else if( cmp == 0 )
                    {
                        if( pAdapt->STAInfo.ID < pAdapt->STAInfo.DesignatedPort )
                        {
                            becomeDesignated = TRUE;                            // (5)
                        }
                        else
                        {
                            // If this SAFEASSERT fires, we should have succeeded on test (1)
                            SAFEASSERT( pAdapt->STAInfo.ID > pAdapt->STAInfo.DesignatedPort );
                        }
                    }
                }
            }

            if( becomeDesignated )
            {
                BrdgSTABecomeDesignatedPort( pAdapt );
            }
        }
    }

    NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
}

BOOLEAN
BrdgSTATopologyChangeDetected()
/*++

Routine Description:

    Takes appropriate action when a topology change is detected. If we are
    the root, this consists of setting the TopologyChange flag in future
    BPDUs until the expiry of the gTopologyChangeTimer. If we are not the
    root, this consists of sending a TCN BPDU periodically until it is
    acknowledged

Arguments:

    None

Return Value:

    TRUE means the caller should arrange to send a TCN BPDU from outside the
    gSTALock. FALSE means it is not necessary to send such a packet.

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    BOOLEAN         rc = FALSE;

    if( BrdgSTAWeAreRoot() )
    {
        BrdgSTAUpdateTopologyChange( TRUE );
        BrdgSTASetTimerWithSTATime( &gTopologyChangeTimer, DEFAULT_MAX_AGE + DEFAULT_FORWARD_DELAY, FALSE /*Not periodic*/ );
    }
    else
    {
        rc = TRUE;
        BrdgSTASetTimerWithSTATime( &gTopologyChangeNotificationTimer, DEFAULT_HELLO_TIME, FALSE /*Not periodic*/ );
    }

    gTopologyChangeDetected = TRUE;

    return rc;
}

VOID
BrdgSTAMakeForwarding(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Starts the process of putting an adapter in the forwarding state.

    Adapters must pass through the Listening and Learning states before entering
    the Forwarding state.

Arguments:

    pAdapt              The adapter

Return Value:

    None

Locking Constraints:

    None

--*/
{
    if( pAdapt->State == Blocking )
    {
        BrdgSTASetAdapterState( pAdapt, Listening );
        BrdgSTASetTimerWithSTATime( &pAdapt->STAInfo.ForwardDelayTimer, gForwardDelay, FALSE /*Not periodic*/ );
    }
}

BOOLEAN
BrdgSTAMakeBlocking(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Puts an adapter in the blocking state

Arguments:

    pAdapt              The adapter

Return Value:

    TRUE means the caller should arrange to send a TCN BPDU from outside the
    gSTALock. FALSE means it is not necessary to send such a packet.

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    BOOLEAN             rc = FALSE;

    if( pAdapt->State != Blocking )
    {
        if( (pAdapt->State == Forwarding) ||
            (pAdapt->State == Learning) )
        {
            rc = BrdgSTATopologyChangeDetected();
        }

        BrdgSTASetAdapterState( pAdapt, Blocking );
        BrdgCancelTimer( &pAdapt->STAInfo.ForwardDelayTimer );
    }

    return rc;
}

BOOLEAN
BrdgSTAPortStateSelection()
/*++

Routine Description:

    Examines all ports and puts them in an appropriate state

Arguments:

    None

Return Value:

    TRUE means the caller should arrange to send a TCN BPDU from outside the
    gSTALock. FALSE means it is not necessary to send such a packet.

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    BOOLEAN             rc = FALSE;
    LOCK_STATE          LockState;
    PADAPT              pAdapt;

    SAFEASSERT( gHaveID );

    NdisAcquireReadWriteLock( &gAdapterListLock, FALSE /*read only*/, &LockState );

    for( pAdapt = gAdapterList; pAdapt != NULL; pAdapt = pAdapt->Next )
    {
        if( pAdapt->bSTAInited )
        {
            if( pAdapt == gRootAdapter )
            {
                pAdapt->STAInfo.bConfigPending = FALSE;
                pAdapt->STAInfo.bTopologyChangeAck = FALSE;
                BrdgSTAMakeForwarding( pAdapt );
            }
            else if( (BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedBridgeID, gOurID) == 0) &&
                     (pAdapt->STAInfo.DesignatedPort == pAdapt->STAInfo.ID) )
            {
                // This port is a designated port.
                BrdgCancelTimer( &pAdapt->STAInfo.MessageAgeTimer );
                pAdapt->STAInfo.LastConfigTime = 0L;
                BrdgSTAMakeForwarding( pAdapt );
            }
            else
            {
                pAdapt->STAInfo.bConfigPending = FALSE;
                pAdapt->STAInfo.bTopologyChangeAck = FALSE;
                rc = BrdgSTAMakeBlocking( pAdapt );
            }
        }
    }

    NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );

    return rc;
}

VOID
BrdgSTATopologyChangeAcknowledged()
/*++

Routine Description:

    Called when we receive an acknowledgement from the root bridge that
    our topology change notification has been noted.

Arguments:

    None

Return Value:

    None

Locking Constraints:

    ASSUMES the caller has acquired gSTALock

--*/
{
    DBGPRINT(STA, ("BrdgSTATopologyChangeAcknowledged\n"));
    gTopologyChangeDetected = FALSE;
    BrdgCancelTimer( &gTopologyChangeNotificationTimer );
}

VOID
BrdgSTAAcknowledgeTopologyChange(
    IN PADAPT       pAdapt
    )
/*++

Routine Description:

    Called when we are the root bridge to send a config BPDU acknowledging
    another bridge's topology change notification

Arguments:

    pAdapt          The adapter on which the TCN was received

Return Value:

    None

Locking Constraints:

    ASSUMES the caller DOES NOT have gSTALock

--*/
{
    DBGPRINT(STA, ("BrdgSTAAcknowledgeTopologyChange\n"));
    pAdapt->STAInfo.bTopologyChangeAck = TRUE;
    BrdgSTATransmitConfig( pAdapt );
}

VOID
BrdgSTAProcessConfigBPDU(
    IN PADAPT       pAdapt,
    IN PCONFIG_BPDU pbpdu
    )
/*++

Routine Description:

    Processes received BPDU information

Arguments:

    pAdapt          The adapter on which the BPDU was received
    pbpdu           The received information

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    BOOLEAN         bWasRoot;

    NdisAcquireSpinLock( &gSTALock );

    bWasRoot = BrdgSTAWeAreRoot();

    if( BrdgSTASupersedesPortInfo(pAdapt, pbpdu) )
    {
        BOOLEAN     bTransmitTCN = FALSE;

        // The new information is better than what we had before. Use it.
        BrdgSTARecordConfigInfo(pAdapt, pbpdu);
        BrdgSTAConfigUpdate();
        bTransmitTCN = BrdgSTAPortStateSelection();

        if( bWasRoot && (! BrdgSTAWeAreRoot()) )
        {
            // We used to be the root bridge but now we're not!
            DBGPRINT(STA, ("Saw superseding information that made us NOT root on adapter %p\n", pAdapt));

            BrdgCancelTimer( &gHelloTimer );

            if( gTopologyChangeDetected )
            {
                BrdgCancelTimer( &gTopologyChangeTimer );
                bTransmitTCN = TRUE;
                BrdgSTASetTimerWithSTATime( &gTopologyChangeNotificationTimer, DEFAULT_HELLO_TIME, FALSE /*Not periodic*/ );
            }
        }

        if( pAdapt == gRootAdapter )
        {
            // This is the root port. Heed config information from the root and pass along
            // its information.
            BrdgSTARecordTimeoutInfo( pbpdu );

            if( pbpdu->bTopologyChangeAck )
            {
                BrdgSTATopologyChangeAcknowledged();
            }

            // Don't send packets from inside the spin lock
            NdisReleaseSpinLock( &gSTALock );

            BrdgSTAGenerateConfigBPDUs();
        }
        else
        {
            NdisReleaseSpinLock( &gSTALock );
        }

        if( bTransmitTCN )
        {
            BrdgSTATransmitTCNPacket();
        }
    }
    else
    {
        // The received information does not supersede our previous info
        SAFEASSERT( gHaveID );

        if( (BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedBridgeID, gOurID) == 0) &&
            (pAdapt->STAInfo.DesignatedPort == pAdapt->STAInfo.ID) )
        {
            NdisReleaseSpinLock( &gSTALock );

            // This is the designated port for this link, and the information we just received
            // is inferior to the information we already have. Reply by sending out our own info.
            BrdgSTATransmitConfig(pAdapt);
        }
        else
        {
            NdisReleaseSpinLock( &gSTALock );
        }
    }
}

VOID
BrdgSTAProcessTCNBPDU(
    IN PADAPT           pAdapt
    )
/*++

Routine Description:

    Processes a received TopologyChangeNotification BPDU

Arguments:

    pAdapt          The adapter on which the TCN was received

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    DBGPRINT(STA, ("BrdgSTAProcessTCNBPDU()\n"));
    SAFEASSERT( gHaveID );

    NdisAcquireSpinLock( &gSTALock );

    if( (BrdgSTABridgeIDCmp(pAdapt->STAInfo.DesignatedBridgeID, gOurID) == 0) &&
        (pAdapt->STAInfo.DesignatedPort == pAdapt->STAInfo.ID) )
    {
        BOOLEAN             bTransmitTCN = FALSE;

        // This is a designated port.
        bTransmitTCN = BrdgSTATopologyChangeDetected();
        NdisReleaseSpinLock( &gSTALock );

        if( bTransmitTCN )
        {
            BrdgSTATransmitTCNPacket();
        }

        BrdgSTAAcknowledgeTopologyChange(pAdapt);
    }
    else
    {
        NdisReleaseSpinLock( &gSTALock );
    }
}

VOID
BrdgSTAHelloTimerExpiry(
    IN PVOID            Unused
    )
/*++

Routine Description:

    Called when the Hello Timer expires. Sends another Config BPDU.

Arguments:

    Unused

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    BrdgSTAGenerateConfigBPDUs();
}

VOID
BrdgSTAMessageAgeTimerExpiry(
    IN PVOID            Context
    )
/*++

Routine Description:

    Called when the Message Age Timer expires. Recalculates STA information
    given the fact that no bridge is being heard on the given port anymore.

Arguments:

    Context             The adapter on which the timer expired

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    PADAPT              pAdapt;
    BOOLEAN             bWasRoot, bTransmitTCN = FALSE;

    NdisAcquireSpinLock( &gSTALock );

    pAdapt = (PADAPT)Context;
    pAdapt->STAInfo.LastConfigTime = 0L;
    bWasRoot = BrdgSTAWeAreRoot();

    BrdgSTABecomeDesignatedPort(pAdapt);
    BrdgSTAConfigUpdate();
    bTransmitTCN = BrdgSTAPortStateSelection();

    if( BrdgSTAWeAreRoot() && (! bWasRoot) )
    {
        DBGPRINT(STA, ("Became root through message age timer expiry of %p\n", pAdapt));

        // We just became root.
        gMaxAge = DEFAULT_MAX_AGE;
        gHelloTime = DEFAULT_HELLO_TIME;
        gForwardDelay = DEFAULT_FORWARD_DELAY;

        bTransmitTCN = BrdgSTATopologyChangeDetected();
        BrdgCancelTimer( &gTopologyChangeNotificationTimer );

        NdisReleaseSpinLock( &gSTALock );

        BrdgSTAGenerateConfigBPDUs();
        BrdgSTASetTimerWithSTATime( &gHelloTimer, gHelloTime, TRUE /*Periodic*/ );
    }
    else
    {
        NdisReleaseSpinLock( &gSTALock );
    }

    if( bTransmitTCN )
    {
        BrdgSTATransmitTCNPacket();
    }
}

VOID
BrdgSTAForwardDelayTimerExpiry(
    IN PVOID            Context
    )
/*++

Routine Description:

    Called when the Forward Delay Timer expires. Continues stepping an
    adapter through the process of becoming Forwarding.

Arguments:

    Context             The adapter on which the timer expired

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    PADAPT              pAdapt = (PADAPT)Context;
    BOOLEAN             bTransmitTCN = FALSE;

    NdisAcquireSpinLock( &gSTALock );

    SAFEASSERT( gHaveID );

    if( pAdapt->State == Listening )
    {
        // Move to learning state
        BrdgSTASetAdapterState( pAdapt, Learning );
        BrdgSTASetTimerWithSTATime( &pAdapt->STAInfo.ForwardDelayTimer, gForwardDelay, FALSE /*Not periodic*/ );
    }
    else if( pAdapt->State == Learning )
    {
        LOCK_STATE      LockState;
        PADAPT          anAdapt;

        // Move to forwarding state
        BrdgSTASetAdapterState( pAdapt, Forwarding );

        // If we are the designated port on any link, we need to signal a topology change
        // notification.
        NdisAcquireReadWriteLock( &gAdapterListLock, FALSE/*Read-only*/, &LockState );

        for( anAdapt = gAdapterList; anAdapt != NULL; anAdapt = anAdapt->Next )
        {
            if( anAdapt->bSTAInited )
            {
                if( BrdgSTABridgeIDCmp(anAdapt->STAInfo.DesignatedBridgeID, gOurID) == 0 )
                {
                    bTransmitTCN = BrdgSTATopologyChangeDetected();
                }
            }
        }

        NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
    }

    NdisReleaseSpinLock( &gSTALock );

    if( bTransmitTCN )
    {
        BrdgSTATransmitTCNPacket();
    }
}

VOID
BrdgSTATopologyChangeNotificationTimerExpiry(
    IN PVOID            Unused
    )
/*++

Routine Description:

    Called when the Topology Change Notification Timer expires.
    Transmits another TCN packet.

Arguments:

    Unused

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    if (BrdgFwdBridgingNetworks())
    {
        BrdgSTATransmitTCNPacket();
        BrdgSTASetTimerWithSTATime( &gTopologyChangeNotificationTimer, DEFAULT_HELLO_TIME, FALSE /*Not periodic*/ );
    }
}

VOID
BrdgSTATopologyChangeTimerExpiry(
    IN PVOID            Unused
    )
/*++

Routine Description:

    Called when the Topology Change Timer expires. Stops setting the TopologyChange
    flag in outbound Config BPDUs.

Arguments:

    Unused

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    NdisAcquireSpinLock( &gSTALock );
    gTopologyChangeDetected = FALSE;
    BrdgSTAUpdateTopologyChange( FALSE );
    NdisReleaseSpinLock( &gSTALock );
}

VOID
BrdgSTAHoldTimerExpiry(
    IN PVOID            Context
    )
/*++

Routine Description:

    Called when the Hold Timer expires. Sends a Config BPDU.

Arguments:

    Context             The adapter on which the timer expired

Return Value:

    None

Locking Constraints:

    ASSUMES the caller does NOT have gSTALock

--*/
{
    PADAPT              pAdapt = (PADAPT)Context;

    NdisAcquireSpinLock( &gSTALock );

    if( pAdapt->STAInfo.bConfigPending )
    {
        NdisReleaseSpinLock( &gSTALock );
        BrdgSTATransmitConfig( pAdapt );
    }
    else
    {
        NdisReleaseSpinLock( &gSTALock );
    }
}

VOID
BrdgSTACancelTimersGPO()
{
    LOCK_STATE LockState;
    PADAPT pAdapt = NULL;

    //
    // We need to cancel the general STA timers.
    //
    BrdgCancelTimer( &gTopologyChangeTimer );
    BrdgCancelTimer( &gTopologyChangeNotificationTimer );
    BrdgCancelTimer( &gHelloTimer );

    //
    // And the individual HoldTimers and MessageAgeTimers
    //
    NdisAcquireReadWriteLock( &gAdapterListLock, FALSE/*Read-only*/, &LockState );
    
    for( pAdapt = gAdapterList; pAdapt != NULL; pAdapt = pAdapt->Next )
    {
        // This will only cancel the timer if it is running.
        BrdgCancelTimer(&pAdapt->STAInfo.HoldTimer);
        BrdgCancelTimer(&pAdapt->STAInfo.MessageAgeTimer);
    }

    NdisReleaseReadWriteLock( &gAdapterListLock, &LockState );
}

VOID
BrdgSTARestartTimersGPO()
{
    BrdgSTASetTimerWithSTATime( &gHelloTimer, gHelloTime, TRUE );
}

VOID
BrdgSTAResetSTAInfoGPO()
{
    BOOLEAN PortSelection = FALSE;
    
    NdisAcquireSpinLock(&gSTALock);

    PortSelection = BrdgSTAPortStateSelection();

    // Release the spinlock before we send packets over the wire.
    NdisReleaseSpinLock(&gSTALock);

    BrdgSTASetTimerWithSTATime( &gTopologyChangeNotificationTimer, DEFAULT_HELLO_TIME, FALSE /*Not periodic*/ );
    
    if (PortSelection)
    { 
       BrdgSTATransmitTCNPacket();
    }

    if (!BrdgSTAWeAreRoot())
    {
        // Set the timer on the root adapter to expire immediately, this will force us to re-determine
        // our state.
        BrdgSTASetTimerWithSTATime( &gRootAdapter->STAInfo.MessageAgeTimer, 0, FALSE /*Not periodic*/ );
    }
    else
    {
        BrdgSTAGenerateConfigBPDUs();
    }
    BrdgSTARestartTimersGPO();
}