windows-xp/Source/XPSP1/NT/net/rras/ip/rtrmgr/if.c

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    routing\ip\rtrmgr\if.c

Abstract:

    IP Router Manager interface related functions

Revision History:

    Gurdeep Singh Pall          6/26/95  Created

--*/

#include "allinc.h"

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
// The interface state machine:                                             //
//                                                                          //
//                           ----------                                     //
//                          | Unbound  |                                    //
//             ------------>| Disabled |<---------------                    //
//            |              ----------                 |                   //
//            V                                         V                   //
//       ----------                                  ---------              //
//      | Bound    |                                | Unbound |             //
//      | Disabled |                                | Enabled |             //
//       ----------                                  ---------              //
//           ^                                          ^                   //
//           |               ---------                  |                   //
//            ------------->| Bound   |<----------------                    //
//                          | Enabled |                                     //
//                           ---------                                      //
//                                                                          //
//                                                                          //
//  LAN interfaces:                                                         //
//                                                                          //
//  Characteristics    UP (Operational)    DOWN (Non-Operational)           //
//  ------------------------------------------------------------------      //
//  Binding (IP Address)    Yes                 No                          //
//  Protocols Added         Yes                 Yes                         //
//  Static Routes           Yes                 No                          //
//  Other Routes            Yes                 No                          //
//  Added to Filter Driver  Yes                 Yes                         //
//  Filters                 Added               Not added                   //
//  Filter Ctxt in IP Stack Set (Valid)         Not Set (Invalid)           //
//  Router Discovery        Active (if necc)    Inactive                    //
//  Adapter ID (and Map)    Valid               Invalid                     //
//                                                                          //
//  WAN interfaces:                                                         //
//                                                                          //
//  Characteristics       CONNECTED     DISCON/CONNECTING     UNREACHABLE   //
//  -------------------------------------------------------------------     //
//  Binding (IP Address)    Yes             No                  No          //
//  Protocols Added         Yes             Yes                 Yes         //
//  Static Routes           Yes             Yes                 No          //
//  Other Routes            Yes             No                  No          //
//  Added to Filter Driver  Yes             Yes                 Yes         //
//  Filters                 Yes             Yes                 No          //
//  Filter Ctxt in IP Stack Set (Valid)     Not Set (Invalid)   Not Set     //
//  Router Discovery        Active          Inactive            Inactive    //
//  Adapter ID (and Map)    Valid           Invalid             Invalid     //
//                                                                          //
//  Enabled/Disabled depends upon the AdminState and not upon the           //
//  operational state                                                       //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////


PICB
CreateIcb(
    PWSTR                   pwszInterfaceName,
    HANDLE                  hDIMInterface,
    ROUTER_INTERFACE_TYPE   InterfaceType,
    DWORD                   dwAdminState,
    DWORD                   dwIfIndex OPTIONAL
    )

/*++

Routine Description

    This function creates an interface control block

Locks

    None

Arguments

    None

Return Value

    None    

--*/

{
    DWORD           dwResult;
    PICB            pNewInterfaceCb;
    GUID            Guid;

    //
    // Make sure this is a valid name
    //

    if(InterfaceType is ROUTER_IF_TYPE_TUNNEL1)
    {
        UNICODE_STRING  usTempName;

        //
        // For now only these interfaces are GUIDs
        //

        usTempName.Length        = wcslen(pwszInterfaceName) * sizeof(WCHAR);
        usTempName.MaximumLength = usTempName.Length + sizeof(WCHAR);
        usTempName.Buffer        = pwszInterfaceName;

        if(RtlGUIDFromString(&usTempName,
                             &Guid) isnot STATUS_SUCCESS)
        {
            Trace1(ERR,
                   "CreateIcb: %S is not a GUID\n",
                   pwszInterfaceName);
 
            return NULL;
        }
    }

    //
    // Allocate an ICB
    //
   
    dwResult = AllocateIcb(pwszInterfaceName,
                           &pNewInterfaceCb);

    if(dwResult isnot NO_ERROR)
    {
        return NULL;
    }

    pNewInterfaceCb->dwIfIndex    = INVALID_IF_INDEX;
    pNewInterfaceCb->hDIMHandle   = hDIMInterface;
    pNewInterfaceCb->ritType      = InterfaceType;
    pNewInterfaceCb->dwMcastTtl   = 1;


    //
    // "Unique" interface ID used for ICBs.
    // This ID is passed to WANARP and DIM and they in
    // turn pass this back to Router Manager when 
    // requesting/indicating actions on the interface.
    //
    
    pNewInterfaceCb->dwSeqNumber = g_dwNextICBSeqNumberCounter;


    //
    // Initialize the filter, and wanarp contexts to invalid values
    // (NAT invalid is NULL)
    //

    pNewInterfaceCb->ihFilterInterface         = INVALID_HANDLE_VALUE;
    pNewInterfaceCb->ihDemandFilterInterface   = INVALID_HANDLE_VALUE;

    //
    // Initialize the lists of which async notifications and
    // the protocol blocks are queued
    //
    
    InitializeListHead(&pNewInterfaceCb->lePendingResultList);
    InitializeListHead(&pNewInterfaceCb->leProtocolList);

    //
    // Since we HEAP zeroed the ICB, all our binding related
    // stuff is already zero, the bBound is FALSE and dwNumAddress is 0
    // The adapter id was set to invalid in InitializeInterfaceContext
    //


    //
    // set the operational status based on the interface type
    // Also figure out the interface index
    //

    dwResult = NO_ERROR;
    
    switch(pNewInterfaceCb->ritType) 
    {
        case ROUTER_IF_TYPE_CLIENT:
        {
            //
            // Clients come up in connecting, since we dont get a LINE_UP for
            // them.  We also set the notification flags to fake the LINE UP
            //

            pNewInterfaceCb->dwAdminState       = IF_ADMIN_STATUS_UP;
            pNewInterfaceCb->dwOperationalState = CONNECTING; 
            pNewInterfaceCb->nitProtocolType    = REMOTE_WORKSTATION_DIAL;

            SetNdiswanNotification(pNewInterfaceCb);

            pNewInterfaceCb->dwBCastBit       = 1;
            pNewInterfaceCb->dwReassemblySize = DEFAULT_MTU;

            //
            // We dont really care about dial out ifIndex
            // so clients will have an index of -1 (since we init to -1)
            //
            
            break;
        }

        case ROUTER_IF_TYPE_HOME_ROUTER:
        case ROUTER_IF_TYPE_FULL_ROUTER:
        {
            //
            // HOME and FULL routers are disconnected
            //

            pNewInterfaceCb->dwAdminState       = dwAdminState;
            pNewInterfaceCb->dwOperationalState = DISCONNECTED;
            pNewInterfaceCb->nitProtocolType    = DEMAND_DIAL;

            pNewInterfaceCb->dwBCastBit       = 1;
            pNewInterfaceCb->dwReassemblySize = DEFAULT_MTU;

            //
            // WANARP reserves and index when we add an interface to it
            //
            
            dwResult = AddInterfaceToWanArp(pNewInterfaceCb);

            break;
        }

        case ROUTER_IF_TYPE_DEDICATED:
        {
            //
            // LAN interfaces come up as NON_OPERATIONAL. If the admin
            // wants them up we will try to do a LanInterfaceDownToUp()
            // If that succeeds, it will set the operational state
            // correctly
            //

            pNewInterfaceCb->dwAdminState       = dwAdminState;
            pNewInterfaceCb->dwOperationalState = NON_OPERATIONAL;
            pNewInterfaceCb->nitProtocolType    = PERMANENT;

            dwResult = NhpGetInterfaceIndexFromStack(
                            pNewInterfaceCb->pwszName,
                            &(pNewInterfaceCb->dwIfIndex)
                            );

            break;
        }

        case ROUTER_IF_TYPE_INTERNAL:
        {
            
            pNewInterfaceCb->dwAdminState       = IF_ADMIN_STATUS_UP;
            pNewInterfaceCb->dwOperationalState = DISCONNECTED;
            pNewInterfaceCb->nitProtocolType    = LOCAL_WORKSTATION_DIAL;

            pNewInterfaceCb->dwBCastBit       = 1;
            pNewInterfaceCb->dwReassemblySize = DEFAULT_MTU;

            //
            // WANARP reserves and index when we add an interface to it
            //
            
            dwResult = AddInterfaceToWanArp(pNewInterfaceCb);

            break;
        }
        
        case ROUTER_IF_TYPE_LOOPBACK:
        {
            
            pNewInterfaceCb->dwAdminState       = IF_ADMIN_STATUS_UP;
            pNewInterfaceCb->dwOperationalState = OPERATIONAL;
            pNewInterfaceCb->nitProtocolType    = PERMANENT;

            //
            // Note that IP uses 1
            //

            pNewInterfaceCb->dwIfIndex = LOOPBACK_INTERFACE_INDEX;
            
            break;
        }

        case ROUTER_IF_TYPE_TUNNEL1:
        {
  
            pNewInterfaceCb->dwAdminState       = dwAdminState;
            pNewInterfaceCb->dwOperationalState = NON_OPERATIONAL;
            pNewInterfaceCb->nitProtocolType    = PERMANENT;

            pNewInterfaceCb->dwBCastBit       = 1;
            pNewInterfaceCb->dwReassemblySize = DEFAULT_MTU;

            //
            // IP in IP does the same thing as WANARP
            //

            dwResult = AddInterfaceToIpInIp(&Guid,
                                            pNewInterfaceCb);

            break;
        }

        case ROUTER_IF_TYPE_DIALOUT:
        {
            //
            // Dial out interface are not known to DIM. We learn about
            // them via a back door mechanism.
            //

            IpRtAssert(dwIfIndex isnot INVALID_IF_INDEX);
            IpRtAssert(dwIfIndex isnot 0);

            pNewInterfaceCb->dwAdminState       = IF_ADMIN_STATUS_UP;
            pNewInterfaceCb->dwOperationalState = CONNECTED;
            pNewInterfaceCb->nitProtocolType    = REMOTE_WORKSTATION_DIAL;
            pNewInterfaceCb->dwIfIndex          = dwIfIndex;

            pNewInterfaceCb->dwBCastBit       = 1;
            pNewInterfaceCb->dwReassemblySize = DEFAULT_MTU;

            break;
        }

         
        default:
        {
            IpRtAssert(FALSE);

            break;
        }
    }

    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "CreateIcb: Error %d in getting index for %S\n",
               dwResult,
               pNewInterfaceCb->pwszName);

        HeapFree(IPRouterHeap,
                 0,
                 pNewInterfaceCb);

        return NULL;
    }
        
    //
    // Once the interface index is done we can Initialize the bindings
    //

    dwResult = CreateBindingForNewIcb(pNewInterfaceCb);

    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "CreateIcb: Error %d in creating binding for %S\n",
               dwResult,
               pNewInterfaceCb->pwszName);

        HeapFree(IPRouterHeap, 
                 0,
                 pNewInterfaceCb);

        return NULL;
    }

    return pNewInterfaceCb;
}

DWORD
AllocateIcb(
    PWCHAR  pwszName,
    ICB     **ppIcb
    )

/*++

Routine Description

    Allocates memory for the ICB

Locks

    None

Arguments

    pwszName    Interface name
    ppIcb       OUT: pointer to allocate ICB

Return Value

    NO_ERROR
    
--*/

{
    DWORD   dwNameLen, dwAllocSize;
    PICB    pNewInterfaceCb;

    *ppIcb = NULL;
    
    dwNameLen       = sizeof(WCHAR) * (wcslen(pwszName) + 1); // +1 for NULL
    dwNameLen       = min(dwNameLen, MAX_INTERFACE_NAME_LEN);
    dwAllocSize     = sizeof (ICB) + dwNameLen + 4; // +4 for alignment
    
    pNewInterfaceCb = HeapAlloc(IPRouterHeap, 
                                HEAP_ZERO_MEMORY, 
                                dwAllocSize);

    if(pNewInterfaceCb is NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    //
    // The interface name is after the ICB
    //
    
    pNewInterfaceCb->pwszName = (PWCHAR)((PBYTE)pNewInterfaceCb +
                                         sizeof (ICB));
    
    //
    // Align it to DWORD boundary - easier to copy out the name
    //
    
    pNewInterfaceCb->pwszName = 
        (PWCHAR)(((ULONG_PTR)pNewInterfaceCb->pwszName + 3) & ~((ULONG_PTR)0x3));
    
    //
    // Initialize the name
    //
    
    CopyMemory(pNewInterfaceCb->pwszName,
               pwszName,
               dwNameLen);
    
    pNewInterfaceCb->pwszName[wcslen(pwszName)] = UNICODE_NULL;

    *ppIcb = pNewInterfaceCb;
    
    return NO_ERROR;
}

DWORD
CreateBindingForNewIcb(
    PICB    pNewIcb
    )

/*++

Routine Description

    Creates a binding and bind node for the ICB

    LAN interfaces get the binding setup when they are being brought UP.
    Since the other interfaces will ALWAYS have ONLY 1 address, we can
    set their binding info here, even if we dont have the address
    
    We skip INTERNAL, too because of the way the internal address is 
    got. Otherwise we will get an assert in UpdateBindingInformation
    when we find an existing binding with no address 
    
Locks

    

Arguments

    

Return Value


--*/

{
    PADAPTER_INFO   pBindNode;
    PICB_BINDING    pBinding;

    if((pNewIcb->ritType is ROUTER_IF_TYPE_TUNNEL1) or
       (pNewIcb->ritType is ROUTER_IF_TYPE_HOME_ROUTER) or
       (pNewIcb->ritType is ROUTER_IF_TYPE_FULL_ROUTER) or
       (pNewIcb->ritType is ROUTER_IF_TYPE_LOOPBACK) or
       (pNewIcb->ritType is ROUTER_IF_TYPE_DIALOUT))
    {

        IpRtAssert(pNewIcb->dwIfIndex isnot INVALID_IF_INDEX);

        pBindNode   = HeapAlloc(IPRouterHeap,
                                HEAP_ZERO_MEMORY,
                                SIZEOF_ADAPTER_INFO(1));
       
        pBinding    = HeapAlloc(IPRouterHeap,
                                HEAP_ZERO_MEMORY,
                                sizeof(ICB_BINDING)); 

        if((pBinding is NULL) or
           (pBindNode is NULL))
        {
            return ERROR_NOT_ENOUGH_MEMORY;
        }
        
        pBindNode->pInterfaceCB             = pNewIcb;
        pBindNode->dwIfIndex                = pNewIcb->dwIfIndex;
        pBindNode->dwSeqNumber              = pNewIcb->dwSeqNumber;
        pBindNode->bBound                   = pNewIcb->bBound;
       
        pBindNode->dwRemoteAddress          = INVALID_IP_ADDRESS;
        pBindNode->rgibBinding[0].dwAddress = INVALID_IP_ADDRESS;
        pBindNode->rgibBinding[0].dwMask    = INVALID_IP_ADDRESS;

        pBindNode->dwBCastBit               = pNewIcb->dwBCastBit;
        pBindNode->dwReassemblySize         = pNewIcb->dwReassemblySize;

        pBindNode->ritType                  = pNewIcb->ritType;

        pNewIcb->pibBindings                = pBinding;
        
        //
        // Set the binding in the hash table
        //
        
        ENTER_WRITER(BINDING_LIST);

        InsertHeadList(
            &g_leBindingTable[BIND_HASH(pNewIcb->dwIfIndex)],
            &(pBindNode->leHashLink)
            );

        g_ulNumBindings++;

        g_LastUpdateTable[IPADDRCACHE] = 0;

        EXIT_LOCK(BINDING_LIST);

        return NO_ERROR;
    }
   
    //
    // For client (dial in our out) interfaces, we only create the BINDING
    //

    if((pNewIcb->ritType is ROUTER_IF_TYPE_CLIENT) or
       (pNewIcb->ritType is ROUTER_IF_TYPE_DIALOUT))
    {
        pBinding = HeapAlloc(IPRouterHeap,
                             HEAP_ZERO_MEMORY,
                             sizeof(ICB_BINDING));

        if(pBinding is NULL)
        {
            return ERROR_NOT_ENOUGH_MEMORY;
        }
        
        pNewIcb->pibBindings  = pBinding;

        return NO_ERROR;
    }

    return NO_ERROR;
}

VOID    
InsertInterfaceInLists(
    PICB     pNewIcb
    )

/*++

Routine Description

    Insert the new ICB. The newicb must have a valid interface
    index. The code walks all the current ICBs and inserts this
    ICB in increasing ifIndex order. It also sets a sequence
    number in the ICB and increments the global counter. 
  
Locks

    ICB_LIST as writer
      
Arguments

    newicb          The ICB of the interface to init

Return Value

    None
    
--*/

{
    PLIST_ENTRY pleNode;
    PICB        pIcb;

    for(pleNode = &ICBList;
        pleNode->Flink != &ICBList;
        pleNode = pleNode->Flink)
    {
        pIcb = CONTAINING_RECORD(pleNode->Flink, 
                                 ICB, 
                                 leIfLink);

        if(pIcb->dwIfIndex > pNewIcb->dwIfIndex)
        {
            break;
        }
    }

    InsertHeadList(pleNode, 
                   &pNewIcb->leIfLink);

    AddInterfaceLookup(pNewIcb);


    //
    // Find next unassigned ICB number
    //
    
    do
    {
        InterlockedIncrement(&g_dwNextICBSeqNumberCounter);

        //
        // WANARP considers 0 to be an invalid value for an
        // interface
        //
        
        if ((g_dwNextICBSeqNumberCounter == 0) or
            (g_dwNextICBSeqNumberCounter == INVALID_IF_INDEX))
        {
            InterlockedIncrement(&g_dwNextICBSeqNumberCounter);
        }

    } while(InterfaceLookupByICBSeqNumber(g_dwNextICBSeqNumberCounter) != NULL);
    
    //
    // Increment total number of interfaces
    //
    
    InterlockedIncrement(&g_ulNumInterfaces);


    //
    // Count for non client interfaces
    //

    if(pNewIcb->ritType isnot ROUTER_IF_TYPE_CLIENT)
    {
        InterlockedIncrement(&g_ulNumNonClientInterfaces);
    }
}

VOID
RemoveInterfaceFromLists(
    PICB    pIcb
    )

/*++

Routine Description

    This

Locks

    None

Arguments

    None

Return Value

    None    

--*/

{
    RemoveEntryList(&(pIcb->leIfLink));

    pIcb->leIfLink.Flink = NULL;
    pIcb->leIfLink.Blink = NULL;

    RemoveInterfaceLookup(pIcb);

    if(pIcb->ritType isnot ROUTER_IF_TYPE_CLIENT)
    {
        InterlockedDecrement(&g_ulNumNonClientInterfaces);
    }

    InterlockedDecrement(&g_ulNumInterfaces);
}

DWORD
BindInterfaceInAllProtocols(
    PICB pIcb
    )

/*++

Routine Description

    Binds the interface in all protocols running over the interface
      
Locks 

    The ICB_LIST lock must be held as READER. 
    Acquires the PROTOCOL_CB_LIST as READER

Arguments

    pIcb  ICB of the interface to bind

Return Value

    NO_ERROR

--*/

{
    IP_ADAPTER_BINDING_INFO *pBindInfo;
    DWORD                   i = 0 ;
    DWORD                   dwResult,dwReturn;
    PLIST_ENTRY             pleNode;
    
    TraceEnter("BindInterfaceInAllProtocols");

    CheckBindingConsistency(pIcb);
    
    if(!pIcb->bBound)
    {
        //
        // This may happen if we are in non operational state
        // It is not an error. We could do this check at the place
        // we called the function but it would make it tougher
        //

        Trace1(IF,
               "BindInterfaceInAllProtocols: Not binding %S since no addresses present",
               pIcb->pwszName);

        return NO_ERROR;
    }

    pBindInfo = HeapAlloc(IPRouterHeap,
                          0,
                          SIZEOF_IP_BINDING(pIcb->dwNumAddresses));

    if(pBindInfo is NULL)
    {
        
        Trace1(ERR,
               "BindInterfaceInAllProtocols: Error allocating %d bytes for bindings",
               SIZEOF_IP_BINDING(pIcb->dwNumAddresses));

        return ERROR_NOT_ENOUGH_MEMORY;
    }

    
    pBindInfo->AddressCount  = pIcb->dwNumAddresses ;
    pBindInfo->RemoteAddress = pIcb->dwRemoteAddress;

    pBindInfo->Mtu           = pIcb->ulMtu;
    pBindInfo->Speed         = pIcb->ullSpeed;

    for (i = 0; i < pIcb->dwNumAddresses; i++) 
    {
        pBindInfo->Address[i].Address = pIcb->pibBindings[i].dwAddress;
        pBindInfo->Address[i].Mask    = pIcb->pibBindings[i].dwMask;
    }

    
    
    //
    // walk the array of routing protocols to activate
    //
    
    dwReturn = NO_ERROR;
    
    // *** Exclusion Begin ***
    ENTER_READER(PROTOCOL_CB_LIST);

    for(pleNode = pIcb->leProtocolList.Flink;
        pleNode isnot &(pIcb->leProtocolList);
        pleNode = pleNode->Flink)
    {
        PIF_PROTO   pProto;
        
        pProto = CONTAINING_RECORD(pleNode,
                                   IF_PROTO,
                                   leIfProtoLink);

        dwResult = BindInterfaceInProtocol(pIcb,
                                           pProto->pActiveProto,
                                           pBindInfo);

        if(dwResult isnot NO_ERROR)
        {
            Trace3(ERR,
                   "BindInterfaceInAllProtocols: Couldnt bind interface %S to %S. Error %d",
                   pIcb->pwszName,
                   pProto->pActiveProto->pwszDisplayName,
                   dwResult);
            
            dwReturn = ERROR_CAN_NOT_COMPLETE;
        }
    }

    HeapFree(IPRouterHeap,
             0,
             pBindInfo);
    
    // *** Exclusion End ***
    EXIT_LOCK(PROTOCOL_CB_LIST);

    return dwReturn;
}

DWORD
BindInterfaceInProtocol(
    PICB                        pIcb,
    PPROTO_CB                   pProto,
    PIP_ADAPTER_BINDING_INFO    pBindInfo
    )

/*++

Routine Description

    Binds the interface in the given protocol

Locks

    The ICB_LIST lock must be held as READER.
    The PROTOCOL_CB_LIST lock must also be held as READER

Arguments

    pIcb        ICB of the interface to bind
    pProto      PROTO_CB of the protocol
    pBindInfo   Binding info

Return Value

    NO_ERROR

--*/

{
    DWORD   dwResult;
 
    //
    // If this is a mcast protocol and the interface is not
    // mcast enabled, do so now
    //

    if((pIcb->bMcastEnabled is FALSE) and
       (TYPE_FROM_PROTO_ID(pProto->dwProtocolId) is PROTO_TYPE_MCAST))
    {
        dwResult = SetMcastOnIf(pIcb,
                                TRUE);

        if(dwResult isnot NO_ERROR)
        {
            WCHAR   rgwcName[MAX_INTERFACE_NAME_LEN + 2];
            PWCHAR  pName;

            Trace2(ERR,
                   "BindInterfaceInProtocol: Err %d activating mcast on %S",
                   dwResult,
                   pIcb->pwszName);

            if(MprConfigGetFriendlyName(g_hMprConfig,
                                        pIcb->pwszName,
                                        rgwcName,
                                        sizeof(rgwcName)) is NO_ERROR)
            {
                pName = rgwcName;
            }
            else
            {
                pName = pIcb->pwszName;
            }

            RouterLogEventEx(g_hLogHandle,
                             EVENTLOG_ERROR_TYPE,
                             dwResult,
                             ROUTERLOG_IP_MCAST_NOT_ENABLED,
                             TEXT("%S%S"),
                             pName,
                             pProto->pwszDisplayName);

            //
            // Dont add this protocol
            //

            return dwResult;
        }

        pIcb->bMcastEnabled = TRUE;
    }

    //
    // Call the routing protocol's BindInterface() entrypoint
    //

    dwResult = (pProto->pfnInterfaceStatus)(
                    pIcb->dwIfIndex,
                    (pIcb->dwOperationalState >= CONNECTED),
                    RIS_INTERFACE_ADDRESS_CHANGE,
                    pBindInfo
                    );

    if(dwResult isnot NO_ERROR)
    {
        Trace3(ERR,
               "BindInterfaceInProtocol: Couldnt bind interface %S to %S.Error %d",
               pIcb->pwszName,
               pProto->pwszDisplayName,
               dwResult);

    }

    return dwResult;
}

DWORD
UnbindInterfaceInAllProtocols(
    PICB pIcb
    )

/*++
  
Routine Description

    Removes the binding information from the protocols on this interface
  
Locks 

    ICB_LIST lock as READER
    Acquires the PROTOCOL_CB_LIST as READER

Arguments
      

Return Value

    NO_ERROR

--*/

{
    PLIST_ENTRY pleNode;
    DWORD       dwResult,dwReturn = NO_ERROR;

    IP_ADAPTER_BINDING_INFO BindInfo;

    BindInfo.AddressCount = 0;
    
    TraceEnter("UnbindInterfaceInAllProtocols");

    // *** Exclusion Begin ***
    ENTER_READER(PROTOCOL_CB_LIST);


    for(pleNode = pIcb->leProtocolList.Flink;
        pleNode isnot &(pIcb->leProtocolList);
        pleNode = pleNode->Flink)
    {
        PIF_PROTO  pProto;
        
        pProto = CONTAINING_RECORD(pleNode,IF_PROTO,leIfProtoLink);

        dwResult = (pProto->pActiveProto->pfnInterfaceStatus)(
                        pIcb->dwIfIndex,
                        FALSE,
                        RIS_INTERFACE_ADDRESS_CHANGE,
                        &BindInfo
                        );

        if(dwResult isnot NO_ERROR)
        {
            Trace3(ERR,
                   "UnbindInterfaceInAllProtocols: Error %d unbinding %S in %S",
                   dwResult,
                   pIcb->pwszName,
                   pProto->pActiveProto->pwszDisplayName);

            dwReturn = ERROR_CAN_NOT_COMPLETE;
        }
    }

    
    // *** Exclusion Begin ***
    EXIT_LOCK(PROTOCOL_CB_LIST);

    return dwReturn;
}


DWORD
AddInterfaceToAllProtocols(
    PICB                     pIcb, 
    PRTR_INFO_BLOCK_HEADER   pInfoHdr
    )

/*++

Routine Description

    Walks thru list of  routing protocols and calls AddInterface if
    TOC and info for that protocol exists
  
Locks 

    ICB_LIST lock as WRITER
    Acquires PROTOCOL_CB_LIST as READER

Arguments
      

Return Value

    NO_ERROR

--*/

{
    DWORD           i = 0 , dwResult;
    LPVOID          pvProtoInfo ;
    PPROTO_CB       pProtoCbPtr ;
    PLIST_ENTRY     pleNode;
    PRTR_TOC_ENTRY  pToc;
    ULONG           ulStructureVersion, ulStructureSize, ulStructureCount;
    
    TraceEnter("AddInterfaceToAllProtocols");

    if(!ARGUMENT_PRESENT(pInfoHdr))
    {
        Trace1(IF,
               "AddInterfaceToAllProtocols: No interface info for %S. Not adding to any protocols",
               pIcb->pwszName);

        return NO_ERROR;
    }

    // *** Exclusion Begin ***
    ENTER_READER(PROTOCOL_CB_LIST);
    
    for(pleNode = g_leProtoCbList.Flink; 
        pleNode != &g_leProtoCbList; 
        pleNode = pleNode->Flink) 
    {
        pProtoCbPtr = CONTAINING_RECORD(pleNode, PROTO_CB, leList);
      
        pToc = GetPointerToTocEntry(pProtoCbPtr->dwProtocolId, 
                                    pInfoHdr);

        pvProtoInfo = NULL;

        if(pToc and (pToc->InfoSize > 0))
        {
            pvProtoInfo = GetInfoFromTocEntry(pInfoHdr,
                                              pToc);

            //ulStructureVersion = pInfoHdr->TocEntry[i].InfoVersion;
            ulStructureVersion = 0x500;
            ulStructureSize  = pInfoHdr->TocEntry[i].InfoSize;
            ulStructureCount = pInfoHdr->TocEntry[i].Count;

        }

        //
        // If the protocol block is found, add the interface with the
        // routing protocol.
        //
        
        if((pProtoCbPtr->fSupportedFunctionality & RF_ADD_ALL_INTERFACES) or
           (pvProtoInfo))
        {
            dwResult = AddInterfaceToProtocol(pIcb,
                                              pProtoCbPtr,
                                              pvProtoInfo,
                                              ulStructureVersion,
                                              ulStructureSize,
                                              ulStructureCount);

            if(dwResult isnot NO_ERROR)
            {
                Trace3(ERR,
                       "AddInterfaceToAllProtocols: Error %d adding %S to %S",
                       dwResult,
                       pIcb->pwszName,
                       pProtoCbPtr->pwszDisplayName);
            }
        }
    }
    
    // *** Exclusion End ***
    EXIT_LOCK(PROTOCOL_CB_LIST);

    return NO_ERROR;
}

DWORD
AddInterfaceToProtocol(
    IN  PICB            pIcb,
    IN  PPROTO_CB       pProtocolCb,
    IN  PVOID           pvProtoInfo,
    IN  ULONG           ulStructureVersion,
    IN  ULONG           ulStructureSize,
    IN  ULONG           ulStructureCount
    )

/*++

Routine Description

    Adds an interface to a single routing protocol

Locks

    

Arguments

    

Return Value


--*/

{
    PIF_PROTO   pProto;
    DWORD       dwResult;

        
    pProto = HeapAlloc(IPRouterHeap,
                       0,
                       sizeof(IF_PROTO));
                
    if(pProto is NULL)
    {
        Trace3(ERR,
               "AddInterfaceToProtocol: Error allocating %d bytes to add %S to %S",
               sizeof(IF_PROTO),
               pIcb->pwszName,
               pProtocolCb->pwszDisplayName);

        return ERROR_NOT_ENOUGH_MEMORY;
    }
            
    //
    // The protocol wants all the interfaces indicated to it or
    // there is info for this protocol
    //
            
    Trace2(IF,
           "AddInterfaceToProtocol: Adding %S to %S",
           pIcb->pwszName,
           pProtocolCb->pwszDisplayName);
    
    dwResult = (pProtocolCb->pfnAddInterface)(pIcb->pwszName,
                                              pIcb->dwIfIndex,
                                              pIcb->nitProtocolType,
                                              pIcb->dwMediaType,
                                              pIcb->wAccessType,
                                              pIcb->wConnectionType,
                                              pvProtoInfo,
                                              ulStructureVersion,
                                              ulStructureSize,
                                              ulStructureCount);
    
    if(dwResult isnot NO_ERROR)
    {
        Trace3(ERR,
               "AddInterfaceToProtocol: Error %d adding %S to %S",
               dwResult,
               pIcb->pwszName,
               pProtocolCb->pwszDisplayName);

        HeapFree(IPRouterHeap,
                 0,
                 pProto);
    }   
    else
    {
        pProto->pActiveProto = pProtocolCb;
            
        //
        // Mark this block as being added, because of prom.
        // mode, if that is the case
        //
            
        pProto->bPromiscuous = (pvProtoInfo is NULL);
        
        InsertTailList(&(pIcb->leProtocolList),
                       &(pProto->leIfProtoLink));
    }

    return dwResult;
}   

DWORD
DeleteInterfaceFromAllProtocols(
    PICB pIcb
    )

/*++
  
Routine Description

    Deletes the interface from all protocols running on it
    Frees the protocol info on the interface
  
Locks 

    Called with ICB_LIST as WRITER
    Acquires PROTOCOL_CB_LIST as READER

Arguments

    pIcb  ICB of interface

Return Value

    NO_ERROR

--*/

{
    DWORD       i = 0 ;
    PLIST_ENTRY pleNode;
    
    TraceEnter("DeleteInterfaceFromAllProtocols");
    
    //
    // If the router has stopped we do not need to delete the interface
    // from the routing protocol. This is handled before we get here by
    // the UnloadRoutingProtocol()
    //
    
    if (RouterState.IRS_State is RTR_STATE_STOPPED)
    {
        return NO_ERROR;
    }

    // *** Exclusion Begin ***
    ENTER_READER(PROTOCOL_CB_LIST);
    
    
    while(!(IsListEmpty(&(pIcb->leProtocolList))))
    {
        PIF_PROTO  pProto;
        
        pleNode = RemoveHeadList(&(pIcb->leProtocolList));
        
        pProto = CONTAINING_RECORD(pleNode,IF_PROTO,leIfProtoLink);
        
        //
        // Call the routing protocol's deleteinterface entrypoint
        //
        
        (pProto->pActiveProto->pfnDeleteInterface) (pIcb->dwIfIndex);
        
        //
        // Delete this protocol from the list of protocols in the Interface
        //
        
        HeapFree(IPRouterHeap,0,pProto);
    }

    // *** Exclusion End ***
    EXIT_LOCK(PROTOCOL_CB_LIST);

    return NO_ERROR;
}


DWORD
DisableInterfaceWithAllProtocols(
    PICB   pIcb
    )
{
    PLIST_ENTRY pleNode;
    DWORD       dwResult,dwReturn = NO_ERROR;

    TraceEnter("DisableInterfaceWithAllProtocols");

    ENTER_READER(PROTOCOL_CB_LIST);

    for(pleNode = pIcb->leProtocolList.Flink;
        pleNode isnot &(pIcb->leProtocolList);
        pleNode = pleNode->Flink)
    {
        PIF_PROTO  pProto;
        
        pProto = CONTAINING_RECORD(pleNode,IF_PROTO,leIfProtoLink);

        //
        // Call the routing protocol's DisableInterface() entrypoint
        //
    
        dwResult = (pProto->pActiveProto->pfnInterfaceStatus)(
                        pIcb->dwIfIndex,
                        FALSE,
                        RIS_INTERFACE_DISABLED,
                        NULL
                        );
    
        if(dwResult isnot NO_ERROR)
        {
            Trace3(ERR, 
                   "DisableInterfaceWithAllProtocols: Couldnt disable %S with %S. Error %d",
                   pIcb->pwszName,
                   pProto->pActiveProto->pwszDisplayName,
                   dwResult);
            
            dwReturn = ERROR_CAN_NOT_COMPLETE;
        }
    }

    EXIT_LOCK(PROTOCOL_CB_LIST);
   
    return dwReturn;
}


DWORD
EnableInterfaceWithAllProtocols(
    PICB    pIcb
    )
{
    PLIST_ENTRY pleNode;
    DWORD       dwResult, dwReturn = NO_ERROR;

    TraceEnter("EnableInterfaceWithAllProtocols");

    ENTER_READER(PROTOCOL_CB_LIST);
    
    for(pleNode = pIcb->leProtocolList.Flink;
        pleNode isnot &(pIcb->leProtocolList);
        pleNode = pleNode->Flink)
    {
        PIF_PROTO  pProto;

        pProto = CONTAINING_RECORD(pleNode,IF_PROTO,leIfProtoLink);

        dwResult = (pProto->pActiveProto->pfnInterfaceStatus)(
                    pIcb->dwIfIndex,
                    (pIcb->dwOperationalState >= CONNECTED),
                    RIS_INTERFACE_ENABLED,
                    NULL
                    );

        if(dwResult isnot NO_ERROR)
        {
            Trace3(ERR, 
                   "EnableInterfaceWithAllProtocols: Couldnt enable %S with %S. Error %d",
                   pIcb->pwszName,
                   pProto->pActiveProto->pwszDisplayName,
                   dwResult);
            
            dwReturn = ERROR_CAN_NOT_COMPLETE;

            continue;
        }
    }

    EXIT_LOCK(PROTOCOL_CB_LIST);
    
    return dwReturn;
}

        
VOID
DeleteAllInterfaces(
    VOID
    )
{

    PLIST_ENTRY pleNode ;
    PICB        pIcb ;
    
    TraceEnter("DeleteAllInterfaces");

    // *** Exclusion Begin ***
    ENTER_WRITER(ICB_LIST);


    //
    // We do this backwards. Quick hack for fixing OSPF
    //

    //
    // First we unlink the internal interface because if the worker function
    // finds the ICB list non empty, it loops, waiting for the interfaces
    // to get deleted. After all interfaces are deleted it deletes the
    // internal interface
    // Hence we remove the i/f from the list here and decrement the count.
    //

    if(g_pInternalInterfaceCb)
    {
        RemoveEntryList(&(g_pInternalInterfaceCb->leIfLink));

        InterlockedDecrement(&g_ulNumInterfaces);
    }

    if(g_pLoopbackInterfaceCb)
    {
        g_pLoopbackInterfaceCb = NULL;
    }

    for(pleNode = ICBList.Blink; pleNode != &ICBList;) 
    {
        pIcb = CONTAINING_RECORD (pleNode, ICB, leIfLink) ;

        if((pIcb->dwOperationalState is CONNECTED) and
           ((pIcb->ritType is ROUTER_IF_TYPE_HOME_ROUTER) or
            (pIcb->ritType is ROUTER_IF_TYPE_FULL_ROUTER)))
        {

            MarkInterfaceForDeletion(pIcb);
            
            pleNode = pleNode->Blink;

            continue;
        }
        
        pleNode = pleNode->Blink;

        RemoveInterfaceFromLists(pIcb);

        DeleteSingleInterface(pIcb);      // clean up interface.

        //
        // Free the ICB
        //

        HeapFree(IPRouterHeap, 
                 0, 
                 pIcb);
    }

    // *** Exclusion End ***
    EXIT_LOCK(ICB_LIST);

}

DWORD
DeleteSingleInterface(
    PICB pIcb
    )
{
    PICB_BINDING    pBinding;
    PADAPTER_INFO   pBindNode;
    DWORD           dwResult;
    
    TraceEnter("DeleteSingleInterface");

    if(pIcb->ritType is ROUTER_IF_TYPE_CLIENT)
    { 
        IpRtAssert(g_pInternalInterfaceCb);
 
        if(pIcb->bBound)
        { 
            PLIST_ENTRY         pleNode;
            IP_LOCAL_BINDING    clientAddr;

            clientAddr.Address = pIcb->pibBindings->dwAddress;
            clientAddr.Mask    = pIcb->pibBindings->dwMask;

#if 0
            //
            // Remove the client host route
            //

            DeleteSingleRoute(g_pInternalInterfaceCb->dwIfIndex,
                              clientAddr.Address,
                              HOST_ROUTE_MASK,
                              clientAddr.Address,
                              MIB_IPPROTO_NETMGMT,
                              FALSE);
#endif

            ENTER_READER(PROTOCOL_CB_LIST);


            //
            // Call ConnectClient for all the protocols configured
            // over the ServerInterface
            //

            for(pleNode = g_pInternalInterfaceCb->leProtocolList.Flink;
                pleNode isnot &(g_pInternalInterfaceCb->leProtocolList);
                pleNode = pleNode->Flink)
            {
                PIF_PROTO   pIfProto;

                pIfProto = CONTAINING_RECORD(pleNode,
                                             IF_PROTO,
                                             leIfProtoLink);

                if(pIfProto->pActiveProto->pfnDisconnectClient)
                {
                    pIfProto->pActiveProto->pfnDisconnectClient(
                        g_pInternalInterfaceCb->dwIfIndex,
                        &clientAddr
                        );
                }
            }

            EXIT_LOCK(PROTOCOL_CB_LIST);

            //
            // Delete static routes from RTM (and the stack)
            //

            DeleteAllClientRoutes(pIcb,
                                  g_pInternalInterfaceCb->dwIfIndex);


            if(pIcb->pStoredRoutes)
            {
                HeapFree(IPRouterHeap,
                         0,
                         pIcb->pStoredRoutes);
        
                pIcb->pStoredRoutes = NULL;
            }

            //
            // Delete the interface from the filter driver
            //

            DeleteFilterInterface(pIcb);

            HeapFree(IPRouterHeap,
                     0,
                     pIcb->pibBindings);

            pIcb->pibBindings = NULL;
        }

        return NO_ERROR;
    }

    if(pIcb->ritType is ROUTER_IF_TYPE_DIALOUT)
    {
        IpRtAssert(pIcb->bBound);

        pBinding = pIcb->pibBindings;

        IpRtAssert(pBinding);

        DeleteAutomaticRoutes(pIcb,
                              pBinding[0].dwAddress,
                              pBinding[0].dwMask);

        DeleteAllRoutes(pIcb->dwIfIndex,
                        FALSE);

        ENTER_WRITER(BINDING_LIST);

#if DBG

        pBindNode = GetInterfaceBinding(pIcb->dwIfIndex);

        IpRtAssert(pBindNode);

#endif // DBG

        RemoveBinding(pIcb);

        EXIT_LOCK(BINDING_LIST);

        HeapFree(IPRouterHeap,
                 0,
                 pBinding);

        pIcb->pibBindings = NULL;

        return NO_ERROR;
    }


    //
    // So at this point we are only dealing with FULL_ROUTER, HOME_ROUTER and
    // DEDICATED type interfaces
    //

    //
    // Delete static routes from RTM (and the stack)
    //

    DeleteAllRoutes(pIcb->dwIfIndex,
                    FALSE);

    //
    // WAN interfaces: bringing down an interface will not delete
    // the binding. Hence we do it here
    //
    
    pBinding    = NULL;
    pBindNode   = NULL;

    if((pIcb->ritType is ROUTER_IF_TYPE_FULL_ROUTER) or
       (pIcb->ritType is ROUTER_IF_TYPE_HOME_ROUTER))
    {
        pBinding    = pIcb->pibBindings;
        pBindNode   = GetInterfaceBinding(pIcb->dwIfIndex);
    }
   
    //
    // Bringing down the interfaces clears out stack contexts
    //

    if((pIcb->ritType is ROUTER_IF_TYPE_DEDICATED) or
       (pIcb->ritType is ROUTER_IF_TYPE_LOOPBACK) or
       (pIcb->ritType is ROUTER_IF_TYPE_TUNNEL1) or
       (pIcb->ritType is ROUTER_IF_TYPE_INTERNAL))
    {
        LanEtcInterfaceUpToDown(pIcb,
                                TRUE);
    }
    else
    {
        WanInterfaceInactiveToDown(pIcb,
                                   TRUE);
    }

    
    //
    // This also frees up the list of IF_PROTO blocks
    //

    DeleteInterfaceFromAllProtocols(pIcb);

    //
    // Now remove the interface from the stack components
    //

    if((pIcb->ritType is ROUTER_IF_TYPE_FULL_ROUTER) or
       (pIcb->ritType is ROUTER_IF_TYPE_HOME_ROUTER) or
       (pIcb->ritType is ROUTER_IF_TYPE_INTERNAL))
    {
        if(pIcb->ritType isnot ROUTER_IF_TYPE_INTERNAL)
        {
            DeleteDemandFilterInterface(pIcb);
        }

        DeleteInterfaceWithWanArp(pIcb);
    }

   
    if((pIcb->ritType isnot ROUTER_IF_TYPE_INTERNAL) and
       (pIcb->ritType isnot ROUTER_IF_TYPE_LOOPBACK))
    {
        dwResult = DeleteFilterInterface(pIcb);

        if(dwResult isnot NO_ERROR)
        {
            Trace2(ERR,
                   "Error %d deleting %S from the filter driver",
                   dwResult,
                   pIcb->pwszName);
        }
    }

    if(pIcb->ritType is ROUTER_IF_TYPE_TUNNEL1)
    {
        dwResult = DeleteInterfaceFromIpInIp(pIcb);
                                             

        if(dwResult isnot NO_ERROR)
        {
            Trace2(ERR,
                   "Error %d deleting %S from the IpInIp driver",
                   dwResult,
                   pIcb->pwszName);
        }

        RemoveBinding(pIcb);
    }

    //
    // Delete the binding for wan interfaces
    //
    
    if(pBindNode)
    {
        ENTER_WRITER(BINDING_LIST);
        
        RemoveBinding(pIcb);

        EXIT_LOCK(BINDING_LIST);
    }

    if(pBinding)
    {
        HeapFree(IPRouterHeap,
                 0,
                 pBinding);
    }

    if(pIcb->pRtrDiscAdvt)
    {
        HeapFree(IPRouterHeap,
                 0,
                 pIcb->pRtrDiscAdvt);

        pIcb->pRtrDiscAdvt = NULL;
    }

    return NO_ERROR;
}

DWORD
IpIpTunnelDownToUp(
    PICB    pIcb
    )
{
    return NO_ERROR;
}

DWORD
LanEtcInterfaceDownToUp(
    PICB   pIcb,
    BOOL   bAdding
    )

/*++

Routine Description

    The interface's admin state MUST be UP or this function will simply
    return
    
    The interface to adapter map MUST have already been stored before this
    is called

Locks

    ICB_LIST lock held as writer

Arguments

    pIcb    ICB of the interface to bring up
    bAdding Set to TRUE if we are adding the interface (as opposed to bringing
            it up when the admin state changed etc)   

Return Value

    NO_ERROR
    
--*/

{
    DWORD                   dwResult;
    PRESTORE_INFO_CONTEXT   pricInfo;
    
    TraceEnter("LanInterfaceDownToUp");
   
    if(pIcb->dwAdminState isnot IF_ADMIN_STATUS_UP)
    {
        Trace2(ERR,
               "LanInterfaceDownToUp: Tried to bring up %S when its admin state is %d",
               pIcb->pwszName,
               pIcb->dwAdminState);

        return ERROR_INVALID_PARAMETER;
    }
 
    //
    // Read the address from the registry for LAN interfaces. This function
    // is also called for the INTERNAL interface, whose address is already
    // plumbed by the time it is called and for TUNNEL which currently
    // run in unnumbered mode
    //

    if(pIcb->ritType is ROUTER_IF_TYPE_DEDICATED)
    {
        IpRtAssert(!pIcb->bBound);
        IpRtAssert(pIcb->dwNumAddresses is 0);

        CheckBindingConsistency(pIcb);
    
        dwResult = UpdateBindingInformation(pIcb);
   
        if(dwResult isnot NO_ERROR)
        {
            //
            // UpdateBindingInf can return ERROR_ALREADY_ASSOC, 
            // but since we have asserted earlier that we dont have
            // an address, that error only means we still dont have an
            // address
            //

            if(dwResult isnot ERROR_ADDRESS_ALREADY_ASSOCIATED)
            {
                Trace1(ERR,
                       "LanInterfaceDownToUp: Couldnt read binding information for %S",
                       pIcb->pwszName);
            }
       
            pIcb->dwOperationalState = IF_OPER_STATUS_NON_OPERATIONAL;
        
            return ERROR_CAN_NOT_COMPLETE;
        }
    }

    IpRtAssert(pIcb->bBound);

    if(pIcb->ritType isnot ROUTER_IF_TYPE_INTERNAL)
    {
        pIcb->dwOperationalState = IF_OPER_STATUS_OPERATIONAL;
    }
    else
    {
        pIcb->dwOperationalState = IF_OPER_STATUS_CONNECTED;
    }

    //
    // First do the generic interface to up stuff
    //
    
    GenericInterfaceComingUp(pIcb);

    //
    // We restore routes even when this function is being called from
    // add interface, because that is the only way to pick up stack
    // routes
    //

    pricInfo = HeapAlloc(IPRouterHeap,
                         0,
                         sizeof(RESTORE_INFO_CONTEXT));

    if(pricInfo isnot NULL)
    {
        pricInfo->dwIfIndex     = pIcb->dwIfIndex;

        pIcb->bRestoringRoutes  = TRUE;

        dwResult = QueueAsyncFunction(RestoreStaticRoutes,
                                      (PVOID)pricInfo,
                                      FALSE);

        if(dwResult isnot NO_ERROR)
        {
            pIcb->bRestoringRoutes = FALSE;

            IpRtAssert(FALSE);

            Trace2(ERR,
                   "LanInterfaceDownToUp: Error %d queueing function for %S",
                   dwResult,
                   pIcb->pwszName);
        }
    }
    else
    {
        IpRtAssert(FALSE);

        Trace1(ERR,
               "LanInterfaceDownToUp: Error allocating context for %S",
               pIcb->pwszName);
    }   

    return NO_ERROR;
}

DWORD
WanInterfaceInactiveToUp(
    PICB   pIcb
    )

/*++

Routine Description

    This function does things slighlty differently from above because, for
    one, there is no UpdateBindingInfo() call for such adapters

Locks

    

Arguments

    

Return Value


--*/

{
    PRESTORE_INFO_CONTEXT pricInfo;
    DWORD                 dwResult;
    INTERFACE_ROUTE_INFO  rifRoute;
    
    TraceEnter("WanInterfaceInactiveToUp");

    CheckBindingConsistency(pIcb);
    
    Trace1(IF,
           "WanInterfaceInactiveToUp: %S coming up",
           pIcb->pwszName);

    //
    // quick look up of interface given the adapter index.
    // This is done in UpdateBindingInfo for LAN interfaces.
    //

    //StoreAdapterToInterfaceMap(pIcb->dwAdapterId, 
    //                           pIcb->dwIfIndex);
    

    //
    // First do the generic thing
    //
    
    GenericInterfaceComingUp(pIcb);

    //
    // Delete all static routes.  These will be re-added
    // by RestoreStaticRoutes (below) with the correct next hop
    //

    DeleteAllRoutes(pIcb->dwIfIndex, TRUE);

    //
    // Restore all static and NON-Dod routes on this interface
    //

    pricInfo = HeapAlloc(IPRouterHeap,
                         0,
                         sizeof(RESTORE_INFO_CONTEXT));

    if(pricInfo isnot NULL)
    {
        pricInfo->dwIfIndex     = pIcb->dwIfIndex;

        pIcb->bRestoringRoutes  = TRUE;

        dwResult = QueueAsyncFunction(RestoreStaticRoutes,
                                      (PVOID)pricInfo,
                                      FALSE);

        if(dwResult isnot NO_ERROR)
        {
            pIcb->bRestoringRoutes = FALSE;

            IpRtAssert(FALSE);

            Trace2(ERR,
                   "WanInterfaceInactiveToUp: Error %d queueing function for %S",
                   dwResult,
                   pIcb->pwszName);
        }
    }
    else
    {
        IpRtAssert(FALSE);

        Trace1(ERR,
               "WanInterfaceInactiveToUp: Error allocating context for %S",
               pIcb->pwszName);
    }   

    //
    // Change Static route so that it uses the correct adapter index
    //
    
    // ChangeAdapterIndexForDodRoutes(pIcb->dwIfIndex);

    //
    // Add a host route for the remote side
    //
    
    if(pIcb->dwRemoteAddress isnot INVALID_IP_ADDRESS)
    {
        rifRoute.dwRtInfoMask          = HOST_ROUTE_MASK;
        rifRoute.dwRtInfoNextHop       = pIcb->pibBindings[0].dwAddress;
        rifRoute.dwRtInfoDest          = pIcb->dwRemoteAddress;
        rifRoute.dwRtInfoIfIndex       = pIcb->dwIfIndex;
        rifRoute.dwRtInfoMetric1       = 1;
        rifRoute.dwRtInfoMetric2       = 0;
        rifRoute.dwRtInfoMetric3       = 0;
        rifRoute.dwRtInfoPreference    = 
            ComputeRouteMetric(MIB_IPPROTO_NETMGMT);
        rifRoute.dwRtInfoViewSet       = RTM_VIEW_MASK_UCAST |
                                          RTM_VIEW_MASK_MCAST; // XXX config
        rifRoute.dwRtInfoType          = MIB_IPROUTE_TYPE_DIRECT;
        rifRoute.dwRtInfoProto         = MIB_IPPROTO_NETMGMT;
        rifRoute.dwRtInfoAge           = 0;
        rifRoute.dwRtInfoNextHopAS     = 0;
        rifRoute.dwRtInfoPolicy        = 0;
        
        dwResult = AddSingleRoute(pIcb->dwIfIndex,
                                  &rifRoute,
                                  pIcb->pibBindings[0].dwMask,
                                  0,        // RTM_ROUTE_INFO::Flags
                                  TRUE,     // Valid route 
                                  TRUE,
                                  TRUE,
                                  NULL);

        if(dwResult isnot NO_ERROR)
        {
            Trace1(ERR,
                   "WanInterfaceInactiveToUp: Couldnt add host route for %x",
                   pIcb->dwRemoteAddress);
        }
    }

    return NO_ERROR;
}


DWORD
GenericInterfaceComingUp(
    PICB   pIcb
    )

/*++

Routine Description

    This function has the common code for bringing up an interface.
    It assumes that the interface is bound.

    If NAT is running and we have an address (not unnumbered) we add the
    address to NAT.
    We activate router discovery and multicast heartbeat (if they are present)
    Then we add
        (i)   local loopback
        (ii)  local multicast
        (iii) all subnets broadcast
        (iv)  all 1's broadcast
    routes
    Then we call out to the routing protocols and the filter driver to inform
    them of the binding
    
Locks

    ICB_LIST lock held as WRITER

Arguments

    pIcb    ICB of the interface to bring up

Return Value


--*/

{
    DWORD               dwResult, i;
    MIB_IPFORWARDROW    rifRoute;
    PADAPTER_INFO       pBinding;
    
    TraceEnter("GenericInterfaceComingUp");
    
    Trace1(IF,
           "GenericInterfaceComingUp: %S coming UP",
           pIcb->pwszName);

    // Join the All-Routers multicast group

    {
        extern SOCKET McMiscSocket;

        Trace1(IF,
               "CreateSockets: Joining ALL_ROUTERS on %S",
               pIcb->pwszName);
    
        if ( McJoinGroupByIndex( McMiscSocket, 
                                 SOCK_RAW, 
                                 ALL_ROUTERS_MULTICAST_GROUP,
                                 pIcb->dwIfIndex ) is SOCKET_ERROR )
        {
            Trace2(ERR,
                   "GenericInterfaceComingUp: Error %d joining all-routers group on %S",
                   WSAGetLastError(),
                   pIcb->pwszName);
        }
    }
   
    //
    // Start router discovery on this interface. This will cause
    // the advertisement to get updated
    //
    
    dwResult = ActivateRouterDiscovery(pIcb);

        
    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "GenericInterfaceComingUp: Error %d activating router discovery on %S",
               dwResult,
               pIcb->pwszName);
    }

    dwResult = ActivateMHeartbeat(pIcb);

    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "GenericInterfaceComingUp: Error %d activating router discovery on %S",
               dwResult,
               pIcb->pwszName);
    }

    //
    // Add default routes for the connected network 
    //

    for(i = 0; i < pIcb->dwNumAddresses; i++)
    {
        if(pIcb->pibBindings[i].dwAddress is INVALID_IP_ADDRESS)
        {
            continue;
        }

        AddAutomaticRoutes(pIcb,
                           pIcb->pibBindings[i].dwAddress,
                           pIcb->pibBindings[i].dwMask);
        
    }

    //
    // Interfaces going to UP must have valid binding information.
    // This is passed to the routing protocols
    //
    
    BindInterfaceInAllProtocols(pIcb);
   
    // Set Multicast limits in stack

    ActivateMcastLimits(pIcb);

    for (i=0; i<NUM_INFO_CBS; i++)
    {
        if (!g_rgicInfoCb[i].pfnBindInterface)
        {
            continue;
        }

        dwResult = g_rgicInfoCb[i].pfnBindInterface(pIcb);

        if (dwResult isnot NO_ERROR)
        {
            Trace3(ERR,
                   "GenericInterfaceComingUp: Error %d binding %S for %s info",
                   dwResult,
                   pIcb->pwszName,
                   g_rgicInfoCb[i].pszInfoName);
        }
    }

    return NO_ERROR ;
}


DWORD
LanEtcInterfaceUpToDown(
    PICB pIcb,
    BOOL bDeleted
    )

/*++

Routine Description

    This function is called when a LAN, INTERNAL or LOOPBACK interface goes
    down.

    If the interface is not being deleted, we delete all the static routes.
    We then disable the interface with the routing protocols and call
    the generic routing to handle all the rest
    
Locks

    ICB_LOCK held as WRITER

Arguments

    pIcb
    bDeleted

Return Value

    None    

--*/

{
    DWORD   i,dwResult;

    TraceEnter("LanInterfaceUpToDown");

    if(!bDeleted)
    {
        DeleteAllRoutes(pIcb->dwIfIndex,
                        FALSE);
    }

    GenericInterfaceNoLongerUp(pIcb,
                               bDeleted);

    pIcb->dwOperationalState = IF_OPER_STATUS_NON_OPERATIONAL;

    return NO_ERROR;
}

DWORD
WanInterfaceUpToInactive(
    PICB   pIcb,
    BOOL   bDeleted
    )
{
    DWORD                   dwResult;
    PRESTORE_INFO_CONTEXT   pricInfo;
    

    TraceEnter("WanInterfaceUpToInactive");

    //
    // Delete the route before deallocating the address (which is called in
    // GenericInterfaceNoLongerUp), because that will set Remote addr to
    // invalid and then this route will never be deleted
    //
   
    CheckBindingConsistency(pIcb);

    //
    // If it was up, it should be bound
    //

    IpRtAssert(pIcb->bBound);
    
    if(!bDeleted and
       (pIcb->dwRemoteAddress isnot INVALID_IP_ADDRESS))
    {
        dwResult = DeleteSingleRoute(pIcb->dwIfIndex,
                                     pIcb->dwRemoteAddress,
                                     HOST_ROUTE_MASK,
                                     pIcb->pibBindings[0].dwAddress,
                                     PROTO_IP_NETMGMT,
                                     TRUE);

        if(dwResult isnot NO_ERROR)
        {
            Trace1(ERR,
                   "WanInterfaceUpToInactive: Couldnt delete host route for %d.%d.%d.%d",
                   PRINT_IPADDR(pIcb->dwRemoteAddress));
        }
    }

    
    GenericInterfaceNoLongerUp(pIcb,
                               bDeleted);

    if(!bDeleted)
    {
#if 1
        //
        // Delete all static routes/nexthops
        //

        DeleteAllRoutes(pIcb->dwIfIndex, FALSE);


/*
        //
        // Delete all netmgmt routes/nexthops
        //
        
        dwResult = DeleteRtmRoutes(g_hNetMgmtRoute, pIcb->dwIfIndex, FALSE);

        if (dwResult is NO_ERROR)
        {
            dwResult = DeleteRtmNexthopsOnInterface(
                        g_hNetMgmtRoute, pIcb->dwIfIndex
                        );
            if (dwResult isnot NO_ERROR)
            {
                Trace1(
                    ERR,
                    "WanInterfaceUpToInactive: Couldnt delete next hops for "
                    "Interface 0x%x",
                     pIcb->dwIfIndex
                     );
            }
        }
*/
        //
        // Restore all static and NON-Dod routes on this interface
        //

        pricInfo = HeapAlloc(
                    IPRouterHeap, 0, sizeof(RESTORE_INFO_CONTEXT)
                    );

        if(pricInfo isnot NULL)
        {
            pricInfo->dwIfIndex     = pIcb->dwIfIndex;

            pIcb->bRestoringRoutes  = TRUE;

            dwResult = QueueAsyncFunction(RestoreStaticRoutes,
                                          (PVOID)pricInfo,
                                          FALSE);

            if(dwResult isnot NO_ERROR)
            {
                pIcb->bRestoringRoutes = FALSE;

                IpRtAssert(FALSE);

                Trace2(ERR,
                       "WanInterfaceUpToInactive: Error %d queueing"
                       " function for %S",
                       dwResult,
                       pIcb->pwszName);
            }
        }
        else
        {
            IpRtAssert(FALSE);

            Trace1(ERR,
                   "WanInterfaceInactiveToUp: Error allocating context for %S",
                   pIcb->pwszName);
        }   

#else
        //
        // Delete all NON-Dod, Netmgmt routes on this interface
        //
        
        DeleteRtmRoutes(g_hNonDodRoute,  pIcb->dwIfIndex, FALSE);
        DeleteRtmRoutes(g_hNetMgmtRoute, pIcb->dwIfIndex, FALSE);

        ChangeAdapterIndexForDodRoutes(pIcb->dwIfIndex);
#endif
    }

    pIcb->dwOperationalState = IF_OPER_STATUS_DISCONNECTED;
 
    return NO_ERROR;
}
    
DWORD
GenericInterfaceNoLongerUp(
    PICB pIcb,
    BOOL bDeleted
    )

/*++

Routine Description

    This function is called by all interfaces (other than CLIENT) when
    they go to DOWN state (The actual state depends upon the interface). This
    may happen because of state change or because the interface is being
    deleted

    If we are not deleting the interface, we delete all the automatically
    generated routes

    We deactivate router discovery and multicast hearbeat.
    If NAT is running, we remove the FIREWALL context for the interface
    from IP and THEN unbind the address in NAT
    (This MUST be done in this order)

    Then we Unbind the interface in the routing protocols running over it.
    We delete the Adapter->Interface map, deallocate the bindings (which does
    different things depending on LAN/WAN) and if there is a DIM event we
    set the event

Locks

    ICB_LIST lock held as WRITER

Arguments

    pIcb     ICB of the interface
    bDeleted Set to TRUE if the state change is because of deletion

Return Value

    None    

--*/

{
    DWORD           dwResult;
    DWORD           i, j;

    TraceEnter("GenericInterfaceNoLongerUp");

    Trace1(IF,
           "GenericInterfaceNoLongerUp: %S no longer UP",
           pIcb->pwszName);

    if(pIcb->bMcastEnabled)
    {
        pIcb->bMcastEnabled = FALSE;

        dwResult = SetMcastOnIf(pIcb,
                                FALSE);

        if(dwResult isnot NO_ERROR)
        {
            Trace2(ERR,
                   "GenericIfNoLongerUp: Error %d deactivating mcast on %S",
                   dwResult,
                   pIcb->pwszName);
        }
    }

    if(!bDeleted)
    {
        for (i = 0; i < pIcb->dwNumAddresses; i++)
        {
            if(pIcb->pibBindings[i].dwAddress isnot INVALID_IP_ADDRESS)
            {
                DeleteAutomaticRoutes(pIcb,
                                      pIcb->pibBindings[i].dwAddress,
                                      pIcb->pibBindings[i].dwMask);
            }
        }
    }
   
    //
    // Delete any gateways on this
    //

    for(i = 0; i < g_ulGatewayMaxCount; i++)
    {
        if(g_pGateways[i].dwIfIndex is pIcb->dwIfIndex)
        {
            g_pGateways[i].dwAddress = 0;
        }
    }

    //
    // Compress the array
    //

    for(i = 0, j = 1; j < g_ulGatewayMaxCount;j++)
    {
        if(g_pGateways[i].dwAddress isnot 0)
        {
            i++;
        }
        else
        {
            if(g_pGateways[j].dwAddress isnot 0)
            {
                g_pGateways[i] = g_pGateways[j];

                g_pGateways[j].dwAddress = 0;

                i++;
            }
        }
    }

    g_ulGatewayCount = i;

    dwResult = DeActivateRouterDiscovery(pIcb);
    
    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "GenericInterfaceNoLongerUp: Error %d deactivating router discovery on %S",
               dwResult,
               pIcb->pwszName);
    }

    dwResult = DeActivateMHeartbeat(pIcb);
    
    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "GenericInterfaceNoLongerUp: Error %d deactivating multicast heartbeat on %S",
               dwResult,
               pIcb->pwszName);
    }
   
    if((pIcb->ritType isnot ROUTER_IF_TYPE_INTERNAL) and
       (pIcb->ritType isnot ROUTER_IF_TYPE_LOOPBACK))
    {
        UnbindFilterInterface(pIcb);
    }

    //
    // When going out of UP state, the interface loses its address
    //
   
    UnbindInterfaceInAllProtocols(pIcb);

    //if(pIcb->pibBindings) 
    //{
    //    DeleteAdapterToInterfaceMap(pIcb->dwAdapterId) ;
    //}
    
    DeAllocateBindings(pIcb);

    if(pIcb->hDIMNotificationEvent isnot NULL)
    {
        //
        // There was an update pending. Set the event, when the user asks us
        // for info, we will fail the request
        //
        
        if(!SetEvent(pIcb->hDIMNotificationEvent))
        {
            Trace1(ERR,
                   "GenericInterfaceNoLongerUp: Error %d setting update route event",
                   GetLastError());
        }

        CloseHandle(pIcb->hDIMNotificationEvent);

        pIcb->hDIMNotificationEvent = NULL;

    }
    
    return NO_ERROR ;
}

DWORD
WanInterfaceInactiveToDown(
    PICB pIcb,
    BOOL bDeleted
    )
{
    TraceEnter("WanInterfaceInactiveToDown");

    CheckBindingConsistency(pIcb);
    
    IpRtAssert(!pIcb->bBound);
    
    if(!bDeleted)
    { 
        DeleteAllRoutes(pIcb->dwIfIndex,
                        FALSE);
    }

    pIcb->dwOperationalState = UNREACHABLE;

    //DisableInterfacewithWanArp(pIcb);
    
    return NO_ERROR;
}

DWORD
WanInterfaceDownToInactive(
    PICB pIcb
    )
{
    PRESTORE_INFO_CONTEXT   pricInfo;
    DWORD                   dwResult;
    PADAPTER_INFO           pBinding;

    TraceEnter("WanInterfaceDownToInactive");

#if STATIC_RT_DBG

    ENTER_WRITER(BINDING_LIST);

    pBinding = GetInterfaceBinding(pIcb->dwIfIndex);

    pBinding->bUnreach = FALSE;

    EXIT_LOCK(BINDING_LIST);

#endif

    //
    // Set the state before calling restore
    //

    pIcb->dwOperationalState = DISCONNECTED;

    pricInfo = HeapAlloc(IPRouterHeap,
                         0,
                         sizeof(RESTORE_INFO_CONTEXT));

    if(pricInfo isnot NULL)
    {
        pricInfo->dwIfIndex     = pIcb->dwIfIndex;

        pIcb->bRestoringRoutes  = TRUE;

        dwResult = QueueAsyncFunction(RestoreStaticRoutes,
                                      (PVOID)pricInfo,
                                      FALSE);

        if(dwResult isnot NO_ERROR)
        {
            pIcb->bRestoringRoutes = FALSE;

            IpRtAssert(FALSE);

            Trace2(ERR,
                   "WanInterfaceDownToInactive: Error %d queueing function for %S",
                   dwResult,
                   pIcb->pwszName);

            HeapFree(
                IPRouterHeap,
                0,
                pricInfo
                );
        }
    }
    else
    {
        IpRtAssert(FALSE);

        Trace1(ERR,
               "WanInterfaceDownToInactive: Error allocating context for %S",
               pIcb->pwszName);
    }   
    
    return NO_ERROR;
}
      
DWORD
GetInterfaceStatusInfo(
    IN     PICB                   pIcb,
    IN     PRTR_TOC_ENTRY         pToc,
    IN     PBYTE                  pbDataPtr,
    IN OUT PRTR_INFO_BLOCK_HEADER pInfoHdr,
    IN OUT PDWORD                 pdwInfoSize
    )
{
    PINTERFACE_STATUS_INFO  pisiInfo;

    TraceEnter("GetInterfaceStatusInfo");
    
    if(*pdwInfoSize < sizeof(INTERFACE_STATUS_INFO))
    {
        *pdwInfoSize = sizeof(INTERFACE_STATUS_INFO);
        
        return ERROR_INSUFFICIENT_BUFFER;
    }
    
    *pdwInfoSize    = sizeof(INTERFACE_STATUS_INFO);
    
    //pToc->InfoVersion sizeof(INTERFACE_STATUS_INFO);
    pToc->InfoSize  = sizeof(INTERFACE_STATUS_INFO);
    pToc->InfoType  = IP_INTERFACE_STATUS_INFO;
    pToc->Count     = 1;
    pToc->Offset    = (ULONG)(pbDataPtr - (PBYTE) pInfoHdr) ;

    pisiInfo = (PINTERFACE_STATUS_INFO)pbDataPtr;

    pisiInfo->dwAdminStatus         = pIcb->dwAdminState;
    
    return NO_ERROR;
}
    
DWORD
SetInterfaceStatusInfo(
    PICB                     pIcb,
    PRTR_INFO_BLOCK_HEADER   pInfoHdr
    )
{
    PINTERFACE_STATUS_INFO  pisiInfo;
    PRTR_TOC_ENTRY          pToc;
    DWORD                   dwResult;
    
    TraceEnter("SetInterfaceStatusInfo");

    
    pToc = GetPointerToTocEntry(IP_INTERFACE_STATUS_INFO, pInfoHdr);

    if((pToc is NULL) or
       (pToc->InfoSize is 0))
    {
        //
        // No TOC means no change. Also empty TOC means no change (IN THIS
        // ONE CASE ONLY)
        //

        return NO_ERROR;
    }


    pisiInfo = (PINTERFACE_STATUS_INFO)GetInfoFromTocEntry(pInfoHdr,
                                                           pToc);

    if (pisiInfo is NULL)
    {
        //
        // no info block means no change.
        //

        return NO_ERROR;
    }
    
    dwResult = SetInterfaceAdminStatus(pIcb,
                                       pisiInfo->dwAdminStatus);

    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "SetInterfaceStatusInfo: Error %d setting admin status for %S",
               dwResult,
               pIcb->pwszName);
    }

    return dwResult;
}
    
VOID
DeAllocateBindings(
    PICB  pIcb
    )
{
    PADAPTER_INFO pBinding;
    
    TraceEnter("DeAllocateBindings");

    ENTER_WRITER(BINDING_LIST);

    //
    // For LAN interfaces we remove the binding from the
    // list and free the addresses
    // For WAN  and IPIP tunnel interfaces, to avoid allocations when 
    // connections are coming up and down, we zero out the fields and keep 
    // the memory around. Which means we need to free the memory and the 
    // binding when the interface is deleted
    //
    
    if((pIcb->ritType is ROUTER_IF_TYPE_DEDICATED) or
       (pIcb->ritType is ROUTER_IF_TYPE_INTERNAL) or
       (pIcb->ritType is ROUTER_IF_TYPE_LOOPBACK))
    {
        if(pIcb->bBound)
        {
            //
            // These can not be unnumbered
            //

            IpRtAssert(pIcb->dwNumAddresses isnot 0);
            IpRtAssert(pIcb->pibBindings);

            RemoveBinding(pIcb);
            
            HeapFree(IPRouterHeap, 0, pIcb->pibBindings);

            pIcb->pibBindings     = NULL;
            pIcb->dwNumAddresses  = 0;
            pIcb->bBound          = FALSE;
            pIcb->dwRemoteAddress = INVALID_IP_ADDRESS;
        }
    }
    else
    {
        pBinding = GetInterfaceBinding(pIcb->dwIfIndex);

        if (pBinding) {
            IpRtAssert(pBinding isnot NULL);
        
            pIcb->bBound        = FALSE;
            pBinding->bBound    = FALSE;

            pIcb->dwNumAddresses      = 0;
            pBinding->dwNumAddresses  = 0;
        
            pIcb->dwRemoteAddress     = INVALID_IP_ADDRESS;
            pBinding->dwRemoteAddress = INVALID_IP_ADDRESS;
        
            pIcb->pibBindings[0].dwAddress     = INVALID_IP_ADDRESS;
            pIcb->pibBindings[0].dwMask        = INVALID_IP_ADDRESS;
            pBinding->rgibBinding[0].dwAddress = INVALID_IP_ADDRESS;
            pBinding->rgibBinding[0].dwMask    = INVALID_IP_ADDRESS;

            g_LastUpdateTable[IPADDRCACHE] = 0;
        }
    }

    EXIT_LOCK(BINDING_LIST);

}

DWORD 
GetInterfaceStatistics(
    IN   PICB       pIcb, 
    OUT  PMIB_IFROW pOutBuffer
    )
{
    DWORD           dwResult;

    dwResult = NO_ERROR;
    
    TraceEnter("GetInterfaceStatistics");

    switch(pIcb->ritType)
    {
        case ROUTER_IF_TYPE_HOME_ROUTER:
        case ROUTER_IF_TYPE_FULL_ROUTER:
        {
            dwResult = AccessIfEntryWanArp(ACCESS_GET,
                                           pIcb,
                                           pOutBuffer);

            pOutBuffer->dwIndex        = pIcb->dwIfIndex;

            wcscpy(pOutBuffer->wszName, pIcb->pwszName);

            pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;
            pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;
       
            strncpy(pOutBuffer->bDescr,
                    g_rgcWanString,
                    MAXLEN_IFDESCR - 1);

            pOutBuffer->dwDescrLen =
                min((MAXLEN_IFDESCR-1),strlen(g_rgcWanString));

            pOutBuffer->bDescr[MAXLEN_IFDESCR -1] = '\0';
 
            break;
        }
            
        case ROUTER_IF_TYPE_DEDICATED:
        case ROUTER_IF_TYPE_TUNNEL1:
        case ROUTER_IF_TYPE_DIALOUT:
        {
            //
            // A Lan Interface that is up
            //
            
            dwResult = GetIfEntryFromStack(pOutBuffer,
                                           pIcb->dwIfIndex,
                                           FALSE);
            
            if(dwResult is NO_ERROR)
            {
                IpRtAssert(pOutBuffer->dwIndex is pIcb->dwIfIndex);

                //
                // Copy out the name too
                //
                
                wcscpy(pOutBuffer->wszName, pIcb->pwszName);

                //
                // Set the user mode status
                //
                
                pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;

                //
                // Till the notification from ipinip to router is done
                // pass the driver status back for tunnels
                //pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;

                if(pIcb->ritType is ROUTER_IF_TYPE_TUNNEL1)
                {
                    strncpy(pOutBuffer->bDescr,
                            g_rgcIpIpString,
                            MAXLEN_IFDESCR - 1);

                    pOutBuffer->dwDescrLen =
                        min((MAXLEN_IFDESCR-1),
                            strlen(g_rgcIpIpString));

                    pOutBuffer->bDescr[MAXLEN_IFDESCR -1] = '\0';

                }
                else
                {
                    pOutBuffer->dwOperStatus = pIcb->dwOperationalState;
                }
            }
            
            break;
        }
        
        case ROUTER_IF_TYPE_INTERNAL:
        {
            
            pOutBuffer->dwIndex = pIcb->dwIfIndex;
            
            wcscpy(pOutBuffer->wszName, pIcb->pwszName);

            pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;
            pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;

            strncpy(pOutBuffer->bDescr,
                    g_rgcInternalString,
                    MAXLEN_IFDESCR - 1);

            pOutBuffer->dwDescrLen =
                min((MAXLEN_IFDESCR-1),strlen(g_rgcInternalString));

            pOutBuffer->bDescr[MAXLEN_IFDESCR -1] = '\0';

            pOutBuffer->dwType = IF_TYPE_PPP;

            dwResult = NO_ERROR;
            
            break;
        }
        
        case ROUTER_IF_TYPE_LOOPBACK:
        {
            
            pOutBuffer->dwIndex = pIcb->dwIfIndex;
            wcscpy(pOutBuffer->wszName, pIcb->pwszName);

            pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;
            pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;

            strncpy(pOutBuffer->bDescr,
                    g_rgcLoopbackString,
                    MAXLEN_IFDESCR - 1);

            pOutBuffer->dwDescrLen =
                min((MAXLEN_IFDESCR-1),strlen(g_rgcLoopbackString));

            pOutBuffer->bDescr[MAXLEN_IFDESCR - 1] = '\0';

            pOutBuffer->dwType  = IF_TYPE_SOFTWARE_LOOPBACK;
            pOutBuffer->dwMtu   = 32768;
            pOutBuffer->dwSpeed = 10000000;

            dwResult = NO_ERROR;
            
            break;
        }

        case ROUTER_IF_TYPE_CLIENT:
        {
            RtlZeroMemory(pOutBuffer,
                          sizeof(MIB_IFROW));

            pOutBuffer->dwIndex        = pIcb->dwIfIndex;

            wcscpy(pOutBuffer->wszName, pIcb->pwszName);

            pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;
            pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;

            pOutBuffer->dwType     = IF_TYPE_PPP;

            dwResult = NO_ERROR;
        }

        default:
        {
            IpRtAssert(FALSE);
        }
    }

    if((dwResult isnot NO_ERROR) and
       ((pIcb->dwOperationalState is NON_OPERATIONAL) or
        (pIcb->dwAdminState is IF_ADMIN_STATUS_DOWN)))
    {
        RtlZeroMemory(pOutBuffer,
                      sizeof(MIB_IFROW));

        pOutBuffer->dwIndex        = pIcb->dwIfIndex;

        wcscpy(pOutBuffer->wszName, pIcb->pwszName);

        pOutBuffer->dwAdminStatus  = pIcb->dwAdminState;
        pOutBuffer->dwOperStatus   = pIcb->dwOperationalState;

        if(pIcb->ritType is ROUTER_IF_TYPE_CLIENT)
        {
            pOutBuffer->dwType     = IF_TYPE_PPP;
        }
        else
        {
            if(pIcb->ritType is ROUTER_IF_TYPE_TUNNEL1)
            {
                strncpy(pOutBuffer->bDescr,
                        g_rgcIpIpString,
                        MAXLEN_IFDESCR - 1);

                pOutBuffer->dwDescrLen =
                    min((MAXLEN_IFDESCR-1),
                        strlen(g_rgcIpIpString));

                pOutBuffer->bDescr[MAXLEN_IFDESCR -1] = '\0';

                pOutBuffer->dwType     = IF_TYPE_TUNNEL;
            }

            pOutBuffer->dwType     = IF_TYPE_OTHER;
        }

        dwResult = NO_ERROR;
    }


    return dwResult;
}



DWORD 
SetInterfaceStatistics(
    IN PICB pIcb, 
    IN PMIB_IFROW lpInBuffer 
    )
{
    DWORD dwResult = NO_ERROR;

    TraceEnter("SetInterfaceStatistics");

    dwResult = SetInterfaceAdminStatus(pIcb,
                                       lpInBuffer->dwAdminStatus);

    if(dwResult isnot NO_ERROR)
    {
        Trace2(ERR,
               "SetInterfaceStatistics: Error %d setting admin status for %S",
               dwResult,
               pIcb->pwszName);
    }

    return dwResult;
}

DWORD
SetInterfaceAdminStatus(
    IN PICB     pIcb, 
    IN DWORD    dwAdminStatus
    )
{
    DWORD   dwResult;

    TraceEnter("SetInterfaceAdminStatus");
        
    //
    // Not allowed to set to TESTING in NT
    //

    CheckBindingConsistency(pIcb);
    
    if(!((dwAdminStatus is IF_ADMIN_STATUS_DOWN) or
         (dwAdminStatus is IF_ADMIN_STATUS_UP)))
    {

        return ERROR_INVALID_PARAMETER;
    }
    
    dwResult = NO_ERROR;
    
    if((pIcb->dwAdminState is IF_ADMIN_STATUS_UP) and
       (dwAdminStatus is IF_ADMIN_STATUS_DOWN))
    {
        //
        // Going from up to down
        //

        dwResult = InterfaceAdminStatusSetToDown(pIcb);

        if(dwResult isnot NO_ERROR)
        {
            Trace2(ERR,
                   "SetInterfaceAdminStatus: Error %d bringing down %S",
                   dwResult,
                   pIcb->pwszName);
        }
    }

    
    if((pIcb->dwAdminState is IF_ADMIN_STATUS_DOWN) and
       (dwAdminStatus is IF_ADMIN_STATUS_UP))
    {
        //
        // Going from down to up
        //

        dwResult = InterfaceAdminStatusSetToUp(pIcb);

        if(dwResult isnot NO_ERROR)
        {
            Trace2(ERR,
                   "SetInterfaceAdminStatus: Error %d bringing up %S",
                   dwResult,
                   pIcb->pwszName);
        }
    }
    

    //
    // Check the state after you leave
    //

    CheckBindingConsistency(pIcb);
    
    //
    // All other cases, no change
    //
    
    return dwResult;
}

DWORD
InterfaceAdminStatusSetToUp(
    IN  PICB    pIcb
    )
{
    DWORD       dwResult;
    MIB_IFROW   riInBuffer;

    TraceEnter("InterfaceAdminStatusSetToUp");
    
    riInBuffer.dwIndex       = pIcb->dwIfIndex;
    riInBuffer.dwAdminStatus = IF_ADMIN_STATUS_UP;

    //
    // Going from Down to UP
    //

    dwResult = NO_ERROR;

    //
    // Set the state to UP first so that any functions that checks it sees that
    // we want to be up
    //
    
    pIcb->dwAdminState = IF_ADMIN_STATUS_UP;
    
    switch(pIcb->ritType)
    {
        case ROUTER_IF_TYPE_HOME_ROUTER:
        case ROUTER_IF_TYPE_FULL_ROUTER:
        {
            //
            // Couldnt be in down state and have been connecting or
            // connected
            //
            
            IpRtAssert((pIcb->dwOperationalState isnot CONNECTING) and
                       (pIcb->dwOperationalState isnot CONNECTED));
           

            dwResult = AccessIfEntryWanArp(ACCESS_SET,
                                           pIcb,
                                           &riInBuffer);
            
            if(dwResult isnot NO_ERROR)
            {
                Trace1(ERR,
                       "InterfaceAdminStatusSetToUp: Couldnt set IFEntry for %S",
                       pIcb->pwszName);

                pIcb->dwAdminState = IF_ADMIN_STATUS_DOWN;
            }   
            else
            {
                WanInterfaceDownToInactive(pIcb);
            }
            
            break;
        }

        case ROUTER_IF_TYPE_DEDICATED:
        case ROUTER_IF_TYPE_TUNNEL1:
        {
            //
            // Bring the stuff up in stack
            // We need to set to stack before we add routes etc
            //

            riInBuffer.dwIndex = pIcb->dwIfIndex;

            //
            // Force an update
            //
            
            dwResult = SetIfEntryToStack(&riInBuffer,
                                         TRUE);
            
            if(dwResult isnot NO_ERROR)
            {
                Trace2(ERR,
                       "InterfaceAdminStatusSetToDown: Couldnt set IFEntry for %S. Error %d",
                       pIcb->pwszName,
                       dwResult);

                LanEtcInterfaceUpToDown(pIcb,
                                        FALSE);

                pIcb->dwAdminState = IF_ADMIN_STATUS_DOWN;

                dwResult = ERROR_CAN_NOT_COMPLETE;

                break;
            }

            dwResult = LanEtcInterfaceDownToUp(pIcb,
                                               FALSE);

            if(dwResult isnot NO_ERROR)
            {
                Trace1(ERR,
                       "InterfaceAdminStatusSetToUp: Error %d bringing up LanInterface",
                       dwResult);
                
                pIcb->dwAdminState = IF_ADMIN_STATUS_DOWN;
            }

            break;
        }
        
        default:
        {
            // TBD: Handle other types too

            Trace1(ERR,
                   "InterfaceAdminStatusSetToUp: Tried to set status for %S",
                   pIcb->pwszName);
            
            break;
        }
    }
 
    //
    // If we succeeded in setting status, let DIM know
    //
 
    if(dwResult is NO_ERROR)
    {
        IpRtAssert(pIcb->dwAdminState is IF_ADMIN_STATUS_UP);

        EnableInterfaceWithAllProtocols(pIcb);
        
        EnableInterfaceWithDIM(pIcb->hDIMHandle,
                               PID_IP,
                               TRUE);
    }

    return dwResult;
}

DWORD
InterfaceAdminStatusSetToDown(
    IN  PICB    pIcb
    )
{
    DWORD           dwResult;
    MIB_IFROW       riInBuffer;
    
    TraceEnter("InterfaceAdminStatusSetToDown");
    
    riInBuffer.dwIndex       = pIcb->dwIfIndex;
    riInBuffer.dwAdminStatus = IF_ADMIN_STATUS_DOWN;
    
    //
    // Going from up to down
    //
       
    dwResult = NO_ERROR;

    switch(pIcb->ritType)
    {
        case ROUTER_IF_TYPE_DEDICATED:
        case ROUTER_IF_TYPE_TUNNEL1:
        {
            //
            // A Lan Interface that is up or non operational. We can only go
            // to stack if we have an IP Address
            //
          
            if(pIcb->bBound)
            {
                riInBuffer.dwIndex = pIcb->dwIfIndex;

                //
                // Force an update
                //
            
                dwResult = SetIfEntryToStack(&riInBuffer,
                                             TRUE);
            }
                
            if(dwResult isnot NO_ERROR)
            {
                Trace1(ERR,
                       "InterfaceAdminStatusSetToDown: Couldnt set IFEntry for %S",
                       pIcb->pwszName);
            }
            else
            {
                LanEtcInterfaceUpToDown(pIcb,
                                        FALSE);
                
                pIcb->dwAdminState = IF_ADMIN_STATUS_DOWN;
            }

            break;
        }
            
        case ROUTER_IF_TYPE_HOME_ROUTER:
        case ROUTER_IF_TYPE_FULL_ROUTER:
        {
            //
            // A Wan Interface that is down.We need to disable
            // the interface and set the status in WANARP
            //

            if((pIcb->dwOperationalState is CONNECTED) or
               (pIcb->dwOperationalState is CONNECTING))
            {
                Trace1(ERR,
                       "InterfaceAdminStatusSetToDown: Can set %S down since it is a connected WAN interface",
                       pIcb->pwszName);

                dwResult = ERROR_INVALID_DATA;

                break;
            }
                
            dwResult = AccessIfEntryWanArp(ACCESS_SET,
                                           pIcb,
                                           &riInBuffer);
                
            if(dwResult isnot NO_ERROR)
            {
                Trace1(ERR,
                       "InterfaceAdminStatusSetToDown: Couldnt set IFEntry for %S",
                       pIcb->pwszName);
            }
            else
            {
                WanInterfaceInactiveToDown(pIcb,
                                           FALSE);
                    
                pIcb->dwAdminState = IF_ADMIN_STATUS_DOWN;
            }

            break;
        }

        default:
        {
            Trace1(ERR,
                   "InterfaceAdminStatusSetToDown: Tried to set status for %S",
                   pIcb->pwszName);

            break;
        }
            
    }

    //
    // If we succeeded in setting status, let DIM know
    //

    if(pIcb->dwAdminState is IF_ADMIN_STATUS_DOWN)
    {
        DisableInterfaceWithAllProtocols(pIcb);

        EnableInterfaceWithDIM(pIcb->hDIMHandle,
                               PID_IP,
                               FALSE);
    }

    return dwResult;
}

VOID
HandleAddressChangeNotification(
    VOID
    )

/*++

Routine Description

    Called in the context of the worker thread when we get a address change
    notification from winsock

Locks

    Acquires the ICB LOCK as WRITER

Arguments

    None

Return Value

    None

--*/

{
    DWORD       dwResult;
    PLIST_ENTRY pleNode;
    PICB        pIcb;

    ENTER_WRITER(ICB_LIST);

    if(g_pInternalInterfaceCb isnot NULL)
    {
        dwResult = UpdateBindingInformation(g_pInternalInterfaceCb);

        if(dwResult isnot NO_ERROR)
        {
            //
            // Cases in which no address was found
            //

            if(dwResult is ERROR_ADDRESS_ALREADY_ASSOCIATED)
            {
                //
                // This may mean that the i/f had no
                // address and still has no address
                //

                Trace1(IF,
                       "AddressChange: No address change for %S",
                       g_pInternalInterfaceCb->pwszName);

            }
            else
            {
                if(dwResult is ERROR_NO_DATA)
                {
                    //
                    // No data means we had an address and now have none
                    //

                    IpRtAssert(!g_bUninitServer);

                    dwResult = LanEtcInterfaceUpToDown(g_pInternalInterfaceCb,
                                                       FALSE);

                    g_bUninitServer = TRUE;

                    if(dwResult isnot NO_ERROR)
                    {
                        Trace2(ERR,
                               "AddressChange: Error %d bringing down interface %S",
                               dwResult,
                               g_pInternalInterfaceCb->pwszName);
                    }
                }
                else
                {
                    //
                    // All others
                    //

                    Trace2(ERR,
                           "AddressChange: Error %d trying to update binding for %S",
                           dwResult,
                           g_pInternalInterfaceCb->pwszName);
                }
            }
        }
        else
        {
            //
            // Cases in which an address was actually read out
            //

            if(g_bUninitServer)
            {
                //
                // First time we are getting an address
                //

                g_bUninitServer = FALSE;

                dwResult = LanEtcInterfaceDownToUp(g_pInternalInterfaceCb,
                                                   FALSE);

                if(dwResult isnot NO_ERROR)
                {
                    Trace1(ERR,
                           "AddressChange: Error %d bringing up server if",
                           dwResult);
                }
            }
            else
            {
                //
                // We had an address, it is changing
                //

                UnbindInterfaceInAllProtocols(g_pInternalInterfaceCb);

                BindInterfaceInAllProtocols(g_pInternalInterfaceCb);
            }
        }
    }

    for(pleNode = &ICBList;
        pleNode->Flink isnot &ICBList;
        pleNode = pleNode->Flink)
    {
        pIcb = CONTAINING_RECORD(pleNode->Flink,
                                 ICB,
                                 leIfLink);


        //
        // Already handled the INTERNAL case above, We only
        // handle LAN cards here
        //

        if(pIcb->ritType isnot ROUTER_IF_TYPE_DEDICATED)
        {
            continue;
        }

        if(pIcb->dwOperationalState is IF_OPER_STATUS_NON_OPERATIONAL)
        {
            //
            // If the admin state is down, we skip the interface
            //

            if(pIcb->dwAdminState isnot IF_ADMIN_STATUS_UP)
            {
                continue;
            }

            //
            // If the interface is DOWN, maybe this DHCP event will get it 
            // up. So lets try that first
            //

            IpRtAssert(pIcb->bBound is FALSE);

            dwResult = LanEtcInterfaceDownToUp(pIcb,
                                               FALSE);

            if(dwResult isnot NO_ERROR)
            {
                Trace2(IF,
                       "AddressChange: Tried to bring up %S on receiving DHCP notification. However LanInterfaceDownToUp() returned error %d",
                       pIcb->pwszName,
                       dwResult);
            }
            else
            {
                Trace1(IF,
                       "AddressChange: Succesfully brought up %S",
                       pIcb->pwszName);
            }

            continue;
        }

        //
        // This interface was already up. Maybe the
        // address is changing
        //

        IpRtAssert(pIcb->bBound);

        dwResult = UpdateBindingInformation(pIcb);

        CheckBindingConsistency(pIcb);

        if(dwResult isnot NO_ERROR)
        {
            if(dwResult is ERROR_ADDRESS_ALREADY_ASSOCIATED)
            {
                //
                // This may mean that the i/f had no
                // address and still has no address
                //

                Trace1(IF,
                       "AddressChange: No address change for %S",
                       pIcb->pwszName);

                continue;
            }

            if(dwResult is ERROR_NO_DATA)
            {
                //
                // No data means we lost addresses
                //

                dwResult = LanEtcInterfaceUpToDown(pIcb,
                                                   FALSE);

                if(dwResult isnot NO_ERROR)
                {
                    Trace2(ERR,
                           "AddressChange: Error %d bringing down interface %S",
                           dwResult,
                           pIcb->pwszName);
                }

                continue;
            }

            Trace2(ERR,
                   "AddressChange: Error %d trying to update binding for %S",
                   dwResult,
                   pIcb->pwszName);

            continue;
        }

        //
        // Addresses changed so bind and unbind
        // with all protocols
        //

        UnbindInterfaceInAllProtocols(pIcb);

        BindInterfaceInAllProtocols(pIcb);

        UpdateAdvertisement(pIcb);
    }

    EXIT_LOCK(ICB_LIST);

}

DWORD
UpdateBindingInformation(
    PICB pIcb
    )

/*++
  
Routine Description

    Reads the registry for the ip address and mask associated with the
    interface. Then calls down into the stack to get a valid index
  
Locks 


Arguments
      

Return Value

    NO_ERROR        There was an address change and a new address was found
    ERROR_NO_DATA   No addresses were found (and there were addresses on
                    this interface originally) 
    ERROR_ADDRESS_ALREADY_ASSOCIATED 
        If there is no change in addresses. Also returned if the interface
        had no addresses to begin with and still has no addresses


--*/

{
    DWORD           dwResult, dwNumNewAddresses, dwNumOldAddresses;
    PICB_BINDING    pNewBinding,pOldBinding;
    DWORD           dwNewIfIndex,dwBCastBit,dwReasmSize;
    BOOL            bFound, bChange, bStack;
    DWORD           i, j;
    PWCHAR          pwszName;

    DWORD           dwAddr, dwLen;

    TraceEnter("UpdateBindingInformation");

    CheckBindingConsistency(pIcb);
   
    //
    // Only called for LAN and ras server interfaces. These DO NOT run in
    // unnumbered mode. Thus we can continue making assumptions that
    // if bound, dwNumAddresses != 0
    //
 
    if((pIcb->ritType isnot ROUTER_IF_TYPE_DEDICATED) and
       (pIcb->ritType isnot ROUTER_IF_TYPE_INTERNAL))
    {
        Trace2(IF,
               "UpdateBindingInformation: %S is type %d so not updating binding information",
               pIcb->pwszName,
               pIcb->ritType);

        return ERROR_ADDRESS_ALREADY_ASSOCIATED;
    }

    IpRtAssert((pIcb->dwIfIndex isnot 0) and 
               (pIcb->dwIfIndex isnot INVALID_IF_INDEX));

    dwNumNewAddresses   = 0;
    pNewBinding         = NULL;
    pOldBinding         = pIcb->pibBindings;
    dwNumOldAddresses   = pIcb->dwNumAddresses;


    dwResult = GetIpInfoForInterface(pIcb->dwIfIndex,
                                     &dwNumNewAddresses,
                                     &pNewBinding,
                                     &dwBCastBit,
                                     &dwReasmSize);

    if(dwResult isnot NO_ERROR)
    {
        if(dwResult isnot ERROR_NO_DATA)
        {
            Trace2(ERR,
                   "UpdateBindingInformation: Error %d getting IP info for interface %S",
                   dwResult,
                   pIcb->pwszName);
        }
        else
        {
            //
            // If no addresses were found and there were no addresses to begin
            // with, then change the error code
            //

            if(pIcb->dwNumAddresses is 0)
            {
                dwResult = ERROR_ADDRESS_ALREADY_ASSOCIATED;
            }
        }

        return dwResult;
    }
            
    IpRtAssert(dwNumNewAddresses);
    IpRtAssert(pNewBinding);

    //
    // Make sure you will find an adapter index. Otherwise all this is no use
    //


#if DBG
        
    for(i = 0; i < dwNumNewAddresses; i++)
    {
        Trace4(IF,
               "UpdateBindingInformation: Interface: %S, Address: %d.%d.%d.%d Mask: %d.%d.%d.%d Index: 0x%x", 
               pIcb->pwszName, 
               PRINT_IPADDR(pNewBinding[i].dwAddress),
               PRINT_IPADDR(pNewBinding[i].dwMask),
               pIcb->dwIfIndex);
    }

#endif
    
    //
    // At this point the interface can be considered bound
    //

    pIcb->bBound = TRUE;
    
    //
    // Go through the address you have and if they dont appear in the list of 
    // the ones you read out, delete the associated static route
    //

    bChange = FALSE;

    for(i = 0; i < dwNumOldAddresses; i++)
    {
        bFound = FALSE;
        
        for(j = 0; j < dwNumNewAddresses; j++)
        {
            //
            // Check both the mask and the address
            //

            if((pOldBinding[i].dwAddress is pNewBinding[j].dwAddress) and
               (pOldBinding[i].dwMask is pNewBinding[j].dwMask))
            {
                bFound = TRUE;

                break;
            }
        }

        if(!bFound)
        {
            bChange = TRUE;
            
            //
            // Only delete routes we would have added in the first place
            //

            Trace2(IF,
                   "UpdateBindingInformation: Address %d.%d.%d.%d existed on %S earlier, but is now absent",
                   PRINT_IPADDR(pOldBinding[i].dwAddress),
                   pIcb->pwszName);
            
            DeleteAutomaticRoutes(pIcb,
                                  pOldBinding[i].dwAddress,
                                  pOldBinding[i].dwMask);
        }
    }

    //
    // Now go through the stuff read out from the registry and see if you 
    // already have the address(es). 
    //
    
    for(i = 0; i < dwNumNewAddresses; i++)
    {
        bFound = FALSE;
        
        for(j = 0; j < dwNumOldAddresses; j++)
        {
            if((pNewBinding[i].dwAddress is pOldBinding[j].dwAddress) and
               (pNewBinding[i].dwMask is pOldBinding[j].dwMask))
            {
                bFound = TRUE;

                break;
            }
        }

        if(!bFound)
        {
            bChange = TRUE;
        }
    }

    if(!bChange)
    {
        //
        // No change so we can leave
        //

        if(pNewBinding)
        {
            HeapFree(IPRouterHeap,
                     0,
                     pNewBinding);
        }

        return ERROR_ADDRESS_ALREADY_ASSOCIATED;
    }
    
    //
    // So there has been some change
    // At this point we need to add the binding to the hash table
    //

    ENTER_WRITER(BINDING_LIST);

    //
    // If you had old bindings, remove them
    // Also remove the adapter to Interface map
    //

    if(pOldBinding)
    {
        RemoveBinding(pIcb);
    }

    pIcb->pibBindings         = pNewBinding;
    pIcb->dwNumAddresses      = dwNumNewAddresses;
    pIcb->dwBCastBit          = dwBCastBit;
    pIcb->dwReassemblySize    = dwReasmSize;
        
    
    AddBinding(pIcb);

    //
    // We do the same thing we did above, but now we add the routes.
    // We cant do this before because the adapter id and binding info
    // hasnt been set in the hash table
    //

    for(i = 0; i < dwNumNewAddresses; i++)
    {
        bFound = FALSE;
        
        for(j = 0; j < dwNumOldAddresses; j++)
        {
            if((pNewBinding[i].dwAddress is pOldBinding[j].dwAddress) and
               (pNewBinding[i].dwMask is pOldBinding[j].dwMask))
            {
                bFound = TRUE;
            }
        }

        if(!bFound)
        {
            Trace3(IF,
                   "UpdateBindingInformation: Address %d.%d.%d.%d/%d.%d.%d.%d new for %S",
                   PRINT_IPADDR(pNewBinding[i].dwAddress),
                   PRINT_IPADDR(pNewBinding[i].dwMask),
                   pIcb->pwszName);
            
            AddAutomaticRoutes(pIcb,
                               pNewBinding[i].dwAddress,
                               pNewBinding[i].dwMask);
        }
    }
   
    if(pOldBinding)
    { 
        HeapFree(IPRouterHeap,
                 0,
                 pOldBinding);
    }

    //
    // Such interfaces can not have a kernel context
    //
        
    EXIT_LOCK(BINDING_LIST);

    return NO_ERROR;
}


DWORD
GetAdapterInfo(
    DWORD    dwIpAddress,
    PDWORD   pdwAdapterId,
    PDWORD   pdwBCastBit,
    PDWORD   pdwReasmSize
    )

/*++
  
Routine Description

    Queries the tcpip driver with IP_MIB_STATS to figure out the
    adapter index for the adapter with the given ip address.
  
Locks 


Arguments
      

Return Value

    Index if successfule
    INVALID_IF_INDEX otherwise
    
--*/

{
    DWORD   i, dwNumEntries, MatchIndex, dwResult, Size;
    
    PMIB_IPADDRTABLE pAddrTable;
    
    *pdwAdapterId    = INVALID_ADAPTER_ID;
    *pdwBCastBit     = 1;
    *pdwReasmSize    = 0;
    
    dwResult = AllocateAndGetIpAddrTableFromStack(&pAddrTable,
                                                  FALSE,
                                                  IPRouterHeap,
                                                  0);
    
    if(dwResult isnot NO_ERROR) 
    {

        Trace1(ERR,
               "GetAdapterInfo: Error %d getting IP Address table from stack",
               dwResult);

        return dwResult;
    }
    
    for (i = 0; i < pAddrTable->dwNumEntries; i++) 
    {
        if(pAddrTable->table[i].dwAddr is dwIpAddress) 
        {
            *pdwAdapterId       = pAddrTable->table[i].dwIndex;
            *pdwBCastBit        = pAddrTable->table[i].dwBCastAddr;
            *pdwReasmSize       = pAddrTable->table[i].dwReasmSize;

            HeapFree(IPRouterHeap,
                     0,
                     pAddrTable);
            
            return NO_ERROR;
        }
    }

    HeapFree(IPRouterHeap,
             0,
             pAddrTable);
            
    return ERROR_INVALID_DATA;
}

DWORD
GetBestNextHopMaskGivenICB(
    PICB     pIcb,
    DWORD    dwNextHopAddr
    )

/*++

Routine Description

    Gets the longest mask for the next hop
  
Locks 


Arguments

    pIcb           the Interface Control Block over which the route goes out
    dwNextHopAddr  The next hop addr

Return Value

    0xFFFFFFFF if not found

--*/

{
    DWORD           i, dwLastMask;
    
#if DBG
    
    BOOL    bFound = FALSE;
    
#endif

    CheckBindingConsistency(pIcb);
    
    dwLastMask = 0;
    
    for(i = 0; i < pIcb->dwNumAddresses; i++)
    {
        if((pIcb->pibBindings[i].dwAddress & pIcb->pibBindings[i].dwMask) is
           (dwNextHopAddr & pIcb->pibBindings[i].dwMask))
        {

#if DBG            
            bFound = TRUE;
#endif
            if(pIcb->pibBindings[i].dwMask > dwLastMask)
            {
                dwLastMask = pIcb->pibBindings[i].dwMask;
            }
        }
    }

#if DBG
    
    if(!bFound)
    {
        Trace2(ERR,
               "GetBestNextHopMaskGivenICB: Didnt find match. I/f 0x%x Nexthop %x",
               pIcb->dwIfIndex,
               dwNextHopAddr);
    }
    
#endif

    if(dwLastMask is 0x00000000)
    {
        return 0xFFFFFFFF;
    }
    else
    {
        return dwLastMask;
    }
}

DWORD
GetBestNextHopMaskGivenIndex(
    DWORD  dwIfIndex,
    DWORD  dwNextHopAddr
    )

/*++

Routine Description

    Gets the longest mask for the next hop
  
Locks 


Arguments

    pIcb           the Interface Control Block over which the route goes out
    dwNextHopAddr  The next hop addr

Return Value

    0x00000000 if not found

--*/

{
    PICB pIcb;

    pIcb = InterfaceLookupByIfIndex(dwIfIndex);

    if(pIcb is NULL)
    {
        Trace1(ERR,
               "GetBestNextHopMaskGivenIndex: Couldnt find pIcb for index 0x%x",
               dwIfIndex);

        return 0x00000000;
    }

    return GetBestNextHopMaskGivenICB(pIcb,
                                      dwNextHopAddr);
}

DWORD
InitializeLoopbackInterface(
    PICB    pIcb
    )
{
    DWORD               dwResult, i, j;
    PADAPTER_INFO       pBindNode;
    INTERFACE_ROUTE_INFO rifRoute;
    PLIST_ENTRY         pleNode;

    TraceEnter("InitLoopIf");
    
    g_pLoopbackInterfaceCb = pIcb;
    
    dwResult = GetAdapterInfo(IP_LOOPBACK_ADDRESS,
                              &(pIcb->dwIfIndex),
                              &(pIcb->dwBCastBit),
                              &(pIcb->dwReassemblySize));

    if(dwResult isnot NO_ERROR)
    {
        Trace0(ERR,
               "InitLoopIf: Couldnt find adapter id for loopback interface");

        return ERROR_CAN_NOT_COMPLETE;
    }

    IpRtAssert(pIcb->dwIfIndex is LOOPBACK_INTERFACE_INDEX);

    IpRtAssert(pIcb->pibBindings isnot NULL);

    //
    // This will always have one address
    //

    pIcb->dwNumAddresses = 1;
    pIcb->bBound         = TRUE;
    
    //
    // Loopback interfaces have a class A mask
    //

    pIcb->pibBindings[0].dwAddress   = IP_LOOPBACK_ADDRESS;
    pIcb->pibBindings[0].dwMask      = CLASSA_MASK;
        
    ENTER_WRITER(BINDING_LIST);

    pBindNode = GetInterfaceBinding(pIcb->dwIfIndex);

    if(!pBindNode)
    {
        Trace1(ERR,
               "IniteLoopIf: Binding not found for %S",
               pIcb->pwszName);

        IpRtAssert(FALSE);

        //
        // Something really bad happened and we didnt have a
        // bind block for the interface
        //

        AddBinding(pIcb);
    }
    else
    {
        pBindNode->bBound                   = TRUE;
        pBindNode->dwNumAddresses           = 1;
        pBindNode->dwRemoteAddress          = INVALID_IP_ADDRESS;
        pBindNode->rgibBinding[0].dwAddress = IP_LOOPBACK_ADDRESS;
        pBindNode->rgibBinding[0].dwMask    = CLASSA_MASK;

        pBindNode->dwBCastBit               = pIcb->dwBCastBit;
        pBindNode->dwReassemblySize         = pIcb->dwReassemblySize;
        pBindNode->ritType                  = pIcb->ritType;
    }
    
    EXIT_LOCK(BINDING_LIST);
    
    rifRoute.dwRtInfoMask          = CLASSA_MASK;
    rifRoute.dwRtInfoNextHop       = IP_LOOPBACK_ADDRESS;
    rifRoute.dwRtInfoDest          = (IP_LOOPBACK_ADDRESS & CLASSA_MASK);
    rifRoute.dwRtInfoIfIndex       = pIcb->dwIfIndex;
    rifRoute.dwRtInfoMetric1       = 1;
    rifRoute.dwRtInfoMetric2       = 0;
    rifRoute.dwRtInfoMetric3       = 0;
    rifRoute.dwRtInfoViewSet       = RTM_VIEW_MASK_UCAST |
                                      RTM_VIEW_MASK_MCAST; // XXX config
    rifRoute.dwRtInfoPreference    = ComputeRouteMetric(MIB_IPPROTO_LOCAL);
    rifRoute.dwRtInfoType          = MIB_IPROUTE_TYPE_DIRECT;
    rifRoute.dwRtInfoProto         = MIB_IPPROTO_LOCAL;
    rifRoute.dwRtInfoAge           = 0;
    rifRoute.dwRtInfoNextHopAS     = 0;
    rifRoute.dwRtInfoPolicy        = 0;

    dwResult = AddSingleRoute(pIcb->dwIfIndex,
                              &rifRoute,
                              CLASSA_MASK,
                              0,     // RTM_ROUTE_INFO::Flags
                              FALSE, // We dont know what protocols might do
                              FALSE, // No need to add to stack
                              FALSE,
                              NULL);

    //
    // Now we need to go through all the bindings that are there
    // and add the loopback route for them. We do this here because
    // the loopback interface may be add AFTER the other interfaces
    //
    
    //
    // NOTE - this is going to take a lock recursively when it goes
    // to rtmif.c
    //

    ENTER_READER(BINDING_LIST);

    for(i = 0; i < BINDING_HASH_TABLE_SIZE; i++)
    {
        for(pleNode = g_leBindingTable[i].Flink;
            pleNode isnot &g_leBindingTable[i];
            pleNode = pleNode->Flink)
        {
            PADAPTER_INFO   pBinding;

            pBinding = CONTAINING_RECORD(pleNode, ADAPTER_INFO, leHashLink);

            for(j = 0; j < pBinding->dwNumAddresses; j++)
            {
                if(pBinding->rgibBinding[j].dwAddress is INVALID_IP_ADDRESS)
                {
                    continue;
                }

                AddLoopbackRoute( 
                    pBinding->rgibBinding[j].dwAddress,
                    pBinding->rgibBinding[j].dwMask
                    );
            }
        }
    }
    
    EXIT_LOCK(BINDING_LIST);
    
    return NO_ERROR;
}

DWORD
IpIpTunnelInitToDown(
    PICB    pIcb
    )
{
    return NO_ERROR;
}

DWORD
LanEtcInterfaceInitToDown(
    PICB pIcb
    )
{
    DWORD           dwResult, dwNumAddresses, dwMask;
    PICB_BINDING    pBinding;
    DWORD           dwIfIndex = INVALID_IF_INDEX,dwBCastBit,dwReasmSize;
    DWORD           i;
    MIB_IFROW       riInBuffer;
    PWCHAR          pwszName;
    PLIST_ENTRY     ple;
    PROUTE_LIST_ENTRY prl;
    
    IPRouteEntry    *pRouteEntry;

    TraceEnter("LanInterfaceInitToDown");

    dwNumAddresses  = 0;
    pBinding        = NULL;
    pwszName        = pIcb->pwszName;
    
    dwResult = ReadAddressFromRegistry(pwszName,
                                       &dwNumAddresses,
                                       &pBinding,
                                       FALSE);
    
    if(dwResult isnot NO_ERROR) 
    {
        //
        // If there is no data, means the lan card wasnot UP anyway
        //

        if(dwResult is ERROR_NO_DATA)
        {
            return NO_ERROR;
        }
        
        Trace2(ERR, 
               "LanInterfaceInitToDown: Error %d reading IP Address information for interface %S",
               dwResult,
               pIcb->pwszName);

        return dwResult;
    }

    //
    // Make sure you will find an adapter index. Otherwise all this is no use
    //

    for(i = 0; i < dwNumAddresses; i++)
    {
        //
        // Try to get an index using all possible addresses
        //
        
        dwResult = GetAdapterInfo(pBinding[i].dwAddress,
                                  &dwIfIndex,
                                  &dwBCastBit,
                                  &dwReasmSize);

        if(dwResult is NO_ERROR)
        {
            //
            // Ok so we found a valid index from a good address
            //

            break;
        }
    }
        
    if((dwIfIndex is INVALID_IF_INDEX) or
       (dwIfIndex isnot pIcb->dwIfIndex))
    {
        Trace2(ERR, 
               "LanInterfaceInitToDown: Couldnt find adapter index for interface %S using %d.%d.%d.%d",
               pIcb->pwszName,
               PRINT_IPADDR(pBinding[0].dwAddress));
        
        HeapFree(IPRouterHeap,
                 0,
                 pBinding);
        
        return ERROR_CAN_NOT_COMPLETE;
    }

    //
    // Delete all the routes in the stack
    //

    for (ple = g_leStackRoutesToRestore.Flink;
         ple != &g_leStackRoutesToRestore;
         ple = ple->Flink)
    {
        prl = (PROUTE_LIST_ENTRY) 
                CONTAINING_RECORD(ple, ROUTE_LIST_ENTRY, leRouteList); 

        TraceRoute2(
            ROUTE, "%d.%d.%d.%d/%d.%d.%d.%d",
            PRINT_IPADDR( prl->mibRoute.dwForwardDest ),
            PRINT_IPADDR( prl->mibRoute.dwForwardMask )
            );
                
        if(prl->mibRoute.dwForwardIfIndex isnot dwIfIndex)
        {
            //
            // Not going out over this interface
            //
            
            continue;
        }

        prl->mibRoute.dwForwardType = MIB_IPROUTE_TYPE_INVALID;
        
        dwResult = SetIpForwardEntryToStack(&(prl->mibRoute));
        
        if (dwResult isnot NO_ERROR) 
        {
            Trace2(ERR,
                   "ReinstallOldRoutes: Failed to add route to %x from "
                   " init table. Error %x",
                   prl->mibRoute.dwForwardDest,
                   dwResult);
        }
    }


    //
    // Dont really need it anymore
    //
    
    HeapFree(IPRouterHeap,
             0,
             pBinding);
        

    //
    // Going from up to down
    //

    riInBuffer.dwIndex          = dwIfIndex;
    riInBuffer.dwAdminStatus    = IF_ADMIN_STATUS_DOWN;


    dwResult = SetIfEntryToStack(&riInBuffer,
                                 TRUE);
    
    if(dwResult isnot NO_ERROR)
    {
        Trace1(ERR,
               "LanInterfaceInitToDown: Couldnt set IFEntry for %S",
               pIcb->pwszName);
    }
    
    DeleteAllRoutes(pIcb->dwIfIndex,
                    FALSE);

    return dwResult;
}

DWORD
GetIpInfoForInterface(
    IN  DWORD   dwIfIndex,
    OUT PULONG  pulNumAddresses,
    OUT ICB_BINDING **ppAddresses,
    OUT PDWORD  pdwBCastBit,
    OUT PDWORD  pdwReasmSize
    )

/*++

Routine Description

    Gets the addresses and other ip information for an interface

Locks

    None needed

Arguments

    dwIfIndex,
    pdwNumAddresses
    ppAddresses
    pdwBCastBit
    pdwReasmSize

Return Value

    NO_ERROR
    Win32 Errorcode

--*/

{
    DWORD   dwResult, i;
    ULONG   ulAddrIndex, ulCount, ulValid;

    PMIB_IPADDRTABLE pAddrTable;

    *pulNumAddresses = 0;
    *pdwBCastBit     = 1;
    *pdwReasmSize    = 0;
    *ppAddresses     = NULL;

    dwResult = AllocateAndGetIpAddrTableFromStack(&pAddrTable,
                                                  TRUE,
                                                  IPRouterHeap,
                                                  0);

    if(dwResult isnot NO_ERROR)
    {
        Trace1(ERR,
               "GetIpInfoForInterface: Error %d getting IP Address table from stack",
               dwResult);

        return dwResult;
    }

    ulCount = 0;
    ulValid = 0;

    for (i = 0; i < pAddrTable->dwNumEntries; i++)
    {
        if(pAddrTable->table[i].dwIndex is dwIfIndex)
        {
            ulCount++;

            //
            // Make sure this is not a duplicate. Since this is ordered, we
            // merely check the next address
            //

            if(!(IsValidIpAddress(pAddrTable->table[i].dwAddr)) or
               (pAddrTable->table[i].dwMask is 0))
            {
                //
                // Since this is only called for numbered links
                //

                continue;
            }

            if((i isnot (pAddrTable->dwNumEntries - 1)) and
               (pAddrTable->table[i].dwAddr is pAddrTable->table[i + 1].dwAddr))
            {
                Trace1(ERR,
                       "GetIpInfoForInterface: %d.%d.%d.%d duplicate address",
                       PRINT_IPADDR(pAddrTable->table[i].dwAddr));

                continue;
            }

            ulValid++;
        }
    }

    //
    // See if we have good addresses
    //

    if(ulValid is 0)
    {
        if(ulCount isnot 0)
        {
            Trace1(ERR,
                   "GetIpInfoForInterface: If 0x%x has addresses entries which are 0s",
                   dwIfIndex);
        }

        HeapFree(IPRouterHeap,
                 0,
                 pAddrTable);

        return ERROR_NO_DATA;
    }  

    //
    // Allocate from private heap
    //

    *ppAddresses = HeapAlloc(IPRouterHeap,
                             HEAP_ZERO_MEMORY,
                             (sizeof(ICB_BINDING) * ulValid));

    if(*ppAddresses is NULL)
    {
        Trace0(ERR,
               "GetIpInfoForInterface: Error allocating memory");

        HeapFree(IPRouterHeap,
                 0,
                 pAddrTable);

        return ERROR_NOT_ENOUGH_MEMORY;
    }

    //
    // Now copy out the valid addresses
    //

    ulAddrIndex = 0;

    for (i = 0; i < pAddrTable->dwNumEntries; i++)
    {
        if(pAddrTable->table[i].dwIndex is dwIfIndex)
        {

            if(!(IsValidIpAddress(pAddrTable->table[i].dwAddr)) or
               (pAddrTable->table[i].dwMask is 0))
            {
                continue;
            }

            if((i isnot (pAddrTable->dwNumEntries - 1)) and
               (pAddrTable->table[i].dwAddr is pAddrTable->table[i + 1].dwAddr))
            {
                continue;
            }

            if(!(*pdwReasmSize))
            {
                *pdwReasmSize = pAddrTable->table[i].dwReasmSize;
                *pdwBCastBit  = pAddrTable->table[i].dwBCastAddr;
            }

            (*ppAddresses)[ulAddrIndex].dwAddress = pAddrTable->table[i].dwAddr;
            (*ppAddresses)[ulAddrIndex].dwMask    = pAddrTable->table[i].dwMask;

            ulAddrIndex++;
        }
    }

    IpRtAssert(ulAddrIndex is ulValid);

    *pulNumAddresses = ulValid;

    HeapFree(IPRouterHeap,
             0,
             pAddrTable);

    return NO_ERROR;
}

DWORD
ReadAddressFromRegistry(
    IN  PWCHAR          pwszIfName,
    OUT PDWORD          pdwNumAddresses,
    OUT ICB_BINDING     **ppibAddressInfo,
    IN  BOOL            bInternalIf
    )
{
    HKEY    hadapkey ;
    CHAR    buff[512], pszInterfaceName[256];
    DWORD   dwDhcp, dwResult, dwSize, dwType;
    
    TraceEnter("ReadAddressFromRegistry");

    Trace1(IF,
           "ReadAddressFromRegistry: Reading address for %S",
           pwszIfName);

    wcstombs(pszInterfaceName, pwszIfName, wcslen(pwszIfName));

    pszInterfaceName[wcslen(pwszIfName)] = '\0';

    
    *pdwNumAddresses    = 0;
    *ppibAddressInfo    = NULL;
    
    //
    // The IP address should be in the registry
    //
    
    strcpy(buff, REG_KEY_TCPIP_INTERFACES);
    strcat(buff,"\\");
    strcat(buff, pszInterfaceName) ;


    dwResult = RegOpenKey(HKEY_LOCAL_MACHINE,
                          buff,
                          &hadapkey);
    
    if(dwResult isnot NO_ERROR)
    {
        Trace1(ERR,
               "ReadAddressFromRegistry: Unable to open key %s",
               buff);

        return dwResult;
    }

    dwDhcp = 0;
  
    if(!bInternalIf)
    {
        //
        // Get the EnableDHCP flag
        //

        dwSize = sizeof(DWORD);

        dwResult = RegQueryValueEx(hadapkey,
                                   REGISTRY_ENABLE_DHCP,
                                   NULL,
                                   &dwType,
                                   (PBYTE)&dwDhcp,
                                   &dwSize);

        if(dwResult isnot NO_ERROR)
        {
            Trace0(ERR,
                   "ReadAddressFromRegistry: Unable to read DHCP Enabled key");

            RegCloseKey(hadapkey);

            return dwResult;
        }
    }
    else
    {
        //
        // tcpcfg writes server adapter address as DHCP but
        // does not set dhcp enable
        //

        dwDhcp = 1;
    }
  
    //
    // Get the ip address for the net interface
    //
    
    dwSize = 0 ;

    if(dwDhcp == 0) 
    {
        dwResult = ReadAddressAndMaskValues(hadapkey,
                                            REGISTRY_IPADDRESS,
                                            REGISTRY_SUBNETMASK,
                                            ppibAddressInfo,
                                            pdwNumAddresses);
    }
    else 
    {

        //
        // First try autonet, and if that fails, read the DHCP
        // This needs to be done because the DHCP address is not cleared
        // out when running in autonet mode, but the autonet address is set
        // to 0.0.0.0 when in DHCP mode
        //

        dwResult = ReadAddressAndMaskValues(hadapkey,
                                            REGISTRY_AUTOCONFIGIPADDRESS,
                                            REGISTRY_AUTOCONFIGSUBNETMASK,
                                            ppibAddressInfo,
                                            pdwNumAddresses);

        if(dwResult isnot NO_ERROR)
        {
            dwResult = ReadAddressAndMaskValues(hadapkey,
                                                REGISTRY_DHCPIPADDRESS,
                                                REGISTRY_DHCPSUBNETMASK,
                                                ppibAddressInfo,
                                                pdwNumAddresses);
        }
    }   

    RegCloseKey(hadapkey);

    if(dwResult isnot NO_ERROR)
    {
        Trace3(ERR,
               "ReadAddressFromRegistry: Couldnt read address for %S. Error %d. DHCP %d",
               pwszIfName,
               dwResult,
               dwDhcp);
        
        return dwResult;
    }
    else
    {
#if DBG
        DWORD i;

        Trace2(IF,
               "--%d addresses on %S\n",
               *pdwNumAddresses,
               pwszIfName);

        for(i = 0; i < *pdwNumAddresses; i++)
        {
            Trace1(IF, "%d.%d.%d.%d",
                   PRINT_IPADDR((*ppibAddressInfo)[i].dwAddress));
        }
#endif
    }
    
    
    return dwResult;
}

DWORD
ReadAddressAndMaskValues(
    IN  HKEY        hkeyAdapterSection,
    IN  PSZ         pszRegAddressValue,
    IN  PSZ         pszRegMaskValue,
    OUT ICB_BINDING **ppibAddressInfo,
    OUT PDWORD      pdwNumAddresses
    )
{
    DWORD   dwResult, dwType;
    PBYTE   pbyAddresses,pbyMasks;
    DWORD   dwAddressSize, dwMaskSize;

    dwAddressSize = dwMaskSize  = 0;
    
    dwResult = RegQueryValueEx(hkeyAdapterSection,
                               pszRegAddressValue,
                               NULL,
                               &dwType,
                               NULL,
                               &dwAddressSize);

    if((dwAddressSize is 0) or (dwResult isnot NO_ERROR))
    {
        Trace3(ERR,
               "ReadAddressAndMaskValues: Registry reported size = %d with error %d for size of %s",
               dwAddressSize,
               dwResult,
               pszRegAddressValue);
        
        return ERROR_REGISTRY_CORRUPT;
    }
    
    //
    // We allocate size+4 so that even if we read out a REG_SZ, it looks
    // like a REG_MULTI_SZ to the parse routine because we guarantee atleast
    // 2 terminating NULLS
    // 

    pbyAddresses = HeapAlloc(IPRouterHeap,
                             HEAP_ZERO_MEMORY,
                             dwAddressSize + 4);
    
    if(pbyAddresses is NULL)
    {
        Trace2(ERR,
               "ReadAddressAndMaskValues: Error allocating %d bytes for %s",
               dwAddressSize + 4,
               pszRegAddressValue);

        return ERROR_NOT_ENOUGH_MEMORY;
    }
     
    dwResult = RegQueryValueEx(hkeyAdapterSection,
                               pszRegAddressValue,                               
                               NULL,
                               &dwType,
                               pbyAddresses,
                               &dwAddressSize);

    if(dwResult isnot NO_ERROR)
    {
        HeapFree(IPRouterHeap,
                 0,
                 pbyAddresses);

        Trace2(ERR,
               "ReadAddressAndMaskValues: Error %d reading %s from registry",
               dwResult,
               pszRegAddressValue);
        
        
        return dwResult;
    }
    
    //
    // Now get the subnet mask for the net interface
    //
    
    dwResult = RegQueryValueEx(hkeyAdapterSection,
                               pszRegMaskValue,
                               NULL,
                               &dwType,
                               NULL,
                               &dwMaskSize);
    
    if((dwMaskSize is 0) or (dwResult isnot NO_ERROR))
    {
        HeapFree(IPRouterHeap,
                 0,
                 pbyAddresses);
        
        Trace3(ERR,
               "ReadAddressAndMaskValues: Registry reported size = %d with error %d for size of %s",
               dwMaskSize,
               dwResult,
               pszRegMaskValue);
        
        return ERROR_REGISTRY_CORRUPT;
    }
    
    pbyMasks = HeapAlloc(IPRouterHeap,
                         HEAP_ZERO_MEMORY,
                         dwMaskSize + 4);
    
    if(pbyMasks is NULL)
    {
        HeapFree(IPRouterHeap,
                 0,
                 pbyAddresses);

        
        Trace2(ERR,
               "ReadAddressAndMaskValues: Error allocating %d bytes for %s",
               dwMaskSize + 4,
               pszRegMaskValue);
        
        return ERROR_NOT_ENOUGH_MEMORY;
    }
    
    dwResult = RegQueryValueEx(hkeyAdapterSection,
                               pszRegMaskValue,
                               NULL,
                               &dwType,
                               pbyMasks,
                               &dwMaskSize) ;
    
    if(dwResult isnot NO_ERROR)
    {
        HeapFree(IPRouterHeap,
                 0,
                 pbyAddresses);
        
        HeapFree(IPRouterHeap,
                 0,
                 pbyMasks);

        
        Trace2(ERR,
               "ReadAddressAndMaskValues: Error %d reading %s from registry",
               dwResult,
               pszRegMaskValue);
        
        return dwResult;
    }

    dwResult = ParseAddressAndMask(pbyAddresses,
                                   dwAddressSize,
                                   pbyMasks,
                                   dwMaskSize,
                                   ppibAddressInfo,
                                   pdwNumAddresses);
    
    HeapFree(IPRouterHeap,
             0,
             pbyAddresses);
    
    HeapFree(IPRouterHeap,
             0,
             pbyMasks);
    
    return dwResult;
}

DWORD
ParseAddressAndMask(
    IN  PBYTE       pbyAddresses,
    IN  DWORD       dwAddressSize,
    IN  PBYTE       pbyMasks,
    IN  DWORD       dwMaskSize,
    OUT ICB_BINDING **ppibAddressInfo,
    OUT PDWORD      pdwNumAddresses
    )
{
    DWORD   dwAddrCount, dwMaskCount, dwTempLen, dwAddrIndex;
    DWORD   dwMask, dwAddr, i, j;
    PBYTE   pbyTempAddr, pbyTempMask;
    BOOL    bDuplicate;


    *pdwNumAddresses = 0;
    *ppibAddressInfo = NULL;
    
    //
    // If there are only two characters in the string or if the
    // the first two are NULL, we have no data. Due to tcp/ip config
    // we may be passed a REG_SZ instead of a REG_MULTI_SZ. The code works
    // around that by assuming that if a REG_SZ was read out then extra 
    // padding was added to the end so that we ALWAYS have 2 terminating NULLs
    //
    
    if((dwAddressSize < 2) or
       ((pbyAddresses[0] is '\0') and
        (pbyAddresses[1] is '\0')))
    {
        Trace0(IF,
               "ParseAddressAndMask: No addresses found");
        
        return ERROR_NO_DATA;
    }


    //
    // The mask should also have some data
    //

    
    if((dwMaskSize < 2) or
       ((pbyMasks[0] is '\0') and
        (pbyMasks[1] is '\0')))
    {
        Trace0(IF,
               "ParseAddressAndMask: No masks found");
        
        return ERROR_NO_DATA;
    }
    
        
    //
    // Count the number of addresses
    //
    
    dwAddrCount = 0;
    pbyTempAddr = pbyAddresses;
    dwTempLen   = dwAddressSize;
        
    while(dwTempLen)
    {
        if(*pbyTempAddr == '\0')
        {
            dwAddrCount++;
            
            if(*(pbyTempAddr+1) == '\0')
            {
                break;
            }
        }

        pbyTempAddr++ ;
        
        dwTempLen-- ;
    }

    
    if(dwAddrCount is 0)
    {
        Trace0(IF,
               "ParseAddressAndMask: No addresses found");
        
        return ERROR_NO_DATA;
    }

    //
    // Count the number of masks
    //
    
    dwMaskCount = 0;
    pbyTempMask = pbyMasks;
    dwTempLen   = dwMaskSize;
        
    while(dwTempLen)
    {
        if(*pbyTempMask is '\0')
        {
            dwMaskCount++;
            
            if(*(pbyTempMask+1) is '\0')
            {
                break;
            }
        }

        pbyTempMask++ ;
        
        dwTempLen-- ;
    }

    //
    // Make sure that the two are the same
    //

    if(dwAddrCount isnot dwMaskCount)
    {
        Trace0(IF,
               "ParseAddressAndMask: Address and mask count is not same");
        
        return ERROR_NO_DATA;
    }
            
    //
    // Allocate the memory required to store all the addresses
    //

    *ppibAddressInfo = HeapAlloc(IPRouterHeap,
                                 HEAP_ZERO_MEMORY,
                                 (sizeof(ICB_BINDING) * dwAddrCount));

    if(*ppibAddressInfo is NULL)
    {
        Trace1(ERR,
               "ParseAddressAndMask: Error allocating %d bytes for AddressInfo",
               sizeof(ICB_BINDING) * dwAddrCount);

        return ERROR_NOT_ENOUGH_MEMORY;
    }
     
    pbyTempAddr = pbyAddresses;
    pbyTempMask = pbyMasks;

    dwAddrIndex = 0;
 
    for (i = 0; i < dwAddrCount; i++)
    {
        dwAddr = inet_addr(pbyTempAddr);
        dwMask = inet_addr(pbyTempMask);

        pbyTempAddr = strchr(pbyTempAddr, '\0');
        pbyTempMask = strchr(pbyTempMask, '\0');

        pbyTempAddr++;
        pbyTempMask++;

        bDuplicate = FALSE;

        for(j = 0; j < dwAddrIndex; j++)
        {
            if((*ppibAddressInfo)[j].dwAddress is dwAddr)
            {

                Trace1(ERR,
                       "ParseAddressAndMask: Addr %x is duplicate",
                       dwAddr);

                bDuplicate = TRUE;
                
                break;
            }
        }
        
        if(bDuplicate or
           (dwAddr is INVALID_IP_ADDRESS) or
           (dwMask is 0x00000000))
        {
            continue;
        }

        (*ppibAddressInfo)[dwAddrIndex].dwAddress    = dwAddr;
        (*ppibAddressInfo)[dwAddrIndex].dwMask       = dwMask;

        dwAddrIndex++;
    }

    *pdwNumAddresses = dwAddrIndex; 
   
    
    //
    // Make sure that there is atleast one valid address
    //


    if(dwAddrIndex is 0)
    {
        Trace0(ERR,
               "ParseAddressAndMask: No valid addresses found");
        
        HeapFree(IPRouterHeap,
                 0,
                 *ppibAddressInfo);
        
        *ppibAddressInfo    = NULL;

        return ERROR_NO_DATA;
    }

    return NO_ERROR;
}

DWORD
SetInterfaceReceiveType(
    IN  DWORD   dwProtocolId,
    IN  DWORD   dwIfIndex,
    IN  DWORD   dwInterfaceReceiveType,
    IN  BOOL    bActivate
    )

{
    DWORD                       dwResult;
    IO_STATUS_BLOCK             ioStatus;
    IP_SET_IF_PROMISCUOUS_INFO  PromInfo;
    HANDLE                      hEvent;

    hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

    if(hEvent is NULL)
    {
        dwResult = GetLastError();

        Trace1(ERR,
               "SetInterfaceReceiveType: Error %d creating event",
               dwResult);

        return dwResult;
    }

    if(dwInterfaceReceiveType is IR_PROMISCUOUS_MULTICAST)
    {
        PromInfo.Type  = PROMISCUOUS_MCAST;
    }
    else
    {
        if(dwInterfaceReceiveType is IR_PROMISCUOUS)
        {
            PromInfo.Type  = PROMISCUOUS_BCAST;
        }
        else
        {
            return ERROR_INVALID_PARAMETER;
        }
    }

    PromInfo.Index = dwIfIndex;
    PromInfo.Add   = bActivate?1:0;

    dwResult = NtDeviceIoControlFile(g_hIpDevice,
                                     hEvent,
                                     NULL,
                                     NULL,
                                     &ioStatus,
                                     IOCTL_IP_SET_IF_PROMISCUOUS,
                                     (PVOID)&PromInfo,
                                     sizeof(IP_SET_IF_PROMISCUOUS_INFO),
                                     NULL,
                                     0);

    if(dwResult is STATUS_PENDING)
    {
        Trace0(ERR,
               "SetInterfaceReceiveType: Pending from ioctl");

        dwResult = WaitForSingleObject(hEvent,
                                       INFINITE);

        if(dwResult isnot WAIT_OBJECT_0) // 0
        {
            Trace1(ERR,
                   "SetInterfaceReceiveType: Error %d from wait",
                   dwResult);

            dwResult = GetLastError();
        }
        else
        {
            dwResult = STATUS_SUCCESS;
        }
    }

    if(dwResult isnot STATUS_SUCCESS)
    {
        Trace4(ERR,
               "SetInterfaceReceiveType: NtStatus %x while %s i/f %x into %s mode",
               dwResult,
               (PromInfo.Add == 1) ? "activating" : "deactivating",
               dwIfIndex,
               (PromInfo.Type == PROMISCUOUS_MCAST) ? "prom mcast" : "prom all");

        return dwResult;
    }

    return NO_ERROR;
} 

DWORD
HandleMediaSenseEvent(
    IN  PICB    pIcb,
    IN  BOOL    bSensed
    )
    
/*++

Routine Description:

    Called when media sense status changes for a LAN interface

Locks:

    Called with the ICB list lock held as WRITER

Arguments:

    pIcb    ICB of the interface for which the event it
    bSensed TRUE is cable is present

Return Value:

    NO_ERROR

--*/

{
    DWORD   dwErr;

    return NO_ERROR;

    //
    // Not for NT 5.0
    //

    if(pIcb->ritType isnot ROUTER_IF_TYPE_DEDICATED)
    {
        IpRtAssert(FALSE);

        return ERROR_INVALID_PARAMETER;
    }

    if(bSensed)
    {
        //
        // Bring the interface up
        //

        dwErr = LanEtcInterfaceDownToUp(pIcb,
                                        FALSE);
    }
    else
    {
        dwErr = LanEtcInterfaceUpToDown(pIcb,
                                        FALSE);
    }

    if(dwErr isnot NO_ERROR)
    {
        Trace2(ERR,
               "HandleMediaSense: Err %d when changing status for %S",
               dwErr,
               pIcb->pwszName);
    }

    return dwErr;
}

DWORD
GetRouterId()
{
    PLIST_ENTRY pleNode;
    PICB        picb;
    ULONG       ulIdx;
    DWORD       dwRouterId      = -1; // lower is better
    DWORD       dwRouterTypePri = -1; // lower is better
    DWORD       dwTypePri;
    
    TraceEnter("GetRouterId");

    ENTER_READER(ICB_LIST);

    for (pleNode = ICBList.Flink;   // walk the ICBList
         pleNode isnot &ICBList;
         pleNode = pleNode->Flink)
    {
        picb = CONTAINING_RECORD (pleNode, ICB, leIfLink) ;

        // Get Type priority
        switch(picb->ritType) {
        case ROUTER_IF_TYPE_LOOPBACK : dwTypePri = 0;  break; // best
        case ROUTER_IF_TYPE_INTERNAL : dwTypePri = 1;  break;
        case ROUTER_IF_TYPE_TUNNEL1  : dwTypePri = 2;  break; 
        case ROUTER_IF_TYPE_DEDICATED: dwTypePri = 3;  break; 
        default:                       dwTypePri = 10; break; // worst
        }

        // Walk addresses
        for (ulIdx=0; ulIdx<picb->dwNumAddresses; ulIdx++)
        {
            if (!IS_ROUTABLE(picb->pibBindings[ulIdx].dwAddress))
            {
                continue;
            }

            // update if better
            if (dwTypePri < dwRouterTypePri
             || (dwTypePri==dwRouterTypePri 
                  && picb->pibBindings[ulIdx].dwAddress<dwRouterId))
            {
                dwRouterTypePri = dwTypePri;
                dwRouterId      = picb->pibBindings[ulIdx].dwAddress;
            }
        }
    }

    // *** Exclusion End ***
    EXIT_LOCK(ICB_LIST);

    TraceLeave("GetRouterId");

    return dwRouterId;
}