windows-xp/Source/XPSP1/NT/net/rras/ip/rip/api.c

//============================================================================
// Copyright (c) 1995, Microsoft Corporation
//
// File: api.c
//
// History:
//      Abolade Gbadegesin  Aug-8-1995  Created.
//
// router manager API implementations
//============================================================================

#include "pchrip.h"
#pragma hdrstop



//
// Definition of sole global variable for IPRIP
//

IPRIP_GLOBALS ig;



//----------------------------------------------------------------------------
// Function:    DLLMAIN
//
// This is the DLL entrypoint handler. It calls DllStartup
// to initialize locking and event queue and to create IPRIP's heap,
// and calls DllCleanup to delete the lock and event queue.
//----------------------------------------------------------------------------

BOOL
WINAPI
DLLMAIN(
    HINSTANCE hInstance,
    DWORD dwReason,
    PVOID pUnused
    ) {

    BOOL bErr;


    bErr = FALSE;

    switch(dwReason) {
        case DLL_PROCESS_ATTACH:

            DisableThreadLibraryCalls(hInstance);

            bErr = DllStartup();
            break;

        case DLL_PROCESS_DETACH:

            bErr = DllCleanup();
            break;

        default:

            bErr = TRUE;
            break;
    }

    return bErr;
}



//----------------------------------------------------------------------------
// Function:    DllStartup
//
// Initializes IPRIP's function lock, event queue, and global heap.
//----------------------------------------------------------------------------

BOOL
DllStartup(
    ) {

    BOOL bErr;
    DWORD dwErr;


    bErr = TRUE;

    do { // error breakout loop

        ZeroMemory(&ig, sizeof(IPRIP_GLOBALS));


        //
        // create the global critical section and set IPRIP's status
        //

        try {
            InitializeCriticalSection(&ig.IG_CS);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {

            bErr = FALSE;
            break;
        }

        ig.IG_Status = IPRIP_STATUS_STOPPED;


        //
        // attempt to create a private heap for IPRIP
        //

        ig.IG_IpripGlobalHeap = HeapCreate(0, 0, 0);

        if (ig.IG_IpripGlobalHeap == NULL) {

            bErr = FALSE;
            break;
        }


        //
        // create the router manager message queue
        //


        ig.IG_EventQueue = RIP_ALLOC(sizeof(LOCKED_LIST));

        if (ig.IG_EventQueue == NULL) {

            bErr = FALSE;
            break;
        }


        //
        // initialize the Router Manager event queue
        //

        try {
            CREATE_LOCKED_LIST(ig.IG_EventQueue);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {

            bErr = FALSE;
            break;
        }


    } while(FALSE);

    return bErr;
}



//----------------------------------------------------------------------------
// Function:    DllCleanup
//
// Deletes the global heap, event queue, and function lock.
//----------------------------------------------------------------------------

BOOL
DllCleanup(
    ) {

    BOOL bErr;


    bErr = TRUE;


    do { // error breakout loop

        //
        // destroy the router manager event queue
        //

        if (ig.IG_EventQueue != NULL) {

            if (LOCKED_LIST_CREATED(ig.IG_EventQueue)) {

                DELETE_LOCKED_LIST(
                    ig.IG_EventQueue, EVENT_QUEUE_ENTRY, EQE_Link
                    );
            }

            RIP_FREE(ig.IG_EventQueue);
        }


        if (ig.IG_IpripGlobalHeap != NULL) {
            HeapDestroy(ig.IG_IpripGlobalHeap);
        }



        //
        // delete the global critical section
        //

        DeleteCriticalSection(&ig.IG_CS);


        RouterLogDeregister(ig.IG_LogHandle);
        if (ig.IG_TraceID != INVALID_TRACEID) {
            TraceDeregister(ig.IG_TraceID);
        }
        
    } while(FALSE);


    return bErr;
}




//----------------------------------------------------------------------------
// Function:    ProtocolStartup
//
// This is called by StartProtocol. Initializes data structures,
// creates IPRIP threads.
//----------------------------------------------------------------------------

DWORD
ProtocolStartup(
    HANDLE hEventEvent,
    PVOID pConfig
    ) {

    WSADATA wd;
    HANDLE hThread;
    BOOL bCleanupWinsock;
    DWORD dwErr, dwSize, dwThread;
    PIPRIP_GLOBAL_CONFIG pgcsrc, pgcdst;



    EnterCriticalSection(&ig.IG_CS);

    ig.IG_TraceID = TraceRegister("IPRIP2");
    ig.IG_LogHandle = RouterLogRegister("IPRIP2");


    //
    // make certain RIP is not already running
    //

    if (ig.IG_Status != IPRIP_STATUS_STOPPED) {

        TRACE0(START, "ERROR: StartProtocol called with IPRIP already running");
        LOGWARN0(IPRIP_ALREADY_STARTED, NO_ERROR);

        LeaveCriticalSection(&ig.IG_CS);
        return ERROR_CAN_NOT_COMPLETE;
    }



    bCleanupWinsock = FALSE;


    do { // break-out construct



        TRACE0(ENTER, "IPRIP is starting up");


        //
        // save the Router Manager notification event
        //

        ig.IG_EventEvent = hEventEvent;


        //
        // find the size of the global configuration passed in
        //

        pgcsrc = (PIPRIP_GLOBAL_CONFIG)pConfig;

        dwSize = IPRIP_GLOBAL_CONFIG_SIZE(pgcsrc);


        //
        // allocate a block to hold the configuration
        //

        ig.IG_Config = pgcdst = RIP_ALLOC(dwSize);

        if (pgcdst == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for global config",
                dwErr, dwSize
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // copy the supplied configuration
        //

        CopyMemory(pgcdst, pgcsrc, dwSize);
        ig.IG_LogLevel = pgcsrc->GC_LoggingLevel;


        //
        // attempt to start Winsock
        //

        dwErr = (DWORD)WSAStartup(MAKEWORD(1,1), &wd);

        if (dwErr != 0) {

            TRACE1(START, "error %d starting Windows Sockets.", dwErr);
            LOGERR0(WSASTARTUP_FAILED, dwErr);

            break;
        }

        bCleanupWinsock = TRUE;


        //
        // attempt to create synchronization object for global config
        //

        dwErr = CreateReadWriteLock(&ig.IG_RWL);
        if (dwErr != NO_ERROR) {

            TRACE1(START, "error %d creating read-write lock", dwErr);
            LOGERR0(CREATE_RWL_FAILED, dwErr);

            break;
        }


        //
        // register a timer queue with Ntdll timer thread
        //

        ig.IG_TimerQueueHandle = CreateTimerQueue();

        if ( !ig.IG_TimerQueueHandle) {

            dwErr = GetLastError();
            
            TRACE1(START,
                "error %d registering time queue with NtdllTimer thread",
                dwErr
                );
            LOGERR0(CREATE_TIMER_QUEUE_FAILED, dwErr);

            break;
        }


        //
        // allocate space for an interface table
        //

        ig.IG_IfTable = RIP_ALLOC(sizeof(IF_TABLE));
        if (ig.IG_IfTable == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for interface table",
                dwErr, sizeof(IF_TABLE)
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // initialize the interface table
        //

        dwErr = CreateIfTable(ig.IG_IfTable);

        if (dwErr != NO_ERROR) {

            TRACE1(START, "error %d initializing interface table", dwErr);
            LOGERR0(CREATE_IF_TABLE_FAILED, dwErr);

            break;
        }


        //
        // allocate space for the peer statistics table
        //

        ig.IG_PeerTable = RIP_ALLOC(sizeof(PEER_TABLE));

        if (ig.IG_PeerTable == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for peer table",
                dwErr, sizeof(PEER_TABLE)
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // initialize the peer statistics table
        //

        dwErr = CreatePeerTable(ig.IG_PeerTable);

        if (dwErr != NO_ERROR) {

            TRACE1(START, "error %d initializing peer statistics table", dwErr);
            LOGERR0(CREATE_PEER_TABLE_FAILED, dwErr);

            break;
        }


        //
        // allocate space for the binding table
        //

        ig.IG_BindingTable = RIP_ALLOC(sizeof(BINDING_TABLE));

        if (ig.IG_BindingTable == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for binding table",
                dwErr, sizeof(PEER_TABLE)
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // initialize the binding table
        //

        dwErr = CreateBindingTable(ig.IG_BindingTable);
        if (dwErr != NO_ERROR) {

            TRACE1(START, "error %d creating binding table", dwErr);
            LOGERR0(CREATE_BINDING_TABLE_FAILED, dwErr);

            break;
        }


        //
        // allocate space for the send queue
        //

        ig.IG_SendQueue = RIP_ALLOC(sizeof(LOCKED_LIST));

        if (ig.IG_SendQueue == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for send-queue",
                dwErr, sizeof(LOCKED_LIST)
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // initialize the send queue
        //

        try {
            CREATE_LOCKED_LIST(ig.IG_SendQueue);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {

            dwErr = GetExceptionCode();
            TRACE1(START, "exception %d initializing send queue", dwErr);
            LOGERR0(INIT_CRITSEC_FAILED, dwErr);

            break;
        }


        //
        // allocate space for the receive queue
        //

        ig.IG_RecvQueue = RIP_ALLOC(sizeof(LOCKED_LIST));

        if (ig.IG_RecvQueue == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for receive queue",
                dwErr, sizeof(LOCKED_LIST)
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // initialize the receive queue
        //

        try {
            CREATE_LOCKED_LIST(ig.IG_RecvQueue);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {

            dwErr = GetExceptionCode();
            TRACE1(START, "exception %d initializing receive queue", dwErr);
            LOGERR0(INIT_CRITSEC_FAILED, dwErr);

            break;
        }



        //
        // create event signalled by WinSock when input arrives
        // and register it with the NtdllWait thread
        //

        ig.IG_IpripInputEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

        if (ig.IG_IpripInputEvent == NULL) {

            dwErr = GetLastError();
            TRACE1(START, "error %d creating event to signal input", dwErr);
            LOGERR0(CREATE_EVENT_FAILED, dwErr);

            break;
        }

         
        if (! RegisterWaitForSingleObject(
                  &ig.IG_IpripInputEventHandle,
                  ig.IG_IpripInputEvent,
                  CallbackFunctionNetworkEvents,
                  NULL,
                  INFINITE,
                  (WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE)
                  )) {

            dwErr = GetLastError();
            
            TRACE1(START,
                "error %d registering input event with NtdllWait thread",
                dwErr);
            LOGERR0(REGISTER_WAIT_FAILED, dwErr);

            break;
        }


        //
        // initialize the count of threads which are active in IPRIP
        // (includes IpripThread and worker threads),
        // and create the semaphore released by each thread when it is done
        //

        ig.IG_ActivityCount = 0;

        ig.IG_ActivitySemaphore = CreateSemaphore(NULL, 0, 0xfffffff, NULL);

        if (ig.IG_ActivitySemaphore == NULL) {

            dwErr = GetLastError();
            TRACE1(
                START, "error %d creating semaphore for IPRIP threads", dwErr
                );
            LOGERR0(CREATE_SEMAPHORE_FAILED, dwErr);

            break;
        }



        //
        // register with RTMv2
        //

        ig.IG_RtmEntityInfo.RtmInstanceId = 0;
        ig.IG_RtmEntityInfo.AddressFamily = AF_INET;
        ig.IG_RtmEntityInfo.EntityId.EntityProtocolId = PROTO_IP_RIP;
        ig.IG_RtmEntityInfo.EntityId.EntityInstanceId = 0;
        
        dwErr = RtmRegisterEntity(
                    &ig.IG_RtmEntityInfo, NULL,
                    ProcessRtmNotification,
                    FALSE, &ig.IG_RtmProfile,
                    &ig.IG_RtmHandle
                    );

        if (dwErr != NO_ERROR ) {
        
            TRACE1(START, "error %d registering with RTM", dwErr);
            LOGERR0(RTM_REGISTER_FAILED, dwErr);

            break;
        }

        dwErr = RtmRegisterForChangeNotification(
                    ig.IG_RtmHandle,
                    RTM_VIEW_MASK_UCAST,
                    RTM_CHANGE_TYPE_BEST,
                    NULL,
                    &ig.IG_RtmNotifHandle
                    );

        if (dwErr != NO_ERROR ) {
        
            TRACE1(START, "error %d registering for change with RTM", dwErr);
            LOGERR0(RTM_REGISTER_FAILED, dwErr);

            break;
        }

                    
        //
        // set IPRIP's status to running now, before we attempt
        // to queue the MIB display work-item;
        // QueueRipWorker() will check the status,
        // and it will refuse to queue any work-items
        // unless the status is IPRIP_STATUS_RUNNING
        //

        ig.IG_Status = IPRIP_STATUS_RUNNING;


#if CONFIG_DBG

        //
        // queue work item to display IPRIP's MIB tables periodically
        //

        ig.IG_MibTraceID = TraceRegisterEx("IPRIPMIB", TRACE_USE_CONSOLE);

        if (ig.IG_MibTraceID != INVALID_TRACEID) {
        
            //
            // create the persistent timer for the timer queue
            //

            if (!CreateTimerQueueTimer(
                    &ig.IG_MibTimerHandle, ig.IG_TimerQueueHandle,
                    WorkerFunctionMibDisplay, NULL,
                    0, 10000, 0)) {

                dwErr = GetLastError();
                
                TRACE1(START, "error %d creating MIB display timer", dwErr);
            }
        }

#endif


        TRACE0(START, "IPRIP has started successfully");
        LOGINFO0(IPRIP_STARTED, NO_ERROR);

        LeaveCriticalSection(&ig.IG_CS);

        return NO_ERROR;


    } while (FALSE);



    //
    // something went wrong, so we cleanup.
    // Note that we needn't worry about the main thread,
    // since when we finally leave this critical section it will find
    // that the status is IPRIP_STATUS_STOPPED, and it will immediately quit
    //

    TRACE0(START, "IPRIP failed to start");

    ProtocolCleanup(bCleanupWinsock);


    LeaveCriticalSection(&ig.IG_CS);

    return (dwErr == NO_ERROR ? ERROR_CAN_NOT_COMPLETE : dwErr);
}



//----------------------------------------------------------------------------
// Function: ProtocolCleanup
//
// This function deallocates allocated memory, closes open handles, and
// cleans up the global struct. It leaves IPRIP in clean state, so that
// it should be possible to do StartProtocol again with no memory leaks.
//----------------------------------------------------------------------------

DWORD
ProtocolCleanup(
    BOOL bCleanupWinsock
    ) {

    DWORD dwErr;
    
    // EnterCriticalSection(&ig.IG_CS);


#ifdef CONFIG_DBG
    TraceDeregister(ig.IG_MibTraceID);
    ig.IG_MibTraceID = INVALID_TRACEID;
#endif


    if ( ig.IG_RtmNotifHandle != NULL ) {
    
        dwErr = RtmDeregisterFromChangeNotification(
                    ig.IG_RtmHandle, ig.IG_RtmNotifHandle
                    );

        if ( dwErr != NO_ERROR ) {

            TRACE1(STOP, "error %d deregistering change notification", dwErr);
        }    
    }

    if (ig.IG_RtmHandle != NULL) {
    
        dwErr = RtmDeregisterEntity(ig.IG_RtmHandle);

        if ( dwErr != NO_ERROR ) {

            TRACE1(STOP, "error %d deregistering from RTM", dwErr);
        }    
    }
        

    if (ig.IG_ActivitySemaphore != NULL) {

        CloseHandle(ig.IG_ActivitySemaphore);
        ig.IG_ActivitySemaphore = NULL;
    }


    if (ig.IG_IpripInputEvent != NULL) {

        CloseHandle(ig.IG_IpripInputEvent);
        ig.IG_IpripInputEvent = NULL;
    }



    if (ig.IG_RecvQueue != NULL) {

        if (LOCKED_LIST_CREATED(ig.IG_RecvQueue)) {

            FlushRecvQueue(ig.IG_RecvQueue);

            DELETE_LOCKED_LIST(ig.IG_RecvQueue, RECV_QUEUE_ENTRY, RQE_Link);
        }

        RIP_FREE(ig.IG_RecvQueue);
        ig.IG_RecvQueue = NULL;
    }


    if (ig.IG_SendQueue != NULL) {

        if (LOCKED_LIST_CREATED(ig.IG_SendQueue)) {

            FlushSendQueue(ig.IG_SendQueue);

            DELETE_LOCKED_LIST(ig.IG_SendQueue, SEND_QUEUE_ENTRY, SQE_Link);
        }

        RIP_FREE(ig.IG_SendQueue);
        ig.IG_SendQueue = NULL;
    }


    if (ig.IG_BindingTable != NULL) {
        if (BINDING_TABLE_CREATED(ig.IG_BindingTable)) {
            DeleteBindingTable(ig.IG_BindingTable);
        }

        RIP_FREE(ig.IG_BindingTable);
        ig.IG_BindingTable = NULL;
    }


    if (ig.IG_PeerTable != NULL) {

        if (PEER_TABLE_CREATED(ig.IG_PeerTable)) {
            DeletePeerTable(ig.IG_PeerTable);
        }

        RIP_FREE(ig.IG_PeerTable);
        ig.IG_PeerTable = NULL;
    }


    if (ig.IG_IfTable != NULL) {

        if (IF_TABLE_CREATED(ig.IG_IfTable)) {
            DeleteIfTable(ig.IG_IfTable);
        }

        RIP_FREE(ig.IG_IfTable);
        ig.IG_IfTable = NULL;
    }


    if (READ_WRITE_LOCK_CREATED(&ig.IG_RWL)) {
        DeleteReadWriteLock(&ig.IG_RWL);
    }


    if (bCleanupWinsock) {
        WSACleanup();
    }


    if (ig.IG_Config != NULL) {

        RIP_FREE(ig.IG_Config);
        ig.IG_Config = NULL;
    }


    ig.IG_Status = IPRIP_STATUS_STOPPED;

    // LeaveCriticalSection(&ig.IG_CS);

    return NO_ERROR;

}




//----------------------------------------------------------------------------
// Function:    RegisterProtocol
//
// Returns protocol ID and functionality for IPRIP
//----------------------------------------------------------------------------

DWORD
APIENTRY
RegisterProtocol(
    IN OUT PMPR_ROUTING_CHARACTERISTICS pRoutingChar,
    IN OUT PMPR_SERVICE_CHARACTERISTICS pServiceChar
    )
{
    if(pRoutingChar->dwProtocolId != MS_IP_RIP)
    {
        return ERROR_NOT_SUPPORTED;
    }

    //
    // Since we are not a service advertiser (and IPX thing)
    //

    pServiceChar->fSupportedFunctionality = 0;

    if((pRoutingChar->fSupportedFunctionality & (RF_ROUTING|RF_DEMAND_UPDATE_ROUTES)) !=
       (RF_ROUTING|RF_DEMAND_UPDATE_ROUTES))
    {
        return ERROR_NOT_SUPPORTED;
    }

    pRoutingChar->fSupportedFunctionality = (RF_ROUTING | RF_DEMAND_UPDATE_ROUTES);

   pRoutingChar->fSupportedFunctionality = RF_ROUTING;

   pRoutingChar->pfnStartProtocol      = StartProtocol;
   pRoutingChar->pfnStartComplete      = StartComplete;
   pRoutingChar->pfnStopProtocol       = StopProtocol;
   pRoutingChar->pfnGetGlobalInfo      = GetGlobalInfo;
   pRoutingChar->pfnSetGlobalInfo      = SetGlobalInfo;
   pRoutingChar->pfnQueryPower         = NULL;
   pRoutingChar->pfnSetPower           = NULL;

   pRoutingChar->pfnAddInterface       = AddInterface;
   pRoutingChar->pfnDeleteInterface    = DeleteInterface;
   pRoutingChar->pfnInterfaceStatus    = InterfaceStatus;
   pRoutingChar->pfnGetInterfaceInfo   = GetInterfaceConfigInfo;
   pRoutingChar->pfnSetInterfaceInfo   = SetInterfaceConfigInfo;

   pRoutingChar->pfnGetEventMessage    = GetEventMessage;

   pRoutingChar->pfnUpdateRoutes       = DoUpdateRoutes;

   pRoutingChar->pfnConnectClient      = NULL;
   pRoutingChar->pfnDisconnectClient   = NULL;

   pRoutingChar->pfnGetNeighbors       = NULL;
   pRoutingChar->pfnGetMfeStatus       = NULL;

   pRoutingChar->pfnMibCreateEntry     = MibCreate;
   pRoutingChar->pfnMibDeleteEntry     = MibDelete;
   pRoutingChar->pfnMibGetEntry        = MibGet;
   pRoutingChar->pfnMibSetEntry        = MibSet;
   pRoutingChar->pfnMibGetFirstEntry   = MibGetFirst;
   pRoutingChar->pfnMibGetNextEntry    = MibGetNext;

    return NO_ERROR;
}




//----------------------------------------------------------------------------
// Function:    StartProtocol
//
// creates events, tables and queues used by IPRIP, registers with RTM,
// and starts threads.
//----------------------------------------------------------------------------

DWORD
WINAPI
StartProtocol (
    HANDLE              NotificationEvent,
    SUPPORT_FUNCTIONS   *SupportFunctions,
    LPVOID              GlobalInfo,
    ULONG               StructureVersion,
    ULONG               StructureSize,
    ULONG               StructureCount
    )
{
    ig.IG_SupportFunctions = *SupportFunctions;
    
    return ProtocolStartup(NotificationEvent, GlobalInfo);
}


//----------------------------------------------------------------------------
// Function:    StartComplete
//
// Invoked by RouterManager to inform protocol that startup (init + interface
// additions are complete).  Protocol is expected to wait for this before
// starting protocol specfic behavior
//----------------------------------------------------------------------------

DWORD
APIENTRY 
StartComplete(
    VOID
    )
{
    return NO_ERROR;
}

//----------------------------------------------------------------------------
// Function:    StopProtocol
//
// This function is onvoked by Router Manager. It informs the main thread
// that it should exit, and then queues a work-item which waits for it
// to exit as well as any active or queued work-items.
//----------------------------------------------------------------------------

DWORD
APIENTRY
StopProtocol(
    VOID
    ) {

    LONG lThreadCount;



    EnterCriticalSection(&ig.IG_CS);


    //
    // cannot stop if already stopped
    //

    if (ig.IG_Status != IPRIP_STATUS_RUNNING) {

        LeaveCriticalSection(&ig.IG_CS);
        return ERROR_CAN_NOT_COMPLETE;
    }



    TRACE0(ENTER, "entering StopProtocol");


    //
    // set IPRIP's status to STOPPING;
    // this prevents any more work-items from being queued,
    // and it prevents the ones already queued from executing
    //

    ig.IG_Status = IPRIP_STATUS_STOPPING;


    //
    // find out how many threads are active in IPRIP;
    // we will have to wait for this many threads to exit
    // before we clean up RIP's resources
    //

    lThreadCount = ig.IG_ActivityCount;

    TRACE1(STOP, "%d threads are active in IPRIP", lThreadCount);


    LeaveCriticalSection(&ig.IG_CS);


    //
    // queue the stopprotocol work-item, and return PENDING to Router Manager
    //

    QueueUserWorkItem(
        (LPTHREAD_START_ROUTINE)WorkerFunctionFinishStopProtocol,
        (PVOID)UlongToPtr(lThreadCount), 0
        );



    TRACE0(LEAVE, "leaving StopProtocol");

    return ERROR_PROTOCOL_STOP_PENDING;
}



//----------------------------------------------------------------------------
// Function:    GetGlobalInfo
//
// Copies to the given buffer the global information currently in use by
// IPRIP.
//----------------------------------------------------------------------------

DWORD WINAPI
GetGlobalInfo (
    PVOID   OutGlobalInfo,
    PULONG  GlobalInfoSize,
    PULONG  StructureVersion,
    PULONG  StructureSize,
    PULONG  StructureCount
    )
{
    DWORD dwErr, dwSize;
    PIPRIP_GLOBAL_CONFIG pgcsrc, pgcdst;

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


    TRACE2(ENTER, "entering GetGlobalInfo: 0x%08x 0x%08x", OutGlobalInfo, GlobalInfoSize);


    dwErr = NO_ERROR;


    ACQUIRE_GLOBAL_LOCK_SHARED();


    do {


        //
        // check the arguments
        //

        if (GlobalInfoSize == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }


        pgcsrc = ig.IG_Config;
        dwSize = IPRIP_GLOBAL_CONFIG_SIZE(pgcsrc);


        //
        // check the buffer size
        //

        if (*GlobalInfoSize < dwSize || OutGlobalInfo == NULL) {
            dwErr = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
            pgcdst = (PIPRIP_GLOBAL_CONFIG)OutGlobalInfo;

            *StructureVersion    = 1;
            *StructureSize       = dwSize;
            *StructureCount      = 1;

            CopyMemory(pgcdst, pgcsrc, dwSize);
        }

        *GlobalInfoSize = dwSize;

    } while(FALSE);

    RELEASE_GLOBAL_LOCK_SHARED();


    TRACE1(LEAVE, "leaving GetGlobalInfo: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    SetGlobalInfo
//
// Changes IPRIP's global configuration to the supplied values.
//----------------------------------------------------------------------------

DWORD WINAPI
SetGlobalInfo (
    PVOID   GlobalInfo,
    ULONG   StructureVersion,
    ULONG   StructureSize,
    ULONG   StructureCount
    )
{
    DWORD dwErr, dwSize;
    PIPRIP_GLOBAL_CONFIG pgcsrc, pgcdst;

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

    TRACE1(ENTER, "entering SetGlobalInfo: 0x%08x", GlobalInfo);

    dwErr = NO_ERROR;


    ACQUIRE_GLOBAL_LOCK_EXCLUSIVE();


    do {

        //
        // check the argument
        //

        if (GlobalInfo == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }

        pgcsrc = (PIPRIP_GLOBAL_CONFIG)GlobalInfo;


        //
        // find the size of the new global config
        //

        dwSize = IPRIP_GLOBAL_CONFIG_SIZE(pgcsrc);


        //
        // allocate space for the private copy of the config
        //

        pgcdst = (PIPRIP_GLOBAL_CONFIG)RIP_ALLOC(dwSize);

        if (pgcdst == NULL) {

            dwErr = GetLastError();
            TRACE2(
                ANY, "error %d allocating %d bytes for global config",
                dwErr, dwSize
                );
            LOGERR0(HEAP_ALLOC_FAILED, dwErr);

            break;
        }


        //
        // copy from the buffer
        //

        CopyMemory(pgcdst, pgcsrc, dwSize);
        InterlockedExchange(&ig.IG_LogLevel, pgcsrc->GC_LoggingLevel);

        if (ig.IG_Config != NULL) { RIP_FREE(ig.IG_Config); }

        ig.IG_Config = pgcdst;


    } while(FALSE);


    RELEASE_GLOBAL_LOCK_EXCLUSIVE();


    TRACE1(LEAVE, "leaving SetGlobalInfo: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    AddInterface
//
// This function is called to add an interface with the given configuration
// to IPRIP. The interface is created inactive.
//----------------------------------------------------------------------------

DWORD WINAPI
AddInterface (
    PWCHAR              pwszInterfaceName,
    ULONG               InterfaceIndex,
    NET_INTERFACE_TYPE  InterfaceType,
    DWORD               MediaType,
    WORD                AccessType,
    WORD                ConnectionType,
    PVOID               InterfaceInfo,
    ULONG               StructureVersion,
    ULONG               StructureSize,
    ULONG               StructureCount
    )
{
    DWORD dwErr;

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

    TRACE3(
        ENTER, "entering AddInterface: %d %d 0x%08x", InterfaceIndex, InterfaceType, InterfaceInfo
        );



    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = CreateIfEntry(ig.IG_IfTable, InterfaceIndex, InterfaceType, InterfaceInfo, NULL);


    RELEASE_IF_LOCK_EXCLUSIVE();



    TRACE1(LEAVE, "leaving AddInterface: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    DeleteInterface
//
// This removes the interface with the given index, deactivating it if
// necessary.
//----------------------------------------------------------------------------

DWORD
APIENTRY
DeleteInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

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

    TRACE1(ENTER, "entering DeleteInterface: %d", dwIndex);


    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = DeleteIfEntry(ig.IG_IfTable, dwIndex);


    RELEASE_IF_LOCK_EXCLUSIVE();



    TRACE1(LEAVE, "leaving DeleteInterface: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    GetEventMessage
//
// Dequeues a message for Router Manager from IPRIP's event queue.
//----------------------------------------------------------------------------

DWORD
APIENTRY
GetEventMessage(
    OUT ROUTING_PROTOCOL_EVENTS *pEvent,
    OUT PMESSAGE pResult
    ) {

    DWORD dwErr;



    //
    // note that GetEventMessage does not use the
    // ENTER_RIP_API()/LEAVE_RIP_API() mechanism,
    // since it may be called after RIP has stopped, when the
    // Router Manager is retrieving the ROUTER_STOPPED message
    //

    TRACE2(ENTER, "entering GetEventMessage: 0x%08x 0x%08x", pEvent, pResult);


    ACQUIRE_LIST_LOCK(ig.IG_EventQueue);


    dwErr = DequeueEvent(ig.IG_EventQueue, pEvent, pResult);


    RELEASE_LIST_LOCK(ig.IG_EventQueue);



    TRACE1(LEAVE, "leaving GetEventMessage: %d", dwErr);

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    GetInterfaceConfigInfo
//
// Copies to the caller's buffer the configuration for the interface
// with the specified index.
//----------------------------------------------------------------------------

DWORD WINAPI
GetInterfaceConfigInfo (
    ULONG   InterfaceIndex,
    PVOID   OutInterfaceInfo,
    PULONG  InterfaceInfoSize,
    PULONG  StructureVersion,
    PULONG  StructureSize,
    PULONG  StructureCount
    )
{
    DWORD dwErr, dwSize;
    PIF_TABLE pTable;
    PIF_TABLE_ENTRY pite;
    PIPRIP_IF_CONFIG picsrc, picdst;


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

    TRACE3(
        ENTER, "entering GetInterfaceConfigInfo: %d 0x%08x 0x%08x",
        InterfaceIndex,, OutInterfaceInfo, InterfaceInfoSize
        );



    dwErr = NO_ERROR;

    do {

        //
        // check the arguments
        //

        if (InterfaceInfoSize == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }


        pTable = ig.IG_IfTable;


        ACQUIRE_IF_LOCK_SHARED();


        //
        // find the interface specified
        //

        pite = GetIfByIndex(pTable, InterfaceIndex);

        if (pite == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
        }
        else {


            //
            // get the size of the interface config
            //

            picsrc = pite->ITE_Config;
            dwSize = IPRIP_IF_CONFIG_SIZE(picsrc);


            //
            // check the buffer size
            //

            if (*InterfaceInfoSize < dwSize) {
                dwErr = ERROR_INSUFFICIENT_BUFFER;
            }
            else {


                picdst = (PIPRIP_IF_CONFIG)OutInterfaceInfo;


                //
                // copy the interface config, and set the IP address
                //

                CopyMemory(picdst, picsrc, dwSize);


                *StructureVersion    = 1;
                *StructureSize       = dwSize;
                *StructureCount      = 1;

                picdst->IC_State = 0;

                if (IF_IS_ENABLED(pite)) {
                    picdst->IC_State |= IPRIP_STATE_ENABLED;
                }

                if (IF_IS_BOUND(pite)) {
                    picdst->IC_State |= IPRIP_STATE_BOUND;
                }
            }

            *InterfaceInfoSize = dwSize;

        }


        RELEASE_IF_LOCK_SHARED();

    } while(FALSE);



    TRACE1(LEAVE, "leaving GetInterfaceConfigInfo: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    SetInterfaceConfigInfo
//
// This sets the configuration for the interface with the given index.
//----------------------------------------------------------------------------

DWORD WINAPI
SetInterfaceConfigInfo (
    ULONG   InterfaceIndex,
    PVOID   InterfaceInfo,
    ULONG   StructureVersion,
    ULONG   StructureSize,
    ULONG   StructureCount
    )
{
    DWORD dwErr;
    PIF_TABLE pTable;
    PIF_TABLE_ENTRY pite;

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

    TRACE2(
        ENTER, "entering SetInterfaceConfigInfo: %d, 0x%08x", InterfaceIndex, InterfaceInfo
        );



    dwErr = NO_ERROR;

    do {


        if (InterfaceInfo == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }


        pTable = ig.IG_IfTable;

        ACQUIRE_IF_LOCK_EXCLUSIVE();


        dwErr = ConfigureIfEntry(pTable, InterfaceIndex, InterfaceInfo);


        RELEASE_IF_LOCK_EXCLUSIVE();

    } while(FALSE);



    TRACE1(LEAVE, "leaving SetInterfaceConfigInfo: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;

}

DWORD WINAPI
InterfaceStatus(
    ULONG    InterfaceIndex,
    BOOL     InterfaceActive,
    DWORD    StatusType,
    PVOID    StatusInfo
    )
{
    DWORD   dwResult;

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

    switch(StatusType)
    {
        case RIS_INTERFACE_ADDRESS_CHANGE:
        {
            PIP_ADAPTER_BINDING_INFO    pBindInfo;

            pBindInfo = (PIP_ADAPTER_BINDING_INFO)StatusInfo;

            if(pBindInfo->AddressCount)
            {
                dwResult = BindInterface(InterfaceIndex,
                                         pBindInfo);
            }
            else
            {
                dwResult = UnBindInterface(InterfaceIndex);
            }

            break;
        }

        case RIS_INTERFACE_ENABLED:
        {
            dwResult = EnableInterface(InterfaceIndex);

            break;
        }

        case RIS_INTERFACE_DISABLED:
        {
            dwResult = DisableInterface(InterfaceIndex);

            break;

        }

        default:
        {
            RTASSERT(FALSE);

            dwResult = ERROR_INVALID_PARAMETER;
        }
    }

    LEAVE_RIP_API();

    return dwResult;
}



//---------------------------------------------------------------------------
// Function:    BindInterface
//
// This function is called to supply the binding information
// for an interface
//---------------------------------------------------------------------------

DWORD
APIENTRY
BindInterface(
    IN DWORD dwIndex,
    IN PVOID pBinding
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

    TRACE2(ENTER, "entering BindInterface: %d 0x%08x", dwIndex, pBinding);


    if (pBinding == NULL) {

        TRACE0(IF, "error: binding struct pointer is NULL");
        TRACE1(LEAVE, "leaving BindInterface: %d", ERROR_INVALID_PARAMETER);

        return ERROR_INVALID_PARAMETER;
    }



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


    pTable = ig.IG_IfTable;


    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = BindIfEntry(pTable, dwIndex, pBinding);


    RELEASE_IF_LOCK_EXCLUSIVE();



    TRACE1(LEAVE, "leaving BindInterface: %d", dwErr);

    return dwErr;
}




//---------------------------------------------------------------------------
// Function:    UnBindInterface
//
// This function removes the binding for an interface.
//---------------------------------------------------------------------------

DWORD
APIENTRY
UnBindInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;
    PIF_TABLE_ENTRY pite;

    TRACE1(ENTER, "entering UnBindInterface: %d", dwIndex);


    pTable = ig.IG_IfTable;


    //
    // unbind the interface
    //

    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = UnBindIfEntry(pTable, dwIndex);


    RELEASE_IF_LOCK_EXCLUSIVE();


    TRACE1(LEAVE, "leaving UnBindInterface: %d", dwErr);


    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    EnableInterface
//
// This function starts IPRIP activity over the interface with
// the given index, using the given binding information.
//----------------------------------------------------------------------------

DWORD
APIENTRY
EnableInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

    TRACE1(ENTER, "entering EnableInterface: %d", dwIndex);



    pTable = ig.IG_IfTable;


    //
    // activate the interface
    //

    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = EnableIfEntry(pTable, dwIndex);


    RELEASE_IF_LOCK_EXCLUSIVE();



    TRACE1(LEAVE, "leaving EnableInterface: %d", dwErr);

    return dwErr;

}



//----------------------------------------------------------------------------
// Function:    DisableInterface
//
// This function stops IPRIP activity on an interface, also removing
// routes associated with the interface from RTM and purging the network
// of such routes.
//----------------------------------------------------------------------------

DWORD
APIENTRY
DisableInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

    TRACE1(ENTER, "entering DisableInterface: %d", dwIndex);



    pTable = ig.IG_IfTable;


    //
    // stop activity on the interface
    //

    ACQUIRE_IF_LOCK_EXCLUSIVE();


    dwErr = DisableIfEntry(pTable, dwIndex);


    RELEASE_IF_LOCK_EXCLUSIVE();



    TRACE1(LEAVE, "leaving DisableInterface: %d", dwIndex);

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    DoUpdateRoutes
//
// This function begins a demand-update of routes, by queuing a work-item
// which will send out requests on the specified interface.
//----------------------------------------------------------------------------

DWORD
APIENTRY
DoUpdateRoutes(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;

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

    TRACE1(ENTER, "entering DoUpdateRoutes: %d", dwIndex);


    //
    // queue the work-item; perhaps we could call the function directly,
    // but using a worker-thread lets us return to Router Manager right away
    //

    dwErr = QueueRipWorker(
                WorkerFunctionStartDemandUpdate,
                (PVOID)UlongToPtr(dwIndex)
                );


    TRACE1(LEAVE,"leaving DoUpdateRoutes(), errcode %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibCreate
//
// This function does nothing, since IPRIP does not support creation of
// interface objects via SNMP. However, this could be implemented as a call
// to CreateIfEntry() followed by a call to ActivateIfEntry(), and the input
// data would have to contain the interface's index, configuration,
// and binding.
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibCreate(
    IN DWORD dwInputSize,
    IN PVOID pInputData
    ) {

    DWORD dwErr;

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

    TRACE2(ENTER, "entering MibCreate: %d 0x%08x", dwInputSize, pInputData);


    dwErr = ERROR_CAN_NOT_COMPLETE;


    TRACE1(LEAVE, "leaving MibCreate: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    MibDelete
//
// This function does nothing, since IPRIP does not support deletion of
// interface objects via SNMP. This could be implemented as a call to
// DeactivateIfEntry() followed by a call to DeleteIfEntry(), and the
// input data would have to contain the interface's index
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibDelete(
    IN DWORD dwInputSize,
    IN PVOID pInputData
    ) {

    DWORD dwErr;

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

    TRACE2(ENTER, "entering MibDelete: %d 0x%08x", dwInputSize, pInputData);


    dwErr = ERROR_CAN_NOT_COMPLETE;


    TRACE1(LEAVE, "leaving MibDelete: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibSet
//
// The function sets global or interface configuration.
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibSet(
    IN DWORD dwInputSize,
    IN PVOID pInputData
    ) {

    DWORD dwErr;
    PIPRIP_MIB_SET_INPUT_DATA pimsid;

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

    TRACE2(ENTER, "entering MibSet: %d 0x%08x", dwInputSize, pInputData);


    dwErr = NO_ERROR;

    do { // breakout loop

        if (pInputData == NULL) {
            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }

        if (dwInputSize < sizeof(IPRIP_MIB_SET_INPUT_DATA)) {
            dwErr = ERROR_INSUFFICIENT_BUFFER;
            break;
        }


        pimsid = (PIPRIP_MIB_SET_INPUT_DATA)pInputData;

        switch (pimsid->IMSID_TypeID) {

            case IPRIP_GLOBAL_CONFIG_ID: {

                PIPRIP_GLOBAL_CONFIG pigc;


                if (pimsid->IMSID_BufferSize < sizeof(IPRIP_GLOBAL_CONFIG)) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                    break;
                }

                dwErr = SetGlobalInfo(pimsid->IMSID_Buffer,1,0,1);

                if (dwErr == NO_ERROR) {

                    MESSAGE msg = {0, 0, 0};

                    ACQUIRE_LIST_LOCK(ig.IG_EventQueue);
                    EnqueueEvent(
                        ig.IG_EventQueue, SAVE_GLOBAL_CONFIG_INFO, msg
                        );
                    SetEvent(ig.IG_EventEvent);
                    RELEASE_LIST_LOCK(ig.IG_EventQueue);
                }

                break;
            }

            case IPRIP_IF_CONFIG_ID: {

                DWORD dwSize;
                PIF_TABLE pTable;
                PIPRIP_IF_CONFIG pic;
                PIF_TABLE_ENTRY pite;

                if (pimsid->IMSID_BufferSize < sizeof(IPRIP_IF_CONFIG)) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                    break;
                }

                pic = (PIPRIP_IF_CONFIG)pimsid->IMSID_Buffer;


                pTable = ig.IG_IfTable;


                ACQUIRE_IF_LOCK_EXCLUSIVE();


                //
                // retrieve the interface to be configured
                //

                pite = GetIfByIndex(
                            pTable, pimsid->IMSID_IfIndex
                            );
                if (pite == NULL) {
                    dwErr = ERROR_INVALID_PARAMETER;
                }
                else {

                    dwErr = ConfigureIfEntry(pTable, pite->ITE_Index, pic);
                }


                //
                // notify Router Manager
                //

                if (dwErr == NO_ERROR) {

                    MESSAGE msg = {0, 0, 0};

                    msg.InterfaceIndex = pite->ITE_Index;

                    ACQUIRE_LIST_LOCK(ig.IG_EventQueue);
                    EnqueueEvent(
                        ig.IG_EventQueue, SAVE_INTERFACE_CONFIG_INFO, msg
                        );
                    SetEvent(ig.IG_EventEvent);
                    RELEASE_LIST_LOCK(ig.IG_EventQueue);
                }

                RELEASE_IF_LOCK_EXCLUSIVE();


                break;
            }

            default: {
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }

    } while(FALSE);


    TRACE1(LEAVE, "leaving MibSet: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    MibGetInternal
//
// Forward declaration of internal implementation function
//----------------------------------------------------------------------------

DWORD
MibGetInternal(
    PIPRIP_MIB_GET_INPUT_DATA pimgid,
    PIPRIP_MIB_GET_OUTPUT_DATA pimgod,
    PDWORD pdwOutputSize,
    DWORD dwGetMode
    );


//----------------------------------------------------------------------------
// Function:    MibGet
//
// This function retrieves global or interface configuration, as well as
// global stats, interface stats, and peer-router stats.
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibGet(
    IN DWORD dwInputSize,
    IN PVOID pInputData,
    IN OUT PDWORD pdwOutputSize,
    OUT PVOID pOutputData
    ) {

    DWORD dwErr;
    PIPRIP_MIB_GET_INPUT_DATA pimgid;
    PIPRIP_MIB_GET_OUTPUT_DATA pimgod;

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

    TRACE4(
        ENTER, "entering MibGet: %d 0x%08x 0x%08x 0x%08x",
        dwInputSize, pInputData, pdwOutputSize, pOutputData
        );


    if (pInputData == NULL ||
        dwInputSize < sizeof(IPRIP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {

        pimgid = (PIPRIP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPRIP_MIB_GET_OUTPUT_DATA)pOutputData;

        dwErr = MibGetInternal(pimgid, pimgod, pdwOutputSize, GETMODE_EXACT);

    }


    TRACE1(LEAVE, "leaving MibGet: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibGetFirst
//
// This function retrieves global or interface configuration, as well as
// global stats, interface stats, and peer-router stats. It differs from
// MibGet() in that it always returns the FIRST entry in whichever table
// is being queried. There is only one entry in the global stats and config
// tables, but the interface config, interface stats, and peer stats tables
// are sorted by IP address; this function returns the first entry from these.
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibGetFirst(
    IN DWORD dwInputSize,
    IN PVOID pInputData,
    IN OUT PDWORD pdwOutputSize,
    OUT PVOID pOutputData
    ) {

    DWORD dwErr;
    PIPRIP_MIB_GET_INPUT_DATA pimgid;
    PIPRIP_MIB_GET_OUTPUT_DATA pimgod;


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

    TRACE4(
        ENTER, "entering MibGetFirst: %d 0x%08x 0x%08x 0x%08x",
        dwInputSize, pInputData, pdwOutputSize, pOutputData
        );


    if (pInputData == NULL ||
        dwInputSize < sizeof(IPRIP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {
        pimgid = (PIPRIP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPRIP_MIB_GET_OUTPUT_DATA)pOutputData;

        dwErr = MibGetInternal(pimgid, pimgod, pdwOutputSize, GETMODE_FIRST);
    }


    TRACE1(LEAVE, "leaving MibGetFirst: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibGetNext
//
// This function retrieves global or interface configuration, as well as
// global stats, interface stats, and peer-router stats. It differs from both
// MibGet() and MibGetFirst(0 in that it always returns the entry AFTER the
// specified in the specified table. Thus, in the interface config, interface
// stats, and peer stats tables, this function supplies the entry after the
// one with the address passed in.
//
// If the end of the table being queried has been reached, this function will
// return the FIRST entry from the NEXT table, where "NEXT" here means the
// table whose ID is one greater than the ID passed in.
// Thus calling MibGetNext() for the last entry in the interface
// stats table (ID==2) will return the first entry in the interface config
// table (ID==3).
//
// In any case, this function writes the required size to pdwOutputSize and
// writes the ID of the object that WOULD have been returned into the output
// buffer.
//----------------------------------------------------------------------------

DWORD
APIENTRY
MibGetNext(
    IN DWORD dwInputSize,
    IN PVOID pInputData,
    IN OUT PDWORD pdwOutputSize,
    OUT PVOID pOutputData
    ) {

    DWORD dwErr, dwOutSize = 0, dwBufSize = 0;
    PIPRIP_MIB_GET_INPUT_DATA pimgid;
    PIPRIP_MIB_GET_OUTPUT_DATA pimgod;

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

    TRACE4(
        ENTER, "entering MibGetNext: %d 0x%08x 0x%08x 0x%08x",
        dwInputSize, pInputData, pdwOutputSize, pOutputData
        );


    if (pInputData == NULL ||
        dwInputSize < sizeof(IPRIP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {

        pimgid = (PIPRIP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPRIP_MIB_GET_OUTPUT_DATA)pOutputData;

        dwOutSize = *pdwOutputSize;

        dwErr = MibGetInternal(pimgid, pimgod, pdwOutputSize, GETMODE_NEXT);


        if (dwErr == ERROR_NO_MORE_ITEMS) {

            //
            // need to wrap to the first entry in the next table,
            // if there is a next table
            //

            TRACE1(
                CONFIG, "MibGetNext is wrapping to table %d",
                pimgid->IMGID_TypeID + 1
                );

            *pdwOutputSize = dwOutSize;

            //
            // wrap to next table by incrementing the type ID
            //

            ++pimgid->IMGID_TypeID;
            if (pimgid->IMGID_TypeID <= IPRIP_PEER_STATS_ID) {
            
                dwErr = MibGetInternal(
                            pimgid, pimgod, pdwOutputSize, GETMODE_FIRST
                            );
            }
            --pimgid->IMGID_TypeID;
        }
    }


    TRACE1(LEAVE, "leaving MibGetNext: %d", dwErr);

    LEAVE_RIP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibGetInternal
//
// This handles the actual structure access required to read MIB data.
// Each table supported by IPRIP supports three modes of querying;
// EXACT, FIRST, and NEXT, which correspond to the functions MibGet(),
// MibGetFirst(), and MibGetNext() respectively.
//----------------------------------------------------------------------------

DWORD
MibGetInternal(
    PIPRIP_MIB_GET_INPUT_DATA pimgid,
    PIPRIP_MIB_GET_OUTPUT_DATA pimgod,
    PDWORD pdwOutputSize,
    DWORD dwGetMode
    ) {


    DWORD dwErr, dwBufferSize, dwSize;
    ULONG ulVersion, ulSize, ulCount;


    dwErr = NO_ERROR;



    //
    // first we use pdwOutputSize to compute the size of the buffer
    // available for storing returned structures (the size of IMGOD_Buffer)
    //

    if (pimgod == NULL) {
        dwBufferSize = 0;
    }
    else {
        if (*pdwOutputSize < sizeof(IPRIP_MIB_GET_OUTPUT_DATA)) {
            dwBufferSize = 0;
        }
        else {
            dwBufferSize = *pdwOutputSize - sizeof(IPRIP_MIB_GET_OUTPUT_DATA) + 1;
        }
    }

    *pdwOutputSize = 0;


    //
    // determine which type of data is to be returned
    //

    switch (pimgid->IMGID_TypeID) {

        case IPRIP_GLOBAL_STATS_ID: {


            //
            // the global stats structure is constant size.
            // there is only one instance, so if the mode is GETMODE_NEXT
            // we always return ERROR_NO_MORE_ITEMS
            //


            PIPRIP_GLOBAL_STATS pigsdst, pigssrc;


            //
            // set the output size required for this entry,
            // as well as the type of data to be returned
            //

            *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                             sizeof(IPRIP_GLOBAL_STATS);
            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_GLOBAL_STATS_ID; }


            //
            // only GETMODE_EXACT and GETMODE_FIRST are valid for
            // the global stats object, since there is only one entry
            //

            if (dwGetMode == GETMODE_NEXT) {
                dwErr = ERROR_NO_MORE_ITEMS;
                break;
            }


            if (pimgod == NULL) { dwErr = ERROR_INSUFFICIENT_BUFFER; break; }


            //
            // check that the output buffer is big enough
            //

            if (dwBufferSize < sizeof(IPRIP_GLOBAL_STATS)) {
                dwErr = ERROR_INSUFFICIENT_BUFFER;
            }
            else {

                //
                // since access to this structure is not synchronized,
                // we must copy it field by field
                //

                pigssrc = &ig.IG_Stats;
                pigsdst = (PIPRIP_GLOBAL_STATS)pimgod->IMGOD_Buffer;

                pigsdst->GS_SystemRouteChanges = pigssrc->GS_SystemRouteChanges;
                pigsdst->GS_TotalResponsesSent = pigssrc->GS_TotalResponsesSent;
            }


            break;
        }



        case IPRIP_GLOBAL_CONFIG_ID: {

            //
            // the global config struct is variable length,
            // so we wait until it has been retrieved
            // before we set the size.
            // furthermore, there is only one global config object,
            // so GETMODE_NEXT doesn't make any sense
            //

            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_GLOBAL_CONFIG_ID; }

            if (dwGetMode == GETMODE_NEXT) {
                dwErr = ERROR_NO_MORE_ITEMS;
                break;
            }



            //
            // Use GetGlobalInfo to retrieve the global information.
            // It will decide whether the buffer is large enough,
            // and if not will set the required size. Then all we need do
            // is write out the size set by GetGlobalInfo() and
            // relay its return-value to the caller
            //

            if (pimgod == NULL) {
                dwErr = GetGlobalInfo(NULL, &dwBufferSize, &ulVersion, &ulSize, &ulCount);
            }
            else {

                dwErr = GetGlobalInfo(
                            pimgod->IMGOD_Buffer, &dwBufferSize, &ulVersion, &ulSize, &ulCount
                            );
            }

            *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                             dwBufferSize;

            break;
        }



        case IPRIP_IF_STATS_ID: {


            //
            // the interface statistics struct is fixed-length.
            // there may be multiple instances.
            //

            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPRIP_IF_STATS pissrc, pisdst;



            //
            // set the size needed right away
            //

            *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                             sizeof(IPRIP_IF_STATS);
            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_IF_STATS_ID; }


            pTable = ig.IG_IfTable;


            ACQUIRE_IF_LOCK_SHARED();


            //
            // retrieve the interface whose stats are to be read
            //

            pite = GetIfByListIndex(
                        pTable, pimgid->IMGID_IfIndex, dwGetMode, &dwErr
                        );


            //
            // if the interface was not found, it may mean
            // the specified index was invalid, or it may mean
            // that the GETMODE_NEXT was called on the last interface
            // in which case ERROR_NO_MORE_ITEMS was returned.
            // In any case, we make sure dwErr indicates an error
            // and then return the value.
            //
            // if the interface was found but no output buffer was passed,
            // indicate in the error that memory needs to be allocated.
            //
            // otherwise, copy the stats struct of the interface
            //

            if (pite == NULL) {
                if (dwErr == NO_ERROR) { dwErr = ERROR_NOT_FOUND; }
            }
            else
            if (pimgod == NULL) {
                dwErr = ERROR_INSUFFICIENT_BUFFER;
            }
            else {

                //
                // set the index of the interface returned
                //

                pimgod->IMGOD_IfIndex = pite->ITE_Index;


                //
                // if the buffer is large enough, copy over the stats
                //

                if (dwBufferSize < sizeof(IPRIP_IF_STATS)) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                }
                else {

                    //
                    // since access to this structure is not synchronized,
                    // we must copy it field by field
                    //

                    pissrc = &pite->ITE_Stats;
                    pisdst = (PIPRIP_IF_STATS)pimgod->IMGOD_Buffer;

                    pisdst->IS_State = 0;

                    if (IF_IS_ENABLED(pite)) {
                        pisdst->IS_State |= IPRIP_STATE_ENABLED;
                    }

                    if (IF_IS_BOUND(pite)) {
                        pisdst->IS_State |= IPRIP_STATE_BOUND;
                    }


                    pisdst->IS_SendFailures =
                            pissrc->IS_SendFailures;
                    pisdst->IS_ReceiveFailures =
                            pissrc->IS_ReceiveFailures;
                    pisdst->IS_RequestsSent =
                            pissrc->IS_RequestsSent;
                    pisdst->IS_RequestsReceived =
                            pissrc->IS_RequestsReceived;
                    pisdst->IS_ResponsesSent =
                            pissrc->IS_ResponsesSent;
                    pisdst->IS_RequestsReceived =
                            pissrc->IS_RequestsReceived;
                    pisdst->IS_ResponsesReceived =
                            pissrc->IS_ResponsesReceived;
                    pisdst->IS_BadResponsePacketsReceived =
                            pissrc->IS_BadResponsePacketsReceived;
                    pisdst->IS_BadResponseEntriesReceived =
                            pissrc->IS_BadResponseEntriesReceived;
                    pisdst->IS_TriggeredUpdatesSent =
                            pissrc->IS_TriggeredUpdatesSent;
                }
            }

            RELEASE_IF_LOCK_SHARED();


            break;
        }



        case IPRIP_IF_CONFIG_ID: {

            //
            // the interface configuration is variable-length.
            // thus we must actually retrieve the requested interface
            // before we know how large a buffer is needed.
            //

            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPRIP_IF_CONFIG picsrc, picdst;

            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_IF_CONFIG_ID; }

            pTable = ig.IG_IfTable;

            ACQUIRE_IF_LOCK_SHARED();


            //
            // retrieve the interface whose config is to be read
            //

            pite = GetIfByListIndex(
                        pTable, pimgid->IMGID_IfIndex, dwGetMode, &dwErr
                        );


            //
            // if the interface was found, it may mean that the index
            // specified was invalid, or it may mean that a GETMODE_NEXT
            // retrieval was attempted on the last interface, in which case
            // ERROR_NO_MORE_ITEMS would have been returned.
            //

            if (pite == NULL) {
                if (dwErr == NO_ERROR) { dwErr = ERROR_NOT_FOUND; }
            }
            else {

                //
                // compute the size of the interface config retrieved,
                // and write it over the caller's supplied size
                //

                picsrc = pite->ITE_Config;
                dwSize = IPRIP_IF_CONFIG_SIZE(picsrc);
                *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                                 dwSize;


                //
                // if no buffer was specified, indicate one should be allocated
                //

                if (pimgod == NULL) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                }
                else {


                    //
                    // if the buffer is not large enough,
                    // indicate that it should be enlarged
                    //

                    if (dwBufferSize < dwSize) {
                        dwErr = ERROR_INSUFFICIENT_BUFFER;
                    }
                    else {

                        //
                        // copy the configuration
                        //

                        picdst = (PIPRIP_IF_CONFIG)pimgod->IMGOD_Buffer;

                        CopyMemory(picdst, picsrc, dwSize);
                        ZeroMemory(
                            picdst->IC_AuthenticationKey, IPRIP_MAX_AUTHKEY_SIZE
                            );

                        picdst->IC_State = 0;

                        if (IF_IS_ENABLED(pite)) {
                            picdst->IC_State |= IPRIP_STATE_ENABLED;
                        }

                        if (IF_IS_BOUND(pite)) {
                            picdst->IC_State |= IPRIP_STATE_BOUND;
                        }
                    }


                    pimgod->IMGOD_IfIndex = pite->ITE_Index;
                }
            }

            RELEASE_IF_LOCK_SHARED();

            break;
        }



        case IPRIP_IF_BINDING_ID: {

            //
            // the interface binding is variable-length
            // thus we must actually retrieve the requested interface
            // before we know how large a buffer is needed.
            //

            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPRIP_IF_BINDING pibsrc, pibdst;

            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_IF_BINDING_ID; }

            pTable = ig.IG_IfTable;

            ACQUIRE_IF_LOCK_SHARED();

            //
            // retrieve the interface whose binding is to be read
            //

            pite = GetIfByListIndex(
                        pTable, pimgid->IMGID_IfIndex, dwGetMode, &dwErr
                        );


            //
            // if the interface was found, it may mean that the index
            // specified was invalid, or it may mean that a GETMODE_NEXT
            // retrieval was attempted on the last interface, in which case
            // ERROR_NO_MORE_ITEMS would have been returned.
            //

            if (pite == NULL) {
                if (dwErr == NO_ERROR) { dwErr = ERROR_NOT_FOUND; }
            }
            else {

                //
                // compute the size of the interface binding retrieved,
                // and write it over the caller's supplied size
                //

                pibsrc = pite->ITE_Binding;
                dwSize = (pibsrc ? IPRIP_IF_BINDING_SIZE(pibsrc)
                                 : sizeof(IPRIP_IF_BINDING));
                *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                                 dwSize;


                //
                // if no buffer was specified, indicate one should be allocated
                //

                if (pimgod == NULL) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                }
                else {


                    //
                    // if the buffer is not large enough,
                    // indicate that it should be enlarged
                    //

                    if (dwBufferSize < dwSize) {
                        dwErr = ERROR_INSUFFICIENT_BUFFER;
                    }
                    else {

                        //
                        // copy the binding
                        //

                        pibdst = (PIPRIP_IF_BINDING)pimgod->IMGOD_Buffer;

                        if (pibsrc) { CopyMemory(pibdst, pibsrc, dwSize); }
                        else { pibdst->IB_AddrCount = 0; }

                        pibdst->IB_State = 0;

                        if (IF_IS_ENABLED(pite)) {
                            pibdst->IB_State |= IPRIP_STATE_ENABLED;
                        }

                        if (IF_IS_BOUND(pite)) {
                            pibdst->IB_State |= IPRIP_STATE_BOUND;
                        }
                    }


                    pimgod->IMGOD_IfIndex = pite->ITE_Index;
                }
            }

            RELEASE_IF_LOCK_SHARED();

            break;
        }

        case IPRIP_PEER_STATS_ID: {


            //
            // the peer statistics struct is fixed-length.
            //

            DWORD dwAddress;
            PPEER_TABLE pTable;
            PPEER_TABLE_ENTRY ppte;
            PIPRIP_PEER_STATS ppssrc, ppsdst;


            //
            // set the output size right away
            //

            *pdwOutputSize = sizeof(IPRIP_MIB_GET_OUTPUT_DATA) - 1 +
                             sizeof(IPRIP_PEER_STATS);
            if (pimgod) { pimgod->IMGOD_TypeID = IPRIP_PEER_STATS_ID; }


            pTable = ig.IG_PeerTable;
            dwAddress = pimgid->IMGID_PeerAddress;


            ACQUIRE_PEER_LOCK_SHARED();


            //
            // retrieve the peer specified
            //

            ppte = GetPeerByAddress(pTable, dwAddress, dwGetMode, &dwErr);



            //
            // if no struct was returned, it means that either
            // an invalid address was specifed, or GETMODE_NExT
            // was attempted on the last peer.
            // In either case, we return an error code.
            //
            // if no buffer was specifed, return ERROR_INSUFFICIENT_BUFFER
            // to indicate to the caller that a buffer should be allocated
            //

            if (ppte == NULL) {
                if (dwErr == NO_ERROR) { dwErr = ERROR_NOT_FOUND; }
            }
            else
            if (pimgod == NULL) {
                dwErr = ERROR_INSUFFICIENT_BUFFER;
            }
            else {

                //
                // save the address of the peer retrieved
                //

                pimgod->IMGOD_PeerAddress = ppte->PTE_Address;


                //
                // if the buffer is not large enough,
                // return an error to indicate it should be enlarged
                //

                if (dwBufferSize < sizeof(IPRIP_PEER_STATS)) {
                    dwErr = ERROR_INSUFFICIENT_BUFFER;
                }
                else {

                    //
                    // since access to this structure is not synchronized,
                    // we must copy it field by field
                    //

                    ppssrc = &ppte->PTE_Stats;
                    ppsdst = (PIPRIP_PEER_STATS)pimgod->IMGOD_Buffer;

                    ppsdst->PS_LastPeerRouteTag =
                            ppssrc->PS_LastPeerRouteTag;
                    ppsdst->PS_LastPeerUpdateTickCount =
                            ppssrc->PS_LastPeerUpdateTickCount;
                    ppsdst->PS_LastPeerUpdateVersion =
                            ppssrc->PS_LastPeerUpdateVersion;
                    ppsdst->PS_BadResponsePacketsFromPeer =
                            ppssrc->PS_BadResponsePacketsFromPeer;
                    ppsdst->PS_BadResponseEntriesFromPeer =
                            ppssrc->PS_BadResponseEntriesFromPeer;
                }
            }

            RELEASE_PEER_LOCK_SHARED();


            break;

        }

        default: {
            dwErr = ERROR_INVALID_PARAMETER;
        }
    }

    return dwErr;
}