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

//=============================================================================
// Copyright (c) 1997 Microsoft Corporation
// Module Name: If.c
//
// Abstract:
//      This module implements some of the Igmp API's related with interfaces.
//      _AddInterface, _DeleteInterface, _EnableInterface, _DisableInterface,
//      _BindInterface, _UnbindInterface, _ConnectRasClient, _DisconectRasClient,
//      _SetInterfaceConfigInfo, _GetInterfaceConfigInfo.
//
// Author: K.S.Lokesh (lokeshs@)   11-1-97
//=============================================================================


#include "pchigmp.h"
#pragma hdrstop



//------------------------------------------------------------------------------
//          _AddInterface
//
// This api is called to add an interface to Igmp. The interface can be a Proxy
// or an Igmp router(v1/v2). Further, the interface can be a RAS or DemandDial
// or a Permanent interface. This routine creates the interface entry and 
// associated structures including timers.
//
// Locks: Runs completely in ListLock and ExclusiveIfLock.
// Calls: _AddIfEntry()
// Return Values: ERROR_CAN_NOT_COMPLETE, Error, NO_ERROR.
//------------------------------------------------------------------------------
DWORD
WINAPI
AddInterface(
    IN PWCHAR               pwszInterfaceName,//not used
    IN ULONG                IfIndex,
    IN NET_INTERFACE_TYPE   dwIfType,
    IN DWORD                dwMediaType,
    IN WORD                 wAccessType,
    IN WORD                 wConnectionType,
    IN PVOID                pvConfig,
    IN ULONG                ulStructureVersion,
    IN ULONG                ulStructureSize,
    IN ULONG                ulStructureCount
    )
{
    DWORD   Error=NO_ERROR;
    CHAR    str[60];

    
    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    // make sure it is not an unsupported igmp version structure
    if (ulStructureVersion>=IGMP_CONFIG_VERSION_600) {
        Trace1(ERR, "Unsupported IGMP version structure: %0x",
            ulStructureVersion);
        IgmpAssertOnError(FALSE);
        LeaveIgmpApi();
        return ERROR_CAN_NOT_COMPLETE;
    }

    switch (dwIfType) {
        case PERMANENT: //lan
            lstrcpy(str, "PERMANENT(IGMP_IF_NOT_RAS)"); break;
        case DEMAND_DIAL: 
            lstrcpy(str, "DEMAND_DIAL(IGMP_IF_RAS_ROUTER)");break;
        case LOCAL_WORKSTATION_DIAL: 
            lstrcpy(str, "LOCAL_WORKSTATION_DIAL(IGMP_IF_RAS_SERVER)"); break;
    }
    
    Trace2(ENTER, "entering AddInterface(): IfIndex:%0x IfType:%s", 
            IfIndex, str);



    // entire procedure runs in IfListLock and exclusive IfLock.

    ACQUIRE_IF_LIST_LOCK("_AddInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_AddInterface");

    
    //
    // create the interface entry
    //
    Error = AddIfEntry(IfIndex, dwIfType, (PIGMP_MIB_IF_CONFIG)pvConfig,
                ulStructureVersion, ulStructureSize
                );



    RELEASE_IF_LIST_LOCK("_AddInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_AddInterface");

    Trace2(LEAVE1, "leaving AddInterface(%d): %d\n", IfIndex, Error);
    if (Error!=NO_ERROR) {
        Trace1(ERR, "Error adding interface:%0x to IGMP\n", IfIndex);
        IgmpAssertOnError(FALSE);
    }        
    LeaveIgmpApi();
    return Error;
}



//------------------------------------------------------------------------------
//          _AddIfEntry
//
// Creates and initializes a new interface entry and associated data structures.
//
// Called by: _AddInterface().
// Locks: Assumes IfListLock and exclusive IfLock throughout.
//------------------------------------------------------------------------------
DWORD
AddIfEntry(
    DWORD               IfIndex,
    NET_INTERFACE_TYPE  dwExternalIfType,
    PIGMP_MIB_IF_CONFIG pConfigExt,
    ULONG               ulStructureVersion,
    ULONG               ulStructureSize
    )
{
    DWORD               Error = NO_ERROR, IfType;
    PIF_TABLE_ENTRY     pite = NULL;
    PLIST_ENTRY         ple, phead;
    PIGMP_IF_TABLE      pIfTable = g_pIfTable;
    BOOL                bProxy;
    
    

    BEGIN_BREAKOUT_BLOCK1 {
    
        //
        // fail if the interface exists.
        //
        pite = GetIfByIndex(IfIndex);

        if (pite != NULL) {
            Trace1(ERR, "interface %d already exists", IfIndex);
            IgmpAssertOnError(FALSE);
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }

        // convert iftype to igmp iftype
        
        switch (dwExternalIfType) {
        
            case PERMANENT : 
                IfType = IGMP_IF_NOT_RAS;
                break;
            
            case DEMAND_DIAL:
                IfType = IGMP_IF_RAS_ROUTER;
                break;
                
            case LOCAL_WORKSTATION_DIAL:
            {
                IfType = IGMP_IF_RAS_SERVER;


                // currently there can be at most one ras table entry
                
                if (g_RasIfIndex!=0) {
                    Trace2(ERR, 
                        "Error. Cannot have more than one ras server IF(%d:%d)",
                        g_RasIfIndex, IfIndex
                        );
                    IgmpAssertOnError(FALSE);
                    Error = ERROR_CAN_NOT_COMPLETE;
                    Logerr0(RAS_IF_EXISTS, Error);
                    GOTO_END_BLOCK1;
                }
                
                break;
            }
            
            case REMOTE_WORKSTATION_DIAL :
                Error = ERROR_INVALID_PARAMETER;
                break;

            default :
                Error = ERROR_INVALID_PARAMETER;
                break;

        } //end switch (IfType)

        
        // Validate the interface config

        Error = ValidateIfConfig(pConfigExt, IfIndex, IfType, 
                    ulStructureVersion, ulStructureSize
                    );
        if (Error!=NO_ERROR)
            GOTO_END_BLOCK1;


        //
        // allocate memory for the new interface and Zero it.
        // Fields that are to be initialized to 0 or NULL are commented out.
        //
        pite = IGMP_ALLOC(sizeof(IF_TABLE_ENTRY), 0x2, IfIndex);
        PROCESS_ALLOC_FAILURE3(pite, 
                "error %d allocating %d bytes for interface %d", Error, 
                sizeof(IF_TABLE_ENTRY), IfIndex, 
                GOTO_END_BLOCK1);
        Trace2(CONFIG, "IfEntry %0x for IfIndex:%0x", (ULONG_PTR)pite, IfIndex);

        ZeroMemory(pite, sizeof(IF_TABLE_ENTRY));

        
        //
        // set the interface type
        //
        pite->IfType = (UCHAR)IfType;


        //
        // if proxy, make sure that a proxy interface does not already exist
        //
        if ( IS_CONFIG_IGMPPROXY(pConfigExt) ){

            bProxy = TRUE;


            //
            // multiple proxy interfaces cannot exist
            //
            if (g_ProxyIfIndex!=0) {
                
                Error =  ERROR_CAN_NOT_COMPLETE;
                Trace1(IF, "Cannot create multiple proxy interfaces. "
                        "If %d is Proxy",  g_ProxyIfIndex);
                Logerr0(PROXY_IF_EXISTS, Error);
                
                GOTO_END_BLOCK1;
            }
        } 
        
        else  {
            bProxy = FALSE;
        }

    } END_BREAKOUT_BLOCK1;
            
    
    if (Error != NO_ERROR) {
        IGMP_FREE_NOT_NULL(pite);
        
        return Error;
    }


    //
    // initialize fields for the interface
    //
    InitializeListHead(&pite->LinkByAddr);
    InitializeListHead(&pite->LinkByIndex);
    InitializeListHead(&pite->HTLinkByIndex);
    InitializeListHead(&pite->ListOfSameIfGroups);
    InitializeListHead(&pite->ListOfSameIfGroupsNew);
    InitializeListHead(&pite->Config.ListOfStaticGroups);
    //pite->NumGIEntriesInNewList = 0;


    // IfType already set before
    
    pite->IfIndex = IfIndex;


    // Ip addr set when interface is bound
    //pite->IpAddr = 0; 


    // set interface status (neither bound, enabled or activated)
    pite->Status = IF_CREATED_FLAG;



    // copy the interface config

    CopyinIfConfig(&pite->Config, pConfigExt, IfIndex);



    // initialize the Info struct, and If bindings to 0/NULL
    //pite->pBinding = NULL;
    //ZeroMemory(&pite->Info, sizeof(IF_INFO));
    


    //
    // Create RAS table if it is a RAS server interface
    //
    if ( IS_RAS_SERVER_IF(pite->IfType)) {
        InitializeRasTable(IfIndex, pite);
    }
    else {
        //pite->pRasTable = NULL;
    }



    //
    // initialize the sockets to invalid_socket
    //
    pite->SocketEntry.Socket = INVALID_SOCKET;
    pite->SocketEntry.pSocketEventsEntry = NULL;
    InitializeListHead(&pite->SocketEntry.LinkByInterfaces);
    
    
    
    // set (non)query timer to not created. 
    //Other fields set in activate interface.
    //pite->QueryTimer.Status = 0;
    //pite->NonQueryTimer.Status = 0;

    
    //pite->pPrevIfGroupEnumPtr = NULL;
    //pite->PrevIfGroupEnumSignature = 0;
    pite->StaticGroupSocket = INVALID_SOCKET;
    


    //  insert the interface in the hash table at the end.

    InsertTailList(&pIfTable->HashTableByIndex[IF_HASH_VALUE(IfIndex)],
                    &pite->HTLinkByIndex);


    //
    // insert the interface into the list ordered by index
    //
    {
        PIF_TABLE_ENTRY piteTmp;
        
        phead = &pIfTable->ListByIndex;
        for (ple=phead->Flink;  ple!=phead;  ple=ple->Flink) {

            piteTmp = CONTAINING_RECORD(ple, IF_TABLE_ENTRY, LinkByIndex);
            if (pite->IfIndex < piteTmp->IfIndex) 
                break;
        }
    }
    
    InsertTailList(ple, &pite->LinkByIndex);



    // changes to the interface table fields.

    pIfTable->NumInterfaces++;



    // the interface will be inserted into list ordered by IpAddr
    // when it is activated.



    //
    // create proxy HT, and set proxy info in global structure.
    //
    if (bProxy) {
    
        DWORD   dwSize = PROXY_HASH_TABLE_SZ * sizeof(LIST_ENTRY);
        DWORD   i;
        PLIST_ENTRY pProxyHashTable;
        

        BEGIN_BREAKOUT_BLOCK2 {
        
            pProxyHashTable = pite->pProxyHashTable = IGMP_ALLOC(dwSize, 0x4, 
                                                                IfIndex);

            PROCESS_ALLOC_FAILURE2(pProxyHashTable, 
                    "error %d allocating %d bytes for interface table",
                    Error, dwSize, GOTO_END_BLOCK2);

            for (i=0;  i<PROXY_HASH_TABLE_SZ;  i++) {
                InitializeListHead(pProxyHashTable+i);
            }


            InterlockedExchangePointer(&g_pProxyIfEntry, pite);
            InterlockedExchange(&g_ProxyIfIndex, IfIndex);

            pite->CreationFlags |= CREATED_PROXY_HASH_TABLE;

        } END_BREAKOUT_BLOCK2;
    }


    //
    // set ras info in global structure. Ras table already created before.
    //
    if (IS_RAS_SERVER_IF(pite->IfType)) {
        InterlockedExchangePointer(&g_pRasIfEntry, pite);
        InterlockedExchange(&g_RasIfIndex, IfIndex);
    }


    if ( (Error!=NO_ERROR)&&(pite!=NULL) )
        DeleteIfEntry(pite);

        
    return Error;
    
} //end _AddIfEntry




//------------------------------------------------------------------------------
//          _DeleteInterface
//
// Deletes the interface, deactivating if it is activated.
//
// Calls: _DeleteIfEntry()
// Locks: Exclusive SocketsLock, IfListLock, Exclusive IfLock
//------------------------------------------------------------------------------
DWORD
DeleteInterface(
    IN DWORD IfIndex
    )
{
    DWORD            Error = NO_ERROR;
    PIF_TABLE_ENTRY  pite = NULL;


    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace1(ENTER, "entering DeleteInterface: %0x", IfIndex);


    //
    // acquire exclusive SocketsLock, IfListLock, Exclusive IfLock
    //
    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_DeleteInterface");
    ACQUIRE_IF_LIST_LOCK("_DeleteInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_DeleteInterface");


    
    // retrieve the interface specified

    pite = GetIfByIndex(IfIndex);

    if (pite == NULL) {
        Trace1(ERR,
            "_DeleteInterface() called for non existing interface(%d)", IfIndex);
        IgmpAssertOnError(FALSE);
        Error = ERROR_INVALID_PARAMETER;
    }

    // delete the interface if found.
    else {
    
        Error = DeleteIfEntry(pite);

        //DebugCheck
        DebugScanMemoryInterface(IfIndex);
    }
    

    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_DeleteInterface");
    RELEASE_IF_LIST_LOCK("_DeleteInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_DeleteInterface");

    Trace2(LEAVE, "Leaving DeleteInterface(%d): %d\n", IfIndex, Error);

    LeaveIgmpApi();

    return NO_ERROR;
}



//------------------------------------------------------------------------------
//          _DeleteIfEntry
//
// Assumes exclusive IF lock. Marks the interface as deleted, and removes it
// from all global lists. Then queues a work item to do a lazy delete of 
// the Interface structures without having to take the exclusive IF lock.
// If Ras interface, the work item will delete the Ras clients also.
//
// Called by: _DeleteInterface() or _AddIfEntry()
// Calls: 
//    _WF_CompleteIfDeactivateDelete (this calls _DeActivateInterfaceComplete())
// Lock:
//    runs in exclusive SocketLock, IfListLock, exclusive IfLock
//------------------------------------------------------------------------------

DWORD
DeleteIfEntry (
    PIF_TABLE_ENTRY pite
    )
{
    DWORD   dwRetval, Error = NO_ERROR;
    BOOL    bProxy = IS_PROTOCOL_TYPE_PROXY(pite);


    //
    // Set deleted flag for the interface
    //
    pite->Status |= DELETED_FLAG;


    //
    // remove the interface from the InterfaceHashTable and IfIndex lists.
    //
    RemoveEntryList(&pite->LinkByIndex);
    RemoveEntryList(&pite->HTLinkByIndex);


    //
    // if activated, remove the interface from the list of activated interfaces
    // and if proxy or ras server, remove from global table.
    //

    // do not replace the below with IS_IF_ACTIVATED, as deleted flag is set
    if (pite->Status&IF_ACTIVATED_FLAG)
        RemoveEntryList(&pite->LinkByAddr);
    
    if (bProxy) {
        InterlockedExchangePointer(&g_pProxyIfEntry, NULL);
        InterlockedExchange(&g_ProxyIfIndex, 0);        
    }
    
    if (g_pRasIfEntry == pite) {
        InterlockedExchangePointer(&g_pRasIfEntry, NULL);
        InterlockedExchange(&g_RasIfIndex, 0);
    }

    
    //
    // From now on, the interface cannot be accessed from any global list
    // and  is as good as deleted. The only way it can be accessed is 
    // through group list enumeration and timers getting fired, or input on
    // socket.
    //

       
    //
    // if Interface activated, deactivate it
    // Note: deleted flag is already set. 
    //
    
    if (pite->Status&IF_ACTIVATED_FLAG) {

        //
        // I have already removed the interface from the list of activated 
        // interfaces
        //


        //
        // Call MGM to release the interface ownership. If proxy then
        // deregister proxy protocol from Mgm. If RAS, deregister all clients
        //
        
        DeActivationDeregisterFromMgm(pite);
        
        
        //
        // queue work item to deactivate and delete the interface. 
        //
        // _WF_CompleteIfDeactivateDelete will delete the Ras clients,
        // GI entries, and deinitialize pite structure. It will call
        // _CompleteIfDeletion() in the end.
        //
        
        CompleteIfDeactivateDelete(pite);
    }

    //
    // if it is not activated, then go ahead and delete it completely.
    //
    else {

        CompleteIfDeletion(pite);
    }


    // decrement the total number of interfaces
    
    g_pIfTable->NumInterfaces--;


    return NO_ERROR;

} //end _DeleteIfEntry



//------------------------------------------------------------------------------
//          _CompleteIfDeletion
//
// Frees memory with the static groups, frees
// rasTable, proxyHashTable, binding and pite. 
//
// Called by:
//    _DeleteIfEntry() if interface is not activated.
//    _DeActivateInterfaceComplete() if the pite deleted flag is set.
//------------------------------------------------------------------------------
VOID
CompleteIfDeletion (
    PIF_TABLE_ENTRY     pite
    )
{
    if (pite==NULL)
        return;

        
    //
    // delete all static groups.
    //
    {
        PIF_STATIC_GROUP    pStaticGroup;
        PLIST_ENTRY         pHead, ple;
        
        pHead = &pite->Config.ListOfStaticGroups;
        for (ple=pHead->Flink;  ple!=pHead;  ) {
            pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
            ple = ple->Flink;
            IGMP_FREE(pStaticGroup);
        }
    }
    

    // if ras server, then delete ras table.
    
    if ( IS_RAS_SERVER_IF(pite->IfType) ) {

        IGMP_FREE(pite->pRasTable);
    }


    //
    // if proxy interface, then delete the proxy Hash Table
    //
    if (IS_PROTOCOL_TYPE_PROXY(pite)) {
        if ( (pite->CreationFlags&CREATED_PROXY_HASH_TABLE)
            && pite->pProxyHashTable
            ) {

            // clean the hash table entries
            {
                DWORD               i;
                PPROXY_GROUP_ENTRY  ppge;
                PLIST_ENTRY         pHead, ple, 
                                    pProxyHashTable = pite->pProxyHashTable;
                

                for (i=0;  i<PROXY_HASH_TABLE_SZ;  i++) {
                    pHead = &pProxyHashTable[i];

                    for (ple=pHead->Flink;  ple!=pHead;  ) {

                        ppge = CONTAINING_RECORD(ple, PROXY_GROUP_ENTRY, HT_Link);
                        ple=ple->Flink;

                        // delete all sources
                        {
                            PLIST_ENTRY pHeadSrc, pleSrc;
                            PPROXY_SOURCE_ENTRY pSourceEntry;
                            
                            pHeadSrc = &ppge->ListSources;
                            for (pleSrc=pHeadSrc->Flink;  pleSrc!=pHeadSrc; ) {

                                pSourceEntry = CONTAINING_RECORD(pleSrc, 
                                                    PROXY_SOURCE_ENTRY, LinkSources);
                                pleSrc = pleSrc->Flink;

                                IGMP_FREE(pSourceEntry);
                            }
                        }
                        
                        IGMP_FREE(ppge);
                    }

                    InitializeListHead(pHead);
                }
            }

            IGMP_FREE_NOT_NULL(pite->pProxyHashTable);
        }
    }

    // delete the bindings

    IGMP_FREE_NOT_NULL(pite->pBinding);

    
    // delete the interface table entry

    IGMP_FREE(pite);

    return;
}



//------------------------------------------------------------------------------
//             _ActivateInterface
//
// an interface is activated: when it is bound, enabled by routerMgr & in config
// When activated, 
// (1) call is made to MGM to take interface ownership, 
// (2) static groups are appropriately joined, and socket for it created if req.
// (3) Igmprtr: query timer and input socket is activated.
// Note: it is already put in the list of activated IFs(ordered by IpAddr)
//
// Locks: assumes socketLock, IfListLock, exclusive IfLock
// Called by: _BindIfEntry, _EnableIfEntry, 
//------------------------------------------------------------------------------
DWORD
ActivateInterface (
    PIF_TABLE_ENTRY    pite
    )
{
    DWORD                   IfIndex = pite->IfIndex;
    PIGMP_IF_CONFIG         pConfig = &pite->Config;
    PIF_INFO                pInfo = &pite->Info;
    PIGMP_TIMER_ENTRY       pQueryTimer = &pite->QueryTimer,
                            pNonQueryTimer = &pite->NonQueryTimer;
    LONGLONG                llCurTime = GetCurrentIgmpTime();
    BOOL                    bProxy = IS_PROTOCOL_TYPE_PROXY(pite);
    DWORD                   Error = NO_ERROR;
    PLIST_ENTRY             pHead, ple;
    PIF_STATIC_GROUP        pStaticGroup;
    
    
    Trace2(ENTER, "entering ActivateInterface(%d:%d.%d.%d.%d)", 
                IfIndex, PRINT_IPADDR(pite->IpAddr));


    BEGIN_BREAKOUT_BLOCK1 {

        //
        // set time when it is activated
        //
        pite->Info.TimeWhenActivated = llCurTime;


        
        //
        // create sockets for interface
        //
        Error = CreateIfSockets(pite);

        if (Error != NO_ERROR) {

            Trace2(IF, "error %d initializing sockets for interface %d", Error,
                        pite->IfIndex);
            GOTO_END_BLOCK1;
        }
        pite->CreationFlags |= SOCKETS_CREATED;


        

            
        //------------------------------------------
        // PROXY INTERFACE PROCESSING (break at end)
        //------------------------------------------
        if (bProxy) {


            //
            // set status to activated here so that the MGM (*,*) join callbacks will 
            // be successful.
            //
            pite->Status |= IF_ACTIVATED_FLAG;

            

            //
            // register the protocol with mgm
            //
            Error = RegisterProtocolWithMgm(PROTO_IP_IGMP_PROXY);
            if (Error!=NO_ERROR)
                GOTO_END_BLOCK1;
            pite->CreationFlags |= REGISTERED_PROTOCOL_WITH_MGM;



            //
            // enumerate all existing groups from MGM
            //
            {
                DWORD               dwBufferSize, dwNumEntries, dwRetval, i;
                MGM_ENUM_TYPES      MgmEnumType = 0;
                SOURCE_GROUP_ENTRY  BufferSGEntries[20];
                HANDLE              hMgmEnum;
                

                // start enumeration

                dwBufferSize = sizeof(SOURCE_GROUP_ENTRY)*20;
                
                Error = MgmGroupEnumerationStart(g_MgmProxyHandle, MgmEnumType, 
                                                &hMgmEnum);
                if (Error!=NO_ERROR) {
                    Trace1(ERR, "MgmGroupEnumerationStart() returned error:%d", 
                            Error);
                    IgmpAssertOnError(FALSE);
                    GOTO_END_BLOCK1;
                }



                // get group entries from mgm
                // and insert group into Proxy's group list / increment refcount
                
                do {

                    
                    dwRetval = MgmGroupEnumerationGetNext(hMgmEnum, &dwBufferSize,
                                                        (PBYTE)&BufferSGEntries, 
                                                        &dwNumEntries);

                
                    for (i=0;  i<dwNumEntries;  i++) {

                        ProcessProxyGroupChange(BufferSGEntries[i].dwSourceAddr, 
                                                BufferSGEntries[i].dwGroupAddr, 
                                                ADD_FLAG, NOT_STATIC_GROUP);
                    }
                    
                } while (dwRetval==ERROR_MORE_DATA);



                // end enumeration
                
                dwRetval = MgmGroupEnumerationEnd(hMgmEnum);
                if (dwRetval!=NO_ERROR) {
                    Trace1(ERR, "MgmGroupEnumerationEnd() returned error:%d", 
                            dwRetval);
                    IgmpAssertOnError(FALSE);
                }
            } //end block:enumerate existing groups



            //
            // take interface ownership
            //
            Error = MgmTakeInterfaceOwnership(g_MgmProxyHandle, IfIndex, 0);

            if (Error!=NO_ERROR) {
                Trace1(MGM, "MgmTakeInterfaceOwnership rejected for interface %d", 
                        IfIndex);
                Logerr0(MGM_TAKE_IF_OWNERSHIP_FAILED, Error);
                GOTO_END_BLOCK1;
            }
            else {
                Trace1(MGM, "MgmTakeInterfaceOwnership successful for interface %d", 
                        IfIndex);
            }
            
            pite->CreationFlags |= TAKEN_INTERFACE_OWNERSHIP_WITH_MGM;



            //
            // proxy does a (*,*) join
            //
            Error = MgmAddGroupMembershipEntry(g_MgmProxyHandle, 0, 0, 0, 0,
                                                IfIndex, 0, MGM_JOIN_STATE_FLAG);
            if (Error!=NO_ERROR) {
                Trace1(ERR, 
                    "Proxy failed to add *,* entry to MGM on interface %d",
                    IfIndex);
                IgmpAssertOnError(FALSE);
                GOTO_END_BLOCK1;
            }
            
            Trace0(MGM, "proxy added *,* entry to MGM");
            pite->CreationFlags|= DONE_STAR_STAR_JOIN;


            //
            // do static joins
            //
            pHead = &pite->Config.ListOfStaticGroups;
            for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {
                DWORD i;
                
                pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
                for (i=0;  i<pStaticGroup->NumSources;  i++) {
                    ProcessProxyGroupChange(pStaticGroup->Sources[i], pStaticGroup->GroupAddr, 
                                            ADD_FLAG, STATIC_GROUP);
                }

                if (pStaticGroup->NumSources==0)
                    ProcessProxyGroupChange(0, pStaticGroup->GroupAddr, 
                                            ADD_FLAG, STATIC_GROUP);
            }

            
            GOTO_END_BLOCK1;
            
        } // done processing for a proxy interface



        //-----------------------------------------
        //    IGMP ROUTER INTERFACE
        //-----------------------------------------


        //
        // take interface ownership
        //
        Error = MgmTakeInterfaceOwnership(g_MgmIgmprtrHandle, IfIndex, 0);

        if (Error!=NO_ERROR) {
            Trace1(MGM, "TakeInterfaceOwnership rejected for interface %d", 
                    IfIndex);
            Logerr0(MGM_TAKE_IF_OWNERSHIP_FAILED, Error);
            GOTO_END_BLOCK1;
        }
        pite->CreationFlags |= TAKEN_INTERFACE_OWNERSHIP_WITH_MGM;
        

        //
        // see if any other MCast protocol is owning that interface
        // this affects whether a non-querier registers group with Mgm or not
        //
        {
            DWORD   dwProtoId, dwComponentId;
            
            MgmGetProtocolOnInterface(IfIndex, 0, &dwProtoId, &dwComponentId);
            if (dwProtoId==PROTO_IP_IGMP) {
                SET_MPROTOCOL_ABSENT_ON_IGMPRTR(pite);
            }
            else {
                SET_MPROTOCOL_PRESENT_ON_IGMPRTR(pite);
            }
        }

        //
        // when interface is activated, it is by default enabled by mgm.
        //
        MGM_ENABLE_IGMPRTR(pite);
        
        
        //
        // if ras server interface, then register all the ras clients as they 
        // would not have been registered
        //
        if (IS_RAS_SERVER_IF(pite->IfType)) {
        
            PRAS_TABLE_ENTRY    prte;
            PLIST_ENTRY         pHead, ple;
            
            // join all ras clients
            pHead = &pite->pRasTable->ListByAddr;
            for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {

                prte = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);
                
                MgmTakeInterfaceOwnership(g_MgmIgmprtrHandle,  IfIndex, 
                                            prte->NHAddr);
                
                if (Error!=NO_ERROR) {
                    Trace2(MGM, 
                        "TakeInterfaceOwnership rejected for interface %d "
                        "NHAddr(%d.%d.%d.%d)",
                        IfIndex, PRINT_IPADDR(prte->NHAddr));
                    Logerr0(MGM_TAKE_IF_OWNERSHIP_FAILED, Error);
                }
            }
        }



        //
        // INITIALIZE THE INFO STRUCTURE AND SET THE TIMERS
        //

        //
        // start as querier with version specified in the config
        //
        pInfo->QuerierState = RTR_QUERIER;

        pInfo->QuerierIpAddr = pite->IpAddr;

        pInfo->LastQuerierChangeTime = llCurTime;

        
        //
        // how many startup queries left to be sent 
        //
        pInfo->StartupQueryCountCurrent = pConfig->StartupQueryCount;
        {
            MIB_IFROW   TmpIfEntry;

            TmpIfEntry.dwIndex = IfIndex;
            if (GetIfEntry(&TmpIfEntry ) == NO_ERROR)
                pInfo->PacketSize = TmpIfEntry.dwMtu;
            else
                pInfo->PacketSize = INPUT_PACKET_SZ;
        }

                        
        //
        // initialize the query timer
        //
        pQueryTimer->Function = T_QueryTimer;
        pQueryTimer->Context = &pQueryTimer->Context;
        pQueryTimer->Timeout = pConfig->StartupQueryInterval;
        pQueryTimer->Status = TIMER_STATUS_CREATED;

        //
        // initialize non query timer
        //
        pNonQueryTimer->Function = T_NonQueryTimer;
        pNonQueryTimer->Context = &pNonQueryTimer->Context;
        pNonQueryTimer->Timeout = pConfig->OtherQuerierPresentInterval;
        pNonQueryTimer->Status = TIMER_STATUS_CREATED;

        
        //
        // take timer lock and insert timers into the list
        //
        ACQUIRE_TIMER_LOCK("_ActivateInterface");

        //
        // insert querier timer in the list
        //
        #if DEBUG_TIMER_TIMERID
            SET_TIMER_ID(pQueryTimer, 110, IfIndex, 0, 0);
        #endif;
        
        InsertTimer(pQueryTimer, pQueryTimer->Timeout, TRUE, DBG_Y);
        
        RELEASE_TIMER_LOCK("_ActivateInterface");


        
        //
        // activate Input socket
        //
        Error = WSAEventSelect(pite->SocketEntry.Socket, 
                            pite->SocketEntry.pSocketEventsEntry->InputEvent, 
                            FD_READ
                            );

        if (Error != NO_ERROR) {
            Trace3(IF, "WSAEventSelect returned %d for interface %d (%d.%d.%d.%d)",
                    Error, IfIndex, PRINT_IPADDR(pite->IpAddr));
            Logerr1(EVENTSELECT_FAILED, "%I", pite->IpAddr, 0);
            GOTO_END_BLOCK1;
        }


        //
        // set the activated flag here so that the joins will work
        //
        pite->Status |= IF_ACTIVATED_FLAG;

        
        if (pInfo->StartupQueryCountCurrent) {

            //
            // send the initial general query
            //
            SEND_GEN_QUERY(pite);


            // decrement the number of startupQueryCount left to be sent
            pInfo->StartupQueryCountCurrent--;
        }


        //
        // do static joins (no static joins for ras server interface)
        //
        if (!IS_RAS_SERVER_IF(pite->IfType))
        {
            PGROUP_TABLE_ENTRY  pge;
            PGI_ENTRY           pgie;
            DWORD               GroupAddr;
            SOCKADDR_IN         saLocalIf;

            //
            // socket for static groups already created in _CreateIfSockets
            // irrespective of whether there are any static groups
            //
           
            
            pHead = &pite->Config.ListOfStaticGroups;
            for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {

                pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);


                // IGMP_HOST_JOIN
                
                if (pStaticGroup->Mode==IGMP_HOST_JOIN) {

                    DWORD i;

                    if (pStaticGroup->NumSources==0
                        || pStaticGroup->FilterType==EXCLUSION)
                    {
                        JoinMulticastGroup(pite->StaticGroupSocket,
                                        pStaticGroup->GroupAddr,
                                        pite->IfIndex,
                                        pite->IpAddr,
                                        0
                                       );
                    }
                    
                    for (i=0;  i<pStaticGroup->NumSources;  i++) {
                        if (pStaticGroup->FilterType==INCLUSION) {
                            JoinMulticastGroup(pite->StaticGroupSocket,
                                    pStaticGroup->GroupAddr,
                                    pite->IfIndex,
                                    pite->IpAddr,
                                    pStaticGroup->Sources[i]
                                   );
                        }
                        else {
                            BlockSource(pite->StaticGroupSocket,
                                    pStaticGroup->GroupAddr,
                                    pite->IfIndex,
                                    pite->IpAddr,
                                    pStaticGroup->Sources[i]
                                   );
                        }
                    }
                }

                // IGMPRTR_MGM_ONLY
                
                else {
                    BOOL bCreate = TRUE;
                    DWORD i;
                    
                    GroupAddr = pStaticGroup->GroupAddr;
                    
                    ACQUIRE_GROUP_LOCK(GroupAddr, "_ActivateInterface");

                    pge = GetGroupFromGroupTable(GroupAddr, &bCreate, 0);
                    pgie = GetGIFromGIList(pge, pite, 0,
                                pStaticGroup->NumSources==0?STATIC_GROUP:NOT_STATIC_GROUP,
                                &bCreate, 0);
                    for (i=0;  i<pStaticGroup->NumSources;  i++) {
                        GetSourceEntry(pgie, pStaticGroup->Sources[i],
                            pStaticGroup->FilterType,
                            &bCreate, STATIC, MGM_YES);
                    }
                    RELEASE_GROUP_LOCK(GroupAddr, "_ActivateInterface");

                }
            }
        }

        

    } END_BREAKOUT_BLOCK1;


    if (Error!=NO_ERROR) {

        DeActivationDeregisterFromMgm(pite);
        
        DeActivateInterfaceComplete(pite);

        pite->Status &= ~IF_ACTIVATED_FLAG;

        if (bProxy) {
            Logerr1(ACTIVATION_FAILURE_PROXY, "%d",IfIndex, Error);
        }
        else {
            Logerr2(ACTIVATION_FAILURE_RTR, "%d%d",
                GET_IF_VERSION(pite), IfIndex, Error);
        }
    }

    else {
        if (bProxy) {
            Loginfo1(INTERFACE_PROXY_ACTIVATED, "%d",
                IfIndex, NO_ERROR);
        }
        else {
            Loginfo2(INTERFACE_RTR_ACTIVATED, "%d%d",
                GET_IF_VERSION(pite), IfIndex, NO_ERROR);
        }
        Trace1(START, "IGMP activated on interface:%0x", IfIndex);
    }

            
    Trace1(LEAVE, "leaving ActivateInterface():%d\n", Error);

    return Error;
    
} //end _ActivateInterface


//------------------------------------------------------------------------------
//          _DeActivateDeregisterFromMgm
//------------------------------------------------------------------------------

DWORD
DeActivationDeregisterFromMgm(
    PIF_TABLE_ENTRY pite
    )
{
    HANDLE hMgmHandle = IS_PROTOCOL_TYPE_PROXY(pite)
                        ? g_MgmProxyHandle: g_MgmIgmprtrHandle;
    DWORD               Error=NO_ERROR, IfIndex=pite->IfIndex;
    PLIST_ENTRY         pHead, ple;
    PRAS_TABLE_ENTRY    prte;

    
    //
    // Call MGM to release the interface ownership
    //
    if (pite->CreationFlags&TAKEN_INTERFACE_OWNERSHIP_WITH_MGM) {
        
        Error = MgmReleaseInterfaceOwnership(hMgmHandle, IfIndex,0);
        if (Error!=NO_ERROR) {
            Trace2(ERR, "MgmReleaseInterfaceOwnership returned error(%d) for If(%0x)",
                Error, IfIndex);
            IgmpAssertOnError(FALSE);
        }
        else
            pite->CreationFlags &= ~TAKEN_INTERFACE_OWNERSHIP_WITH_MGM;
    }
    

    //
    // if releasing proxy interface, then deregister proxy from mgm
    //

    if (IS_PROTOCOL_TYPE_PROXY(pite) 
        && (pite->CreationFlags&REGISTERED_PROTOCOL_WITH_MGM)) 
    {
        Error = MgmDeRegisterMProtocol(g_MgmProxyHandle);

        if (Error!=NO_ERROR) {
            Trace1(ERR, "MgmDeRegisterMProtocol(proxy) returned error(%d)", 
                Error);
            IgmpAssertOnError(FALSE);
                
        }
        else
            pite->CreationFlags &= ~REGISTERED_PROTOCOL_WITH_MGM;
    }

    //
    // delete all proxy alert entries        
    //
    if (IS_PROTOCOL_TYPE_PROXY(pite)) {

        ACQUIRE_PROXY_ALERT_LOCK("_DeActivationDeregisterMgm");
        
        {
            PLIST_ENTRY ple, pHead;
            
            for (ple=g_ProxyAlertsList.Flink;  ple!=&g_ProxyAlertsList;  ) {
                PPROXY_ALERT_ENTRY pProxyAlertEntry
                    = CONTAINING_RECORD(ple, PROXY_ALERT_ENTRY, Link);
                ple = ple->Flink;
                IGMP_FREE(pProxyAlertEntry);
            }
        }

        InitializeListHead(&g_ProxyAlertsList);
        RELEASE_PROXY_ALERT_LOCK("_DeActivationDeregisterMgm");
    }

    // 
    // if ras interface, then call mgm to release ownership of all ras clients
    //
    if (IS_RAS_SERVER_IF(pite->IfType)) {
        PRAS_TABLE_ENTRY    prte;
        
        pHead = &pite->pRasTable->ListByAddr;
        
        for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {

            prte = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);

            Error = MgmReleaseInterfaceOwnership(g_MgmIgmprtrHandle, IfIndex,
                                        prte->NHAddr);

            if (Error!=NO_ERROR) {
                Trace3(ERR, 
                    "error:%d _MgmReleaseInterfaceOwnership() for If:%0x, "
                    "NHAddr:%d.%d.%d.%d",
                    Error, IfIndex, PRINT_IPADDR(prte->NHAddr));
                IgmpAssertOnError(FALSE);
            }
        }
    }
    


    return Error;
}

//------------------------------------------------------------------------------
//              DeActivateInterfaceInitial
//
// deregister from MGM. Then create a new interface entry structure which 
// replaces the old one in all the lists. Now the old interface entry and 
// all its associated structures can be lazily deleted.
// Also update the global Proxy and Ras table pointers.
//
// Called by _UnBindIfEntry(), _DisableIfEntry()
//------------------------------------------------------------------------------

PIF_TABLE_ENTRY
DeActivateInterfaceInitial (
    PIF_TABLE_ENTRY piteOld
    )
{
    DWORD           IfIndex = piteOld->IfIndex;
    PIF_TABLE_ENTRY piteNew;
    DWORD           dwRetval, Error=NO_ERROR;
    PLIST_ENTRY     pHead, ple, pleNext;
    
    
    Trace0(ENTER1, "Entering _DeActivateInterfaceInitial()");

    
    //
    // deregister from Mgm
    //
    DeActivationDeregisterFromMgm(piteOld);
    

    //
    // allocate memory for the new interface
    //
    piteNew = IGMP_ALLOC(sizeof(IF_TABLE_ENTRY), 0x8, IfIndex);

    PROCESS_ALLOC_FAILURE3(piteNew, 
            "error %d allocating %d bytes for interface %d",
            Error, sizeof(IF_TABLE_ENTRY), IfIndex, 
            return NULL);



    // copy the old pite fields to the new pite
    CopyMemory(piteNew, piteOld, sizeof(IF_TABLE_ENTRY));


    // copy the old static groups to the new pite
    InitializeListHead(&piteNew->Config.ListOfStaticGroups);
    pHead = &piteOld->Config.ListOfStaticGroups;
    for (ple=pHead->Flink;  ple!=pHead;  ple=pleNext) {

        pleNext = ple->Flink;
        RemoveEntryList(ple);
        InsertTailList(&piteNew->Config.ListOfStaticGroups,
                        ple);
    }

    
    // set the status 
    MGM_DISABLE_IGMPRTR(piteNew);


    
    // LinkByAddr (not inserted in this list as the IF is deactivated)
    InitializeListHead(&piteNew->LinkByAddr);


    //
    // insert the new entry before the old entry, and remove the old 
    // entry from the list of IFs ordered by index and from hash table
    //
    
    InsertTailList(&piteOld->LinkByIndex, &piteNew->LinkByIndex);
    RemoveEntryList(&piteOld->LinkByIndex);

    InsertTailList(&piteOld->HTLinkByIndex, &piteNew->HTLinkByIndex);
    RemoveEntryList(&piteOld->HTLinkByIndex);



    // initialize GI list to empty
    InitializeListHead(&piteNew->ListOfSameIfGroups);
    InitializeListHead(&piteNew->ListOfSameIfGroupsNew);
    piteNew->NumGIEntriesInNewList = 0;


    
    //  set binding of piteOld to NULL so that it doesnt get deleted
    piteOld->pBinding = NULL;


    // reset the Info fields
    ZeroMemory(&piteNew->Info, sizeof(IF_INFO));
    

    //
    // create a new RAS table if it is a RAS server interface, and set ras
    // pointer in global table. I could have reused the ras table, but dont
    // so that resetting the fields is cleaner.
    //
    if ( IS_RAS_SERVER_IF(piteNew->IfType)) {

        PRAS_TABLE_ENTRY prte;

        InitializeRasTable(IfIndex, piteNew);

        //
        // recreate all ras client entries
        //
        pHead = &piteOld->pRasTable->ListByAddr;
        
        for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {

            prte = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);

            CreateRasClient(piteNew, &prte, prte->NHAddr);
        }
        
        InterlockedExchangePointer(&g_pRasIfEntry, piteNew);
    }


    //
    // if proxy, then update the entry in the global table
    // I reuse the proxy hash table. set it to null in piteOld so that it is not
    // delete there.
    //
    if (g_pProxyIfEntry == piteOld) {
        InterlockedExchangePointer(&g_pProxyIfEntry, piteNew);

        
        // clean the hash table entries
        {
            DWORD               i;
            PPROXY_GROUP_ENTRY  ppge;
            PLIST_ENTRY         pHead, ple, 
                                pProxyHashTable = piteOld->pProxyHashTable;
            
            if (piteOld->CreationFlags&CREATED_PROXY_HASH_TABLE) {

                for (i=0;  i<PROXY_HASH_TABLE_SZ;  i++) {
                    pHead = &pProxyHashTable[i];

                    for (ple=pHead->Flink;  ple!=pHead;  ) {

                        ppge = CONTAINING_RECORD(ple, PROXY_GROUP_ENTRY, HT_Link);
                        ple=ple->Flink;

                        // delete all sources
                        {
                            PLIST_ENTRY pHeadSrc, pleSrc;
                            PPROXY_SOURCE_ENTRY pSourceEntry;
                            
                            pHeadSrc = &ppge->ListSources;
                            for (pleSrc=pHeadSrc->Flink;  pleSrc!=pHeadSrc; ) {

                                pSourceEntry = CONTAINING_RECORD(pleSrc, 
                                                    PROXY_SOURCE_ENTRY, LinkSources);
                                pleSrc = pleSrc->Flink;

                                IGMP_FREE(pSourceEntry);
                            }
                        }
                        
                        IGMP_FREE(ppge);
                    }

                    InitializeListHead(pHead);
                }
            }
        }

        piteOld->pProxyHashTable = NULL;
    }


    //
    // socket is created when the interface is activated
    //
    
    piteNew->SocketEntry.Socket = INVALID_SOCKET;
    //piteNew->SocketEntry.pSocketEventsEntry = NULL;
    //InitializeListHead(&piteNew->SocketEntry.LinkByInterfaces);


    // initialize the new timers
    piteNew->QueryTimer.Status = 0;
    piteNew->NonQueryTimer.Status = 0;


    piteNew->pPrevIfGroupEnumPtr = NULL;
    piteNew->PrevIfGroupEnumSignature = 0;
    piteNew->StaticGroupSocket = INVALID_SOCKET;


    // creationFlags already copied.
    piteNew->CreationFlags &= ~CREATION_FLAGS_DEACTIVATION_CLEAR;
    


    Trace0(LEAVE1, "Leaving _DeActivateInterfaceInitial()");
    return piteNew;

}//end _DeActivateInterfaceInitial



//------------------------------------------------------------------------------
//          _DeActivateInterfaceComplete
//
// If ras server, then for each ras client queues a work item to delete it.
// the last ras client will delete the pite entry.
// Deletes the GI entries, and calls _CompleteIfDeletion() if deleted flag 
// or DeactivateDelete flag set on the IF entry.
// This routine assumes that the interface has been removed from any global
// lists that it needs to be removed from, and that the appropriate flags have
// been set. The only way they can still be used is by timers getting fired or
// by input on socket.
//
// Called by:
//    _ActivateInterface:(if it fails), only in this case pite is not deleted.
//    _DeleteIfEntry --> 
//          _DeActivationDeregisterFromMgm & _WF_CompleteIfDeactivateDelete
//    _UnbindIfEntry & _DisableIfEntry -->
//          _DeActivateInterfaceInitial & _WF_CompleteIfDeactivateDelete
// Lock:
//    If called when interface is being deleted, then no interface locks required.
//    else assumes exclusive interface lock.
//    requires exclusive sockets list lock in either case.
//------------------------------------------------------------------------------
VOID
DeActivateInterfaceComplete (
    PIF_TABLE_ENTRY     pite
    )
{
    DWORD           IfIndex = pite->IfIndex;
    DWORD           Error = NO_ERROR, dwRetval;
    PLIST_ENTRY     pHead, ple;
    PGI_ENTRY       pgie;
    BOOL            bProxy = IS_PROTOCOL_TYPE_PROXY(pite);;
    
    
    Trace1(ENTER1, "Entering _DeActivateInterfaceComplete(%d)", IfIndex);


    //
    // do all deactivation here which is common for all interfaces
    // whether ras server or not.
    //



    // 
    // unbind sockets from Input event and then close the sockets
    //
    if (pite->SocketEntry.Socket!=INVALID_SOCKET) {

        //
        // proxy does not bind its socket to input event as it
        // does not want to receive any packets
        //
        if (!bProxy)
            WSAEventSelect(pite->SocketEntry.Socket,
                        pite->SocketEntry.pSocketEventsEntry->InputEvent, 0);

    }

    if (pite->CreationFlags&SOCKETS_CREATED)
        DeleteIfSockets(pite);



    /////////////////////////////////////////////////////////
    // IS_RAS_SERVER_IF
    /////////////////////////////////////////////////////////

    //
    // go through the list of Ras clients. Mark them as deleted, remove them
    // from all global lists, and set work item to delete them.
    //
    if (IS_RAS_SERVER_IF(pite->IfType)) {
    
        PRAS_TABLE          prt = pite->pRasTable;
        PRAS_TABLE_ENTRY    prte;


        // go through the list of all Ras clients and set them to be deleted

        pHead = &prt->ListByAddr;
        for (ple=pHead->Flink;  ple!=pHead;  ) {
        
            prte = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);

            ple=ple->Flink;

            
            //
            // if ras client has deleted flag already set, then ignore it.
            //
            if (!(prte->Status&IF_DELETED_FLAG)) {

                //
                // set deleted flag for the ras client, so that no one else will
                // try to access it
                prte->Status |= IF_DELETED_FLAG;


                //
                // remove the RAS client from the Ras table lists so that no one 
                // will access it.
                //
                RemoveEntryList(&prte->HTLinkByAddr);
                RemoveEntryList(&prte->LinkByAddr);


                //
                // clean up the ras client
                //
                DeleteRasClient(prte);
            }

        }

        //
        // delete the timers from pite entry
        //

        ACQUIRE_TIMER_LOCK("_DeActivateInterfaceComplete");

        if (IS_TIMER_ACTIVE(pite->QueryTimer))
            RemoveTimer(&pite->QueryTimer, DBG_Y);

        if (IS_TIMER_ACTIVE(pite->NonQueryTimer))
            RemoveTimer(&pite->NonQueryTimer, DBG_Y);

        RELEASE_TIMER_LOCK("_DeActivateInterfaceComplete");



        pite->CreationFlags = 0; 
        prt->RefCount--;


        //
        // deleting the pite entry(if deleted flag is set), and ras table will 
        // be done by the work item which deletes the last Ras client 
        // (when refcount==0) however if there are no ras clients, then I will 
        // have to do the cleanup here
        //

        if ( ((pite->Status&IF_DELETED_FLAG)
            ||(pite->Status&IF_DEACTIVATE_DELETE_FLAG))
            &&(prt->RefCount==0) )
        {
            CompleteIfDeletion(pite);
        }
    }
    

    
    //------------------------------------------------------------
    // NOT IS_RAS_SERVER_IF: PROXY IF
    //------------------------------------------------------------

    // PROXY INTERFACE. Just clean the hash table, and delete interface if req
    
    else if ( (!IS_RAS_SERVER_IF(pite->IfType)) && bProxy) {
        

        // the proxy hashTable will be deleted if
        // necessary in _CompleteIfDeletion().

    
        //
        // delete the interface if either IF_DELETED_FLAG or 
        // IF_DEACTIVATE_DELETE_FLAG set. (interface not deleted when cleaning
        // up because activate interface failed
        //
        if ( (pite->Status&IF_DELETED_FLAG)
            ||(pite->Status&IF_DEACTIVATE_DELETE_FLAG) ) 
        {
            CompleteIfDeletion(pite);
        }
    }

    //----------------------
    // NOT PROXY interface
    //----------------------
    
    else if ( !IS_RAS_SERVER_IF(pite->IfType) ) {
    
        //
        // take exclusive lock on the If_Group List and remove all timers.
        // From now on no one can enter from outside and no one is inside
        // as all timers have been removed. 

        // have to take the if_group_list lock to make sure that no
        // one is changing it.
        ACQUIRE_IF_GROUP_LIST_LOCK(pite->IfIndex, "_DeActivateInterfaceComplete");

        //
        // Remove all timers
        //
        
        ACQUIRE_TIMER_LOCK("_DeActivateInterfaceComplete");


        // delete all timers contained in GI entries and the sources
        
        pHead = &pite->ListOfSameIfGroups;
        DeleteAllTimers(pHead, NOT_RAS_CLIENT);
        pHead = &pite->ListOfSameIfGroupsNew;
        DeleteAllTimers(pHead, NOT_RAS_CLIENT);
        pite->NumGIEntriesInNewList = 0;
        


        // delete query timer
       
        if (IS_TIMER_ACTIVE(pite->QueryTimer))
            RemoveTimer(&pite->QueryTimer, DBG_Y);

        if (IS_TIMER_ACTIVE(pite->NonQueryTimer))
            RemoveTimer(&pite->NonQueryTimer, DBG_Y);


        RELEASE_TIMER_LOCK("_DeActivateInterfaceComplete");


        RELEASE_IF_GROUP_LIST_LOCK(pite->IfIndex, "_DeActivateInterfaceComplete");
        
        
        //
        // revisit the list and delete all GI entries. Need to take 
        // exclusive lock on the group bucket before deleting the GI entry
        // No need to lock the If-Group list as deleted flag already set and 
        // no one can visit the list from outside or inside(all timers removed).
        //
        DeleteAllGIEntries(pite);


        //
        // if deleted flag set, then also delete the interface
        //

        if ( (pite->Status&IF_DELETED_FLAG)
            ||(pite->Status&IF_DEACTIVATE_DELETE_FLAG) )
        {
            CompleteIfDeletion(pite);
        }
        
    } //deactivated if: Not(ras server if)
        

    // do not use pite, or prt from here as they are deleted.

    if (bProxy)
        Loginfo1(PROXY_DEACTIVATED, "%d",IfIndex, NO_ERROR);
    else
        Loginfo1(RTR_DEACTIVATED, "%d",IfIndex, NO_ERROR);
    
    Trace1(LEAVE, "leaving _DeActivateInterfaceComplete(%d)", IfIndex);
    
} //end _DeActivateInterfaceComplete




//------------------------------------------------------------------------------
//                EnableInterface
//
// sets the status to enabled. If interface is also bound and enabled in
// config, then activate the interface.
//
// Locks: SocketsLock, IfListLock, Exclusive IfLock
//------------------------------------------------------------------------------

DWORD
EnableInterface(
    IN DWORD IfIndex
    )
{
    DWORD Error = NO_ERROR;


    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace1(ENTER1, "entering _EnableInterface(%d):", IfIndex);
    Trace1(IF, "enabling interface %d", IfIndex);
    
    
    //
    // enable the interface
    //
    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_EnableInterface");
    ACQUIRE_IF_LIST_LOCK("_EnableInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_EnableInterface");


    Error = EnableIfEntry(IfIndex, TRUE);


    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_EnableInterface");
    RELEASE_IF_LIST_LOCK("_EnableInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_EnableInterface");



    Trace2(LEAVE1, "leaving _EnableInterface(%d): %d\n", IfIndex, Error);
    if (Error!=NO_ERROR) {
        Trace1(ERR, "Error enabling interface:%0x\n", IfIndex);
        IgmpAssertOnError(FALSE);
    }
    
    LeaveIgmpApi();

    return Error;
}



//------------------------------------------------------------------------------
//                _EnableInterface_ConfigChanged
//
// Set the status to enabled. If it is also bound, activate the interface.
//
// Locks:  Runs entirely in Exclusive interface lock.
// Calls:  EnableIfEntry() with mode config
//------------------------------------------------------------------------------

DWORD
EnableInterface_ConfigChanged(
    DWORD IfIndex
    )
{
    DWORD             Error=NO_ERROR;


    Trace1(ENTER, "entering _EnableInterface_ConfigChanged(%d):", IfIndex);

    Trace1(IF, 
        "Enabling Interface(%d) due to change made by _SetInterfaceConfigInfo", 
        IfIndex);

        
    //
    // enable the interface
    //

    Error = EnableIfEntry(IfIndex, FALSE); // FALSE->change made by config


    Trace2(LEAVE, "leaving _EnableInterface_ConfigChanged(%d): %d\n", 
            IfIndex, Error);

    return Error;
    
} //end _DeActivateInterfaceInitial




//------------------------------------------------------------------------------
//            BindInterface                                                        //
//------------------------------------------------------------------------------
DWORD
BindInterface(
    IN DWORD IfIndex,
    IN PVOID pBinding
    )
/*++
Routine Description:
    Sets the binding for the interface and activates it if it is also enabled.
Return Value
      ERROR_INVALID_PARAMETER
      NO_ERROR
Lock:
    runs entirely in Interface Exclusive lock
Calls:
    BindIfEntry()
--*/
{
    DWORD         Error=NO_ERROR;
    

    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace1(ENTER1, "entering BindInterface: %0x", IfIndex);
    Trace1(IF, "binding interface %0x", IfIndex);


    // pBinding should not be NULL
    
    if (pBinding == NULL) {

        Trace0(IF, "error: binding struct pointer is NULL");
        Trace1(LEAVE, "leaving BindInterface: %0x", ERROR_INVALID_PARAMETER);

        LeaveIgmpApi();
        return ERROR_INVALID_PARAMETER;
    }



    //
    // now bind the interface in the interface table
    //

    //
    // take sockets lock, as activate interface might be called, and
    // sockets lock should be taken before interface lock
    //
    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_BindInterface");
    ACQUIRE_IF_LIST_LOCK("_BindInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_BindInterface");


    Error = BindIfEntry(IfIndex, pBinding);


    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_BindInterface");
    RELEASE_IF_LIST_LOCK("_BindInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_BindInterface");



    Trace2(LEAVE1, "leaving _BindInterface(%x): %d\n", IfIndex, Error);
    if (Error!=NO_ERROR){
        Trace1(ERR, "Error binding interface(%0x)\n", IfIndex);
        IgmpAssertOnError(FALSE);
    }
    LeaveIgmpApi();

    return Error;
}

//------------------------------------------------------------------------------
//          _BindIfEntry
//
// Binds the ip addresses to the interface. The lowest of the ip addresses is
// picked up as the de-facto address for that interface. If the interface is 
// already bound, it makes sure that the bindings are consistent. Currently 
// you cannot change the bindings of an interface.
// If the interface is already enabled, then it is also activated.
//
// Locks: 
//    assumes exclusive interface lock.
// Called by:  _BindInterface().
//------------------------------------------------------------------------------

DWORD
BindIfEntry(
    DWORD IfIndex,
    PIP_ADAPTER_BINDING_INFO pBinding
    ) 
{
    PIF_TABLE_ENTRY         pite = NULL;
    DWORD                   i, j, dwSize;
    IPADDR                  MinAddr;
    PIGMP_IF_BINDING        pib;
    PIGMP_IP_ADDRESS        paddr;
    BOOL                    bFound;
    DWORD                   Error = NO_ERROR;
    INT                     cmp;

    
    pib = NULL;


    //
    // retrieve the interface entry
    //

    pite = GetIfByIndex(IfIndex);

    if (pite == NULL) {
        return ERROR_INVALID_PARAMETER;
    }
    
    
    //
    // If the interface is already bound, check to see if he is giving
    // us a different binding. If he is, then it is an error. 
    //
    if (IS_IF_BOUND(pite)) {

        Trace1(IF, "interface %d is already bound", IfIndex);

        pib = pite->pBinding;

        Error = NO_ERROR;


        // number of address bindings before and now should be same
        
        if(pib->AddrCount != pBinding->AddressCount){
            Trace1(IF, "interface %d is bound and has different binding",
                    IfIndex);
            return ERROR_INVALID_PARAMETER;
        }

        
        //
        // make sure that all address bindings are consistent
        //
        paddr = (PIGMP_IP_ADDRESS)((pib) + 1);

        for(i = 0; i < pBinding->AddressCount; i++) {
            bFound = FALSE;

            for(j = 0; j < pBinding->AddressCount; j++) {
                if((paddr[j].IpAddr == pBinding->Address[i].Address) &&
                   (paddr[j].SubnetMask == pBinding->Address[i].Mask))
                {
                    bFound = TRUE;
                    break;
                }
            }

            if(!bFound) {
                Trace1(IF,
                    "interface %d is bound and has different binding",
                    IfIndex);
                return ERROR_INVALID_PARAMETER;
            }
        }

        return NO_ERROR;
    }

    //
    // make sure there is at least one address. However, unnumbered 
    // RAS server interfaces might have no IP addresses.
    //
    if ( (pBinding->AddressCount==0)&&(!IS_RAS_ROUTER_IF(pite->IfType)) ) {

        return ERROR_CAN_NOT_COMPLETE;
    }

    BEGIN_BREAKOUT_BLOCK1 {
        
        if (pBinding->AddressCount!=0) {
            //
            // allocate memory to store the binding
            //
            dwSize = sizeof(IGMP_IF_BINDING) +
                        pBinding->AddressCount * sizeof(IGMP_IP_ADDRESS);


            pib = IGMP_ALLOC(dwSize, 0x10, IfIndex);

            PROCESS_ALLOC_FAILURE3(pib,
                    "error %d allocating %d bytes for binding on interface %d",
                    Error, dwSize, IfIndex, GOTO_END_BLOCK1);


            //
            // copy the bindings
            //

            pib->AddrCount = pBinding->AddressCount;
            paddr = IGMP_BINDING_FIRST_ADDR(pib);
            MinAddr = ~0;
            
            for (i=0;  i<pib->AddrCount;  i++,paddr++) {
                
                paddr->IpAddr = pBinding->Address[i].Address;
                paddr->SubnetMask = pBinding->Address[i].Mask;

                if (INET_CMP(MinAddr, paddr->IpAddr, cmp)>0)
                    MinAddr = paddr->IpAddr;
            }


            //
            // set the Interface effective address to the smallest bound address
            //
            pite->IpAddr = MinAddr;
            pite->Config.IpAddr = MinAddr;

            
            //
            // save the binding in the interface entry
            //
            pite->pBinding = pib;
        }
        
        // dont have to do the below as they are already set to those values
        else {
            pite->IpAddr = pite->Config.IpAddr = 0;
            pite->pBinding = NULL;
        }

        //
        // mark the interface as being bound
        //
        pite->Status |= IF_BOUND_FLAG;



        //
        // if interface is also enabled, it is now active
        // so activate it
        //

        if (IS_IF_ENABLED_BOUND(pite)) {

            //
            // place interface on the list of active interfaces
            //
            Error = InsertIfByAddr(pite);


            //
            // error if another numbered interface with same IpAddr already exists
            //
            if (Error != NO_ERROR) {
                Trace2(IF, "error %d inserting interface %d in active list",
                        Error, IfIndex);
                IGMP_FREE(pib);
                GOTO_END_BLOCK1;
            }


            //
            // Activate the Interface
            //
            Error = ActivateInterface(pite);

            //
            // if could not activate the interface then undo the binding
            //
            if (Error != NO_ERROR) {

                Trace1(ERR, 
                    "Unbinding interface(%d) because it could not be activated",
                    IfIndex);
                IgmpAssertOnError(FALSE);
                RemoveEntryList(&pite->LinkByAddr);
                IGMP_FREE(pib);

                Error = ERROR_CAN_NOT_COMPLETE;
                GOTO_END_BLOCK1;
            }
         }
        
    } END_BREAKOUT_BLOCK1;


    //
    // if there was any error, then set the status to unbound (pite is null 
    // if interface was not found)
    //
    if ((Error!=NO_ERROR)&&(pite!=NULL)) {

        pite->Status &= ~IF_BOUND_FLAG;

        if (pite->pBinding)     
            IGMP_FREE_NOT_NULL(pite->pBinding); 
        pite->pBinding = NULL;

        pite->IpAddr = pite->Config.IpAddr = 0;
    }
    
    return Error;
    
} //end BindIfEntry
    




//------------------------------------------------------------------------------
//            UnBindInterface                                                        //
//------------------------------------------------------------------------------
DWORD
UnBindInterface(
    IN DWORD IfIndex
    )
/*++
Routine Description:
    Calls UnBindIfEntry to unbind the interface.
Calls:
    UnBindIfEntry();
Locks:
    Runs completely in exclusive interface lock
--*/
{

    DWORD Error=NO_ERROR;

    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }

    Trace1(ENTER, "entering UnBindInterface(%d):", IfIndex);


    //
    // unbind the interface
    //

    //
    // take sockets lock, as activate interface might be called, and
    // sockets lock should be taken before interface lock
    //
    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_UnBindInterface");
    ACQUIRE_IF_LIST_LOCK("_UnBindInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_UnBindInterface");


    Error = UnBindIfEntry(IfIndex);


    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_UnBindInterface");
    RELEASE_IF_LIST_LOCK("_UnBindInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_UnBindInterface");


    Trace2(LEAVE, "leaving UnBindInterface(%d): %d\n", IfIndex, Error);

    LeaveIgmpApi();

    return Error;

}


//------------------------------------------------------------------------------
//          _UnBindIfEntry
//
// If the interface is activated, deactivates it. Removes the binding. 
//
// MayCall: _DeActivateInterfaceComplete().
// Locks: assumes exclusive interface lock.
//------------------------------------------------------------------------------

DWORD
UnBindIfEntry(
    DWORD         IfIndex
    )
{
    DWORD                   Error = NO_ERROR, dwRetval;
    PIF_TABLE_ENTRY         pite, piteNew;
    DWORD                   bProxy;


    BEGIN_BREAKOUT_BLOCK1 {

        //
        // retrieve the interface specified
        //
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Trace1(ERR, "_UnbindInterface called for non existing interface(%d)",
                    IfIndex);
            IgmpAssertOnError(FALSE);
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        //
        // quit if the interface is already unbound
        //
        if (!IS_IF_BOUND(pite)) {

            Error = ERROR_INVALID_PARAMETER;
            Trace1(ERR, "interface %d is already unbound", IfIndex);
            IgmpAssertOnError(FALSE);
            GOTO_END_BLOCK1;
        }

        
        //
        // clear the "bound" flag
        //
        pite->Status &= ~IF_BOUND_FLAG;


        //
        //  unbind IF
        //
            
        IGMP_FREE(pite->pBinding);
        pite->pBinding = NULL;

        
        //
        // if IF activated (ie also enabled), deactivate it
        // note: check for activated flag, and not for enabled flag
        //
        if (IS_IF_ACTIVATED(pite)) {

            // unset activated flag
            
            pite->Status &= ~IF_ACTIVATED_FLAG;


            // remove the interface from the list of activated interfaces
            
            RemoveEntryList(&pite->LinkByAddr);


            piteNew = DeActivateInterfaceInitial(pite);


            //
            // queue work item to deactivate and delete the interface.
            //
            // CompleteIfDeactivateDelete will delete the Ras clients, GI entries,
            // and deinitialize pite structure
            //

            //
            // set flag to indicate that the interface is being deleted following
            // partial deactivation
            //
            pite->Status |= IF_DEACTIVATE_DELETE_FLAG;


            CompleteIfDeactivateDelete(pite);

            
            #ifdef WORKER_DBG
                Trace2(WORKER, "Queuing IgmpWorker function: %s in %s",
                    "_WF_CompleteIfDeactivateDelete:", "_UnBindIfEntry");
            #endif
            
        }
        
        else {
            pite->IpAddr = pite->Config.IpAddr = 0;
        }

    } END_BREAKOUT_BLOCK1;


    return Error;
    
} //end _UnBindIfEntry







//------------------------------------------------------------------------------
// Function:    _EnableIfEntry
//------------------------------------------------------------------------------
DWORD
EnableIfEntry(
    DWORD   IfIndex,
    BOOL    bChangedByRtrmgr // changed by rtrmg or SetInterfaceConfigInfo
    )
/*++
Routine Description:
    Sets the status to enabled. If the interface is also bound, then activates 
    the interface.
Called by:
    EnableInterface().
MayCall:
    ActivateIfEntry()
Locks:
    Assumes exclusive interface lock.
--*/
{
    DWORD               Error = NO_ERROR;
    PLIST_ENTRY         ple, phead;
    PIF_TABLE_ENTRY     pite = NULL;    

    
    BEGIN_BREAKOUT_BLOCK1 {

        //
        // retrieve the interface
        //
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Trace1(IF, "could not find interface %d",IfIndex);
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        if (bChangedByRtrmgr) {
            //
            // quit if the interface is already enabled by the router manager
            //
            if (IS_IF_ENABLED_BY_RTRMGR(pite)) {
                Trace1(IF, "interface %d is already enabled by the router manager", 
                        IfIndex);
                Error = NO_ERROR;
                GOTO_END_BLOCK1;
            }


            // set the flag to enabled by router manager
            
            pite->Status |= IF_ENABLED_FLAG;

            // print trace if enabled flag not set in the Config.
            if (!IS_IF_ENABLED_IN_CONFIG(pite)) {
                Trace1(IF, 
                    "Interface(%d) enabled by router manager but not enabled"
                    "in the Config", pite->IfIndex);
            }
        }

        else {
            //
            // quit if the interface is already enabled in config
            //
            if (IS_IF_ENABLED_IN_CONFIG(pite)) {
                Trace1(IF, "interface %d is already enabled in Config", 
                        IfIndex);
                Error = NO_ERROR;
                GOTO_END_BLOCK1;
            }

            // set the config flag to enabled
            
            pite->Config.Flags |= IGMP_INTERFACE_ENABLED_IN_CONFIG;


            // print trace if interface not enabled by router manager

            if (!IS_IF_ENABLED_BY_RTRMGR(pite)) {
                Trace1(IF, 
                    "Interface(%d) enabled in config but not enabled by router manager",
                    IfIndex);
                Error = NO_ERROR;
                GOTO_END_BLOCK1;
            }
        }
        
    
        //
        // if interface is already bound, it should be activated
        // if the bInterfaceEnabled flag is also set in config (by the UI)
        //

        if (IS_IF_ENABLED_BOUND(pite)) {


            //
            // place interface on the list of active interfaces
            //
            Error = InsertIfByAddr(pite);


            //
            // error if another interface with same ip address already exists
            //
            if (Error != NO_ERROR) {
                 Trace2(IF, "error %d inserting interface %d in active list",
                         Error, IfIndex);
                 GOTO_END_BLOCK1;
            }

            //
            // Activate the Interface
            //
            Error = ActivateInterface(pite);

            //
            // if could not activate the interface then disable it again
            //
            if (Error != NO_ERROR) {

                Trace1(ERR,
                    "Disabling interface(%d) because it could not be activated",
                    IfIndex);
                IgmpAssertOnError(FALSE);
                RemoveEntryList(&pite->LinkByAddr);

                Error = ERROR_CAN_NOT_COMPLETE;
                GOTO_END_BLOCK1;
            }

         }
         
    } END_BREAKOUT_BLOCK1;



    //
    // if an error occured somewhere, set the interface back to the previous 
    // disabled state.(pite may be null if interface was not found).
    //
    if ((Error!=NO_ERROR)&&(pite!=NULL)) {

        if (bChangedByRtrmgr)
            pite->Status &= ~IF_ENABLED_FLAG;
        else
            pite->Config.Flags &= ~IGMP_INTERFACE_ENABLED_IN_CONFIG;
    }

    
    return Error;
    
}//end EnableIfEntry



//------------------------------------------------------------------------------
//            _DisableInterface
//
// If interface is activated, then deactivates it. Finally sets the disabled flag
// Locks: Runs completely in exclusive interface lock.
// Calls: _DisableIfEntry()
//------------------------------------------------------------------------------

DWORD
DisableInterface(
    IN DWORD IfIndex
    )
{      
    DWORD Error=NO_ERROR;

    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace1(ENTER, "entering DisableInterface(%d):", IfIndex);


    //
    // disable the interface
    //
    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_DisableInterface");    
    ACQUIRE_IF_LIST_LOCK("_DisableInterface");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_DisableInterface");


    Error = DisableIfEntry(IfIndex, TRUE);


    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_DisableInterface");    
    RELEASE_IF_LIST_LOCK("_DisableInterface");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_DisableInterface");


    Trace2(LEAVE, "leaving DisableInterface(%d): %d\n", IfIndex, Error);
    LeaveIgmpApi();

    return Error;
}


//------------------------------------------------------------------------------
//            _DisableInterface_ConfigChanged
//
//If interface is activated, then deactivates it. Finally sets the disabled flag
//
// Locks:  assumes IfLists lock and exclusive If lock.
// Calls: _DisableIfEntry() with mode config
// Called by: _SetInterfaceConfigInfo()

//------------------------------------------------------------------------------
DWORD
DisableInterface_ConfigChanged(
    DWORD IfIndex
    )
{      
    DWORD Error=NO_ERROR;

    Trace1(ENTER1, "entering _DisableInterface_ConfigChanged(%d):", IfIndex);

    Trace1(IF, 
        "disabling interface(%d) due to change made by _SetInterfaceConfigInfo",
        IfIndex);


    Error = DisableIfEntry(IfIndex, FALSE); // false->disabling from config


    Trace2(LEAVE, "leaving _DisableInterface_ConfigChanged(%d): %d\n", 
            IfIndex, Error);

    return Error;
}



//------------------------------------------------------------------------------
//          _DisableIfEntry
//
// if interface is activated, then calls DeActivateInterfaceComplete(). Removes
// the enabled flag.
// Locks: Assumes exclusive interface lock.
// Called by: _DisableInterface()
//------------------------------------------------------------------------------

DWORD
DisableIfEntry(
    DWORD IfIndex,
    BOOL  bChangedByRtrmgr
    )
{
    DWORD                   Error = NO_ERROR;
    PIF_TABLE_ENTRY         pite, piteNew;
    BOOL                    bProxy;
    
    
    BEGIN_BREAKOUT_BLOCK1 {

        //
        // retrieve the interface to be disabled
        //
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Trace1(IF, "could not find interface %d", IfIndex);
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        if (bChangedByRtrmgr) {
            //
            // quit if already disabled by router manager
            //
            if (!IS_IF_ENABLED_BY_RTRMGR(pite)) {
                Trace1(IF, "interface %d already disabled by router manager", 
                        IfIndex);
                Error = ERROR_INVALID_PARAMETER;
                GOTO_END_BLOCK1;
            }
        }

        else {
            //
            // quit if already disabled in Config
            //
            if (!IS_IF_ENABLED_IN_CONFIG(pite)) {
                Trace1(IF, "interface %d already disabled in config", 
                        IfIndex);
                Error = ERROR_INVALID_PARAMETER;
                GOTO_END_BLOCK1;
            }
        }

        
        //
        // clear the enabled flag
        //
        if (bChangedByRtrmgr)
            pite->Status &= ~IF_ENABLED_FLAG;
        else
            pite->Config.Flags &= ~IGMP_INTERFACE_ENABLED_IN_CONFIG;

            

        //
        // if IF activated (ie also enabled), deactivate it
        // note: check for activated flag, and not for enabled flag
        //
        
        if (IS_IF_ACTIVATED(pite)) {

            // unset activated flag
            
            pite->Status &= ~IF_ACTIVATED_FLAG;


            // remove the interface from the list of activated interfaces
            
            RemoveEntryList(&pite->LinkByAddr);


            piteNew = DeActivateInterfaceInitial(pite);


            //
            // queue work item to deactivate and delete the interface.
            //
            // CompleteIfDeactivateDelete will delete the Ras clients, GI entries,
            // and deinitialize pite structure
            //

            //
            // set flag to indicate that the interface is being deleted following
            // partial deactivation
            //
            pite->Status |= IF_DEACTIVATE_DELETE_FLAG;


            CompleteIfDeactivateDelete(pite);

            #ifdef WORKER_DBG
                Trace2(WORKER, "Queuing IgmpWorker function: %s in %s",
                    "_WF_CompleteIfDeactivateDelete:", "_DisableIfEntry");
            #endif
        }
    
    } END_BREAKOUT_BLOCK1;

    
    return Error;

} //end _DisableIfEntry



//------------------------------------------------------------------------------
//          _CreateRasClient
//------------------------------------------------------------------------------

DWORD
CreateRasClient (
    PIF_TABLE_ENTRY     pite,      
    PRAS_TABLE_ENTRY   *pprteNew,
    DWORD               NHAddr
    )
{
    DWORD               Error=NO_ERROR;
    PLIST_ENTRY         pHead, ple;
    PRAS_TABLE          prt = pite->pRasTable;
    PRAS_TABLE_ENTRY    prteCur, prte;

    BEGIN_BREAKOUT_BLOCK1 {
        //
        // Create new Ras client entry and initialize the fields
        //

        prte = IGMP_ALLOC(sizeof(RAS_TABLE_ENTRY), 0x20, pite->IfIndex);
        PROCESS_ALLOC_FAILURE2(prte, 
                "error %d allocating %d bytes in CreateRasClient()",
                Error, sizeof(RAS_TABLE_ENTRY), 
                GOTO_END_BLOCK1);

        *pprteNew = prte;


        prte->NHAddr = NHAddr;
        prte->IfTableEntry = pite;
        InitializeListHead(&prte->ListOfSameClientGroups);


        // increment refcount for the ras table
        prt->RefCount++;


        //
        // insert into HashTable
        //
        InsertTailList(&prt->HashTableByAddr[RAS_HASH_VALUE(NHAddr)],
                        &prte->HTLinkByAddr);


        //
        // insert the client into list of clients ordered by IpAddr
        //
        pHead = &prt->ListByAddr;
        for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {
            prteCur = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);
            if (NHAddr>prteCur->NHAddr)
                break;
        }
        InsertTailList(&prt->ListByAddr, &prte->LinkByAddr);


        //
        // Set Interface stats to 0
        //
        ZeroMemory(&prte->Info, sizeof(RAS_CLIENT_INFO));


        prte->Status = IF_CREATED_FLAG;

    } END_BREAKOUT_BLOCK1;
    return Error;
}



//------------------------------------------------------------------------------
//                _ConnectRasClient
//
// Called when a new RAS client dials up to the RAS server.
// A new entry is created in the RAS table.
// Locks: shared interface lock
//      exclusive RAS table lock.
// Note:
//      Ras client entry is created even if the interface is not activated
//------------------------------------------------------------------------------

DWORD
APIENTRY
ConnectRasClient (
    ULONG   IfIndex,
    PVOID   pvNHAddr 
    )
{
    PIF_TABLE_ENTRY             pite = NULL;
    PRAS_TABLE                  prt;
    PRAS_TABLE_ENTRY            prte, prteCur;
    PLIST_ENTRY                 pHead, ple;
    DWORD                       Error = NO_ERROR;
    PIP_LOCAL_BINDING           pNHAddrBinding = (PIP_LOCAL_BINDING)pvNHAddr;
    DWORD                       NHAddr = pNHAddrBinding->Address;
    

    // mightdo
    // currently rtrmgr passes 0 for IfIndex. so I set it to the value required
    IfIndex = g_RasIfIndex;

    
    Trace2(ENTER, "Entering ConnectRasClient(%d.%d.%d.%d):IfIndex(%0x)\n", 
            PRINT_IPADDR(NHAddr), IfIndex);
    if (!EnterIgmpApi()) return ERROR_CAN_NOT_COMPLETE;

            
    //
    // take a shared lock on the interface
    //
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_ConnectRasClient");


    BEGIN_BREAKOUT_BLOCK1 {
        //
        // retrieve the RAS interface entry 
        //
        pite = g_pRasIfEntry;

        if ( (pite==NULL)||(g_RasIfIndex!=IfIndex) ) {
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        //
        // check that it is a RAS server Interface
        //
        if (!IS_RAS_SERVER_IF(pite->IfType)) {
            Error = ERROR_CAN_NOT_COMPLETE;
            Trace2(ERR, 
                "Illegal attempt to connect Ras client(%d.%d.%d.%d) to non-Ras"
                "interface(%d)", PRINT_IPADDR(NHAddr), IfIndex
                );
            IgmpAssertOnError(FALSE);
            Logerr2(CONNECT_FAILED, "%I%d", NHAddr, 
                    pite->IfIndex, Error);
            GOTO_END_BLOCK1;
        }
        
    } END_BREAKOUT_BLOCK1;

    //
    // if error, return from here
    //
    if (Error!=NO_ERROR) {

        RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_ConnectRasClient");

        LeaveIgmpApi();
        return Error;
    }



    //
    // get pointer to RasTable, write lock RasTable and release interface lock
    //
    prt = pite->pRasTable;
    

    BEGIN_BREAKOUT_BLOCK2 {

        //
        // check if a RAS client with similar address already exists
        //
        prte = GetRasClientByAddr(NHAddr, prt);

        if (prte!=NULL) {
            Trace1(ERR, 
                "Ras client(%d.%d.%d.%d) already exists. _ConnectRasClient failed",
                PRINT_IPADDR(NHAddr)
                );
            IgmpAssertOnError(FALSE);
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK2;
        }


        //
        // Create new Ras client entry and initialize the fields
        //

        prte = IGMP_ALLOC(sizeof(RAS_TABLE_ENTRY), 0x40, IfIndex);

        PROCESS_ALLOC_FAILURE2(prte,
                "error %d allocating %d bytes in _ConnectRasClient()",
                Error, sizeof(RAS_TABLE_ENTRY),
                GOTO_END_BLOCK2);


        prte->NHAddr = NHAddr;
        prte->IfTableEntry = pite;
        InitializeListHead(&prte->ListOfSameClientGroups);


        // increment refcount for the ras table
        prt->RefCount++;

        
        //
        // insert into HashTable
        //
        InsertTailList(&prt->HashTableByAddr[RAS_HASH_VALUE(NHAddr)],
                        &prte->HTLinkByAddr);


        //
        // insert the client into list of clients ordered by IpAddr
        //
        pHead = &prt->ListByAddr;
        for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {
            prteCur = CONTAINING_RECORD(ple, RAS_TABLE_ENTRY, LinkByAddr);
            if (NHAddr>prteCur->NHAddr)
                break;
        }
        InsertTailList(&prt->ListByAddr, &prte->LinkByAddr);


        //
        // Set Interface stats to 0
        //
        ZeroMemory(&prte->Info, sizeof(RAS_CLIENT_INFO));

        
        prte->Status = IF_CREATED_FLAG;


        //
        // call MGM to take ownership of this (interface, NHAddr)
        // This call is not made if the interface is not activated.
        //
        
        if (IS_IF_ACTIVATED(pite)) {
            
            MgmTakeInterfaceOwnership(g_MgmIgmprtrHandle,  IfIndex, NHAddr);
            if (Error!=NO_ERROR) {
                Trace2(MGM, 
                    "_TakeInterfaceOwnership rejected for interface %d NHAddr(%d.%d.%d.%d)",
                    IfIndex, PRINT_IPADDR(NHAddr));
                Logerr0(MGM_TAKE_IF_OWNERSHIP_FAILED, Error);
            }
        }
        // register ras client with MGM when the interface is activated.
        else {
            Trace2(ERR, 
                "ras client(%d.%d.%d.%d) connected to an inactive ras server(%d)",
                PRINT_IPADDR(NHAddr), IfIndex);
        }

    } END_BREAKOUT_BLOCK2;

    
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_ConnectRasClient");


    LeaveIgmpApi();
    Trace2(LEAVE, "Leaving _ConnectRasClient(%d.%d.%d.%d):%d\n", 
            PRINT_IPADDR(NHAddr), Error);
    return Error;

} //end _ConnectRasClient




//------------------------------------------------------------------------------
//            _DisconnectRasClient
//
// Takes shared interface lock. retrieves the Ras interface, takes write
// lock on the ras table, and then releases the shared interface lock.
//
// Removes the RasClient Entry from the Ras table so that no one can access
// it through a RAS table. Then queues a work item that will delete all
// GI entries.
//
// Calls: _DeleteRasClient()
//------------------------------------------------------------------------------

DWORD
APIENTRY
DisconnectRasClient (
    DWORD        IfIndex,
    PVOID        pvNHAddr
    )
{
    PIF_TABLE_ENTRY             pite = NULL;
    PRAS_TABLE                  prt;
    PRAS_TABLE_ENTRY            prte, prteCur;
    DWORD                       Error = NO_ERROR;
    PLIST_ENTRY                 pHead, ple;
    PGI_ENTRY                   pgie;
    PIP_LOCAL_BINDING           pNHAddrBinding = (PIP_LOCAL_BINDING)pvNHAddr;
    DWORD                       NHAddr = pNHAddrBinding->Address;

    // mightdo
    // currently rtrmgr passes 0 for IfIndex. so I set it to the value required
    IfIndex = g_RasIfIndex;


    Trace2(ENTER, "Entering DisconnectRasClient for IfIndex(%0x), NextHop(%d.%d.%d.%d)",
            IfIndex, PRINT_IPADDR(NHAddr));

    if (!EnterIgmpApi()) return ERROR_CAN_NOT_COMPLETE;


    //
    // take an exclusive lock on the interface
    //
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_DisconnectRasClient");


    BEGIN_BREAKOUT_BLOCK1 {
        //
        // retrieve the RAS interface entry from the global structure.
        //
        if ( (g_RasIfIndex!=IfIndex) || (g_pRasIfEntry==NULL) ) {
            Error = ERROR_INVALID_PARAMETER;
            Trace2(ERR,
                "attempt to disconnect Ras client(%d.%d.%d.%d) from non-Ras "
                "interface(%d)", PRINT_IPADDR(NHAddr), IfIndex
                );
            IgmpAssertOnError(FALSE);
            Logerr2(DISCONNECT_FAILED, "%I%d", NHAddr,
                    IfIndex, Error);
            GOTO_END_BLOCK1;
        }

        pite = g_pRasIfEntry;

    } END_BREAKOUT_BLOCK1;

    //
    // if error, return from here.
    //
    if (Error!=NO_ERROR) {

        RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_DisconnectRasClient");

        LeaveIgmpApi();
        return Error;
    }


    
    //
    // get pointer to RasTable
    //
    prt = pite->pRasTable;


    BEGIN_BREAKOUT_BLOCK2 {
    
        //
        // retrieve ras client
        //
        prte = GetRasClientByAddr(NHAddr, prt);
        if (prte==NULL) {
            Error = ERROR_INVALID_PARAMETER;
            Trace2(ERR,
                "Illegal attempt to disconnect non-existing Ras client(%d.%d.%d.%d) "
                "from Ras interface(%d)", PRINT_IPADDR(NHAddr), IfIndex);
            IgmpAssertOnError(FALSE);
            Logerr2(DISCONNECT_FAILED, "%I%d", NHAddr,
                    pite->IfIndex, Error);
            GOTO_END_BLOCK2;
        }
        
        //
        // break if ras client has deleted flag set
        //
        if ( (prte->Status&IF_DELETED_FLAG) ) {
            Error = ERROR_CAN_NOT_COMPLETE;
            GOTO_END_BLOCK2;
        }


        //
        // set deleted flag for the ras client, so that no one else will
        // try to access it
        prte->Status |= IF_DELETED_FLAG;

        
        //
        // remove the RAS client from the Ras table lists so that no one will
        // access it.
        //
        RemoveEntryList(&prte->HTLinkByAddr);
        RemoveEntryList(&prte->LinkByAddr);


        //
        // release RasClient virtual interface
        //
        Error = MgmReleaseInterfaceOwnership(g_MgmIgmprtrHandle, pite->IfIndex,
                                            prte->NHAddr);
        if (Error!=NO_ERROR) {
            Trace2(ERR, 
                "Error: _MgmReleaseInterfaceOwnership for If:%0x, NHAddr:%d.%d.%d.%d",
                pite->IfIndex, PRINT_IPADDR(prte->NHAddr));
            IgmpAssertOnError(FALSE);
        }
        

        //
        // remove the ras client's GI entries from the ras server interface
        // list
        //
        
        ACQUIRE_IF_GROUP_LIST_LOCK(IfIndex, "_DisconectRasClient");
        pHead = &prte->ListOfSameClientGroups;
        for (ple=pHead->Flink;  ple!=pHead;  ple=ple->Flink) {
            pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameClientGroups);
            RemoveEntryList(&pgie->LinkBySameIfGroups);
            InitializeListHead(&pgie->LinkBySameIfGroups);
        }
        RELEASE_IF_GROUP_LIST_LOCK(IfIndex, "_DisconnectRasClient");



        //
        // Delete ras client. The refcount is not changed
        // so the prte, prt, pite fields will be valid.
        //
        DeleteRasClient(prte);

    } END_BREAKOUT_BLOCK2;
    

    // release the interface lock
    
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_DisconnectRasClient");
    
                            
    Trace3(LEAVE, 
        "Leaving _DisconnectRasClient(%d) for IfIndex(%0x), NextHop(%d.%d.%d.%d)\n",
        Error, IfIndex, PRINT_IPADDR(NHAddr)
        );
    LeaveIgmpApi();
    
    return Error;
    
} //end _DisconnectRasClient




//------------------------------------------------------------------------------
//            _SetInterfaceConfigInfo
//
// Resets the interface config. The router parameters might have changed. 
// Also proxy<-->router transition might have taken place.
//
// Locks: takes IfLists lock initiallly itself just in case the interface had to
//    be disabled. Runs completely in exclusive interface lock.
//------------------------------------------------------------------------------    
DWORD
WINAPI
SetInterfaceConfigInfo(
    IN DWORD IfIndex,
    IN PVOID pvConfig,
    IN ULONG ulStructureVersion,
    IN ULONG ulStructureSize,
    IN ULONG ulStructureCount
    )
{
    DWORD                   Error=NO_ERROR;
    PIGMP_IF_CONFIG         pConfigDst;
    PIGMP_MIB_IF_CONFIG     pConfigSrc;
    PIF_TABLE_ENTRY         pite = NULL;
    DWORD                   OldState, OldProtoType, NewProtoType;
    BOOL                    bIgmpProtocolChanged=FALSE, bEnabledStateChanged=FALSE;
    BOOL                    bOldStateEnabled=FALSE;
    
    
    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace1(ENTER, "entering SetInterfaceConfigInfo(%d)", IfIndex);
    // make sure it is not an unsupported igmp version structure
    if (ulStructureVersion>=IGMP_CONFIG_VERSION_600) {
        Trace1(ERR, "Unsupported IGMP version structure: %0x",
            ulStructureVersion);
        IgmpAssertOnError(FALSE);
        LeaveIgmpApi();
        return ERROR_CAN_NOT_COMPLETE;
    }

    ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_SetInterfaceConfigInfo");    
    ACQUIRE_IF_LIST_LOCK("_SetInterfaceConfigInfo");
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_SetInterfaceConfigInfo");


    
    BEGIN_BREAKOUT_BLOCK1 {

        if (pvConfig==NULL) {
            Error = ERROR_CAN_NOT_COMPLETE;
            GOTO_END_BLOCK1;
        }
        
        pConfigSrc = (PIGMP_MIB_IF_CONFIG)pvConfig;


        //
        // find the interface specified
        //
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }    


        //
        // validate the new config values
        //
        Error = ValidateIfConfig(pConfigSrc, IfIndex, pite->IfType, 
                    ulStructureVersion, ulStructureSize
                    );
        if (Error!=NO_ERROR)
            GOTO_END_BLOCK1;


        pConfigDst = &pite->Config;


        //
        // make sure you are not setting multiple proxy interfaces
        //
        if (IS_CONFIG_IGMPPROXY(pConfigSrc) 
            &&!IS_CONFIG_IGMPPROXY(pConfigDst)
            && (g_ProxyIfIndex!=0) )
        {
            Error = ERROR_INVALID_PARAMETER;
            Trace1(ERR, "Cannot set multiple Proxy interfaces. Proxy exists on %d",
                    g_ProxyIfIndex);
            IgmpAssertOnError(FALSE);
            Logerr0(PROXY_IF_EXISTS, Error);
                    
            GOTO_END_BLOCK1;
        }

        
        //
        // Process change in IgmpProtocolType (between proxy and router)
        // (no special processing for changes between ver-1 and ver-2)
        //
        if (pConfigSrc->IgmpProtocolType != pConfigDst->IgmpProtocolType)
        {
            bIgmpProtocolChanged = TRUE;
            GOTO_END_BLOCK1;
        }
        else 
            bIgmpProtocolChanged = FALSE;


        OldProtoType = pConfigDst->IgmpProtocolType;


        //
        // if interface enabled state has changed, then process that change
        // I dont have to look for version changes, etc
        //
        if (IGMP_ENABLED_FLAG_SET(pConfigSrc->Flags)
            != IGMP_ENABLED_FLAG_SET(pConfigDst->Flags)) 
        {

            bEnabledStateChanged = TRUE;

            pite->Info.OtherVerPresentTimeWarn = 0;
            
            bOldStateEnabled = IGMP_ENABLED_FLAG_SET(pConfigDst->Flags);
            GOTO_END_BLOCK1;
        }

        else 
            bEnabledStateChanged = FALSE;
            
        

            
        // copy the new config
        
        if (IS_IF_ACTIVATED(pite))
            CopyinIfConfigAndUpdate(pite, pConfigSrc, IfIndex);
        else
            CopyinIfConfig(&pite->Config, pConfigSrc, IfIndex);

        NewProtoType = pConfigDst->IgmpProtocolType;

        /*
        // 
        // if changing from V1 <-> V2
        //
        if ( ((OldProtoType==IGMP_ROUTER_V1) && (NewProtoType==IGMP_ROUTER_V2))
            || ((OldProtoType==IGMP_ROUTER_V2) && (NewProtoType==IGMP_ROUTER_V1)) )
        {
            pite->Info.OtherVerPresentTimeWarn = 0;
        }
        */
                    
    } END_BREAKOUT_BLOCK1;

    

    //
    // change the protocol and check for state changes. 
    // This function will effectively delete the interface with the old
    // protocol and create a new interface with the new protocol.
    //
    if ( (bIgmpProtocolChanged)&&(Error==NO_ERROR) )
        ProcessIfProtocolChange(IfIndex, pConfigSrc);


    //
    // Process State Change: enable or disable interface  
    //
    else if ( (bEnabledStateChanged)&&(Error==NO_ERROR) ) {

        //
        // disable the interface and then copy in the new config
        //
        if (bOldStateEnabled) {

            // old state enabled, new state disabled

            DisableInterface_ConfigChanged(IfIndex);

            //
            // copy the config 
            //
            // get the pite entry again, as disable creates a new one
            //
            
            pite = GetIfByIndex(IfIndex);
            CopyinIfConfig(&pite->Config, pConfigSrc, IfIndex);

            
        }
        //
        // copy the new config before enabling it
        //
        else {

            CopyinIfConfig(&pite->Config, pConfigSrc, IfIndex);
            
            //
            // set the enable state to false, so that the below call can
            // enable the interface.
            //
            pite->Config.Flags &= ~IGMP_INTERFACE_ENABLED_IN_CONFIG;


            // old state disabled, new state enabled

            EnableInterface_ConfigChanged(IfIndex);
        }
    }


    RELEASE_SOCKETS_LOCK_EXCLUSIVE("_SetInterfaceConfigInfo");    
    RELEASE_IF_LIST_LOCK("_SetInterfaceConfigInfo");
    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_SetInterfaceConfigInfo");


    
    Trace2(LEAVE, "leaving SetInterfaceConfigInfo(%d):%d\n", IfIndex, Error);

    LeaveIgmpApi();

    return Error;
    
} //end _SetInterfaceConfigInfo



//------------------------------------------------------------------------------
//          _ProcessProtocolChange
//
// Called when the interface protocol has changed (proxy<->router).
// First disables the old interface so that all old protocol data is cleaned up.
// then sets the new config, and enables the interface again (if it was
// enabled before). This process takes care of creation/deletion of sockets, etc
//
// Locks: no locks when called. Except for _Disable(_Enable)Interface, all work
//          is done inside an exclusive IfLock.
// Calls: _DisableInterface(), _EnableInterface() if required.
//------------------------------------------------------------------------------
DWORD
ProcessIfProtocolChange(
    DWORD               IfIndex,
    PIGMP_MIB_IF_CONFIG pConfigSrc
    )
{
    DWORD                   Error=NO_ERROR, dwDisabled;
    PIGMP_IF_CONFIG         pConfigDst;
    PIF_TABLE_ENTRY         pite = NULL;


    Trace1(ENTER, "Entered _ProcessIfProtocolChange(%d)", IfIndex);

    
    //
    // disable the interface so that all protocol specific data is lost
    //
    dwDisabled = DisableIfEntry(IfIndex, TRUE);


    //
    // find the interface specified and copy the config info. The config
    // has already been validated.
    //
    
    ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_ProcessIfProtocolChange");


    BEGIN_BREAKOUT_BLOCK1 {

        // get interface again
        
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }    

        pConfigDst = &pite->Config;



        //
        // if old interface was Proxy, then remove it from the Global Struct
        // and delete the Proxy_HT related structures
        //
        if (IS_PROTOCOL_TYPE_PROXY(pite)) {

            // _DisableIfEntry would have deleted all the entries in the proxy
            // Hash table
            
            IGMP_FREE(pite->pProxyHashTable);

            InterlockedExchange(&g_ProxyIfIndex, 0);
            InterlockedExchangePointer(&g_pProxyIfEntry, NULL);
        }


        
        //
        // copy the new config values
        //
        CopyinIfConfig(&pite->Config, pConfigSrc, IfIndex);



        //
        // if new interface is Proxy, then add it to the Global Struct
        // and create the Proxy_HT structures
        //

        if (IS_PROTOCOL_TYPE_PROXY(pite)) {
        
            DWORD       dwSize = PROXY_HASH_TABLE_SZ * sizeof(LIST_ENTRY);
            DWORD       i;
            PLIST_ENTRY pProxyHashTable;
            
            pProxyHashTable = pite->pProxyHashTable = IGMP_ALLOC(dwSize, 0x80,IfIndex);

            PROCESS_ALLOC_FAILURE2(pProxyHashTable,
                    "error %d allocating %d bytes for interface table",
                    Error, dwSize,
                    GOTO_END_BLOCK1);


            for (i=0;  i<PROXY_HASH_TABLE_SZ;  i++) {
                InitializeListHead(pProxyHashTable+i);
            }


            InterlockedExchangePointer(&g_pProxyIfEntry, pite);
            InterlockedExchange(&g_ProxyIfIndex, IfIndex);

            pite->CreationFlags |= CREATED_PROXY_HASH_TABLE;

        }

    } END_BREAKOUT_BLOCK1;
    

    RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_ProcessIfProtocolChange");


    //
    // enable the interface if the new state requires
    // it to be enabled.
    //
    if ( (Error==NO_ERROR) && (dwDisabled==NO_ERROR) )
        Error = EnableIfEntry(IfIndex, TRUE);


    Trace2(LEAVE, "Leaving _ProcessIfProtocolChange(%d): %d\n", 
            IfIndex, Error);
    return Error;
    
} //end _ProcessIfProtocolChange



//------------------------------------------------------------------------------
//          _GetInterfaceConfigInfo
//
// The Router Manager calls us with a NULL config and ZERO size. We return
// the required size to it.  It then allocates the needed memory and calls
// us a second time with a valid buffer.  We validate parameters each time
// and copy out our config if we can
//
// Return Value
//    ERROR_INSUFFICIENT_BUFFER If the size of the buffer is too small
//    ERROR_INVALID_PARAMETER    ERROR_INVALID_DATA      NO_ERROR
//------------------------------------------------------------------------------

DWORD
WINAPI
GetInterfaceConfigInfo(
    IN     DWORD  IfIndex,
    IN OUT PVOID  pvConfig,
    IN OUT PDWORD pdwSize,
    IN OUT PULONG pulStructureVersion,
    IN OUT PULONG pulStructureSize,
    IN OUT PULONG pulStructureCount
    )
{

    DWORD                   Error = NO_ERROR;
    PIF_TABLE_ENTRY         pite = NULL;
    PIGMP_MIB_IF_CONFIG     pConfigDst;
    PIGMP_IF_CONFIG         pConfigSrc;


    if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; }
    Trace3(ENTER1, 
        "entering _GetInterfaceConfigInfo(%d): ConfigPrt(%08x) SizePrt(%08x)",
        IfIndex, pvConfig, pdwSize
        );


    ACQUIRE_IF_LOCK_SHARED(IfIndex, "_GetInterfaceConfigInfo");

    BEGIN_BREAKOUT_BLOCK1 {

        //
        // check the arguments
        //
        if (pdwSize == NULL) {
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        //
        // find the interface specified
        //
        pite = GetIfByIndex(IfIndex);

        if (pite == NULL) {
            Error = ERROR_INVALID_PARAMETER;
            GOTO_END_BLOCK1;
        }


        pConfigSrc = &pite->Config;


        // get the size of the interface config
        

        //
        // check the buffer size
        //

        if (*pdwSize < pConfigSrc->ExtSize) {
            Error = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
        

            pConfigDst = (PIGMP_MIB_IF_CONFIG)pvConfig;


            //
            // copy the interface config, and set the IP address
            //
            CopyoutIfConfig(pConfigDst, pite);

        }

        *pdwSize = pConfigSrc->ExtSize;

    } END_BREAKOUT_BLOCK1;


    RELEASE_IF_LOCK_SHARED(IfIndex, "_GetInterfaceConfigInfo");

    if (pulStructureCount)
        *pulStructureCount = 1;
    if (pulStructureSize)
        *pulStructureSize = *pdwSize;
    if (pulStructureVersion)
        *pulStructureVersion = IGMP_CONFIG_VERSION_500;

    Trace2(LEAVE1, "leaving _GetInterfaceConfigInfo(%d): %d\n", IfIndex, Error);
    LeaveIgmpApi();

    return Error;
}


DWORD
WINAPI
InterfaceStatus(
    ULONG IfIndex,
    BOOL  bIfActive,
    DWORD dwStatusType,
    PVOID pvStatusInfo
    )
{
    DWORD Error = NO_ERROR;
    
    switch(dwStatusType)
    {
        case RIS_INTERFACE_ADDRESS_CHANGE:
        {
            PIP_ADAPTER_BINDING_INFO pBindInfo
                                    = (PIP_ADAPTER_BINDING_INFO)pvStatusInfo;
            
            if(pBindInfo->AddressCount)
            {
                Error = BindInterface(IfIndex, pvStatusInfo);
            }
            else 
            {
                Error = UnBindInterface(IfIndex);
            }

            break;
        }

        case RIS_INTERFACE_ENABLED:
        {
            Error = EnableInterface(IfIndex);
            break;
        }

        case RIS_INTERFACE_DISABLED:
        {
            Error = DisableInterface(IfIndex);
            break;
        }

    }

    return Error;
}

DWORD
WINAPI
IgmpMibIfConfigSize(
    PIGMP_MIB_IF_CONFIG pConfig
    )
{
    DWORD Size = sizeof(IGMP_MIB_IF_CONFIG);

    if (pConfig->NumStaticGroups && !IS_CONFIG_IGMP_V3(pConfig)) {
        Size += pConfig->NumStaticGroups*sizeof(IGMP_STATIC_GROUP);
    }
    else if (pConfig->NumStaticGroups && IS_CONFIG_IGMP_V3(pConfig)) {

        DWORD i;
        PSTATIC_GROUP_V3 pStaticGroupV3 = GET_FIRST_STATIC_GROUP_V3(pConfig);
                                
        for (i=0;  i<pConfig->NumStaticGroups;  i++) {
            DWORD EntrySize = sizeof(STATIC_GROUP_V3)
                                + pStaticGroupV3->NumSources*sizeof(IPADDR);
            Size += EntrySize;            
            pStaticGroupV3 = (PSTATIC_GROUP_V3)
                             ((PCHAR)(pStaticGroupV3) + EntrySize);
        }
    }

    return Size;
}