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

//============================================================================
// Copyright (c) 1995, Microsoft Corporation
//
// File:    api.c
//
// History:
//      Abolade Gbadegesin  August 31, 1995     Created
//
// BOOTP Relay Agent's interface to Router Manager
//============================================================================

#include "pchbootp.h"


IPBOOTP_GLOBALS ig;


DWORD
MibGetInternal(
    PIPBOOTP_MIB_GET_INPUT_DATA pimgid,
    PIPBOOTP_MIB_GET_OUTPUT_DATA pimgod,
    PDWORD pdwOutputSize,
    DWORD dwGetMode
    );

BOOL
DllStartup(
    );

BOOL
DllCleanup(
    );

DWORD
ProtocolStartup(
    HANDLE hEventEvent,
    PSUPPORT_FUNCTIONS pFunctionTable,
    PVOID pConfig
    );

DWORD
ProtocolCleanup(
    BOOL bCleanupWinsock
    );

DWORD
BindInterface(
    IN DWORD dwIndex,
    IN PVOID pBinding
    );

DWORD
UnBindInterface(
    IN DWORD dwIndex
    );

DWORD
EnableInterface(
    IN DWORD dwIndex
    );

DWORD
DisableInterface(
    IN DWORD dwIndex
    );


//----------------------------------------------------------------------------
// Function:    DLLMAIN
//
// This is the entry-point for IPBOOTP.DLL.
//----------------------------------------------------------------------------

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
//
// This function initializes IPBOOTP's global structure
// in preparation for calls to the API functions exported.
// It creates the global critical section, heap, and router-manager
// event message queue.
//----------------------------------------------------------------------------

BOOL
DllStartup(
    ) {

    BOOL bErr;
    DWORD dwErr;


    bErr = FALSE;


    do {

        ZeroMemory(&ig, sizeof(IPBOOTP_GLOBALS));


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

            dwErr = GetExceptionCode();
            break;
        }


        ig.IG_Status = IPBOOTP_STATUS_STOPPED;


        //
        // create the global heap for BOOTP
        //

        ig.IG_GlobalHeap = HeapCreate(0, 0, 0);
        if (ig.IG_GlobalHeap == NULL) {

            dwErr = GetLastError();
            break;
        }


        //
        // allocate space for the Router manager event queue
        //

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

        if (ig.IG_EventQueue == NULL) {

            dwErr = GetLastError();
            break;
        }


        //
        // now initialize the locked-list allocated
        //

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

            dwErr = GetExceptionCode();
            break;
        }


        bErr = TRUE;

    } while(FALSE);

    if (!bErr) {
        DllCleanup();
    }

    return bErr;
}



//----------------------------------------------------------------------------
// Function:    DllCleanup
//
// This function is called when the IPBOOTP DLL is being unloaded.
// It releases the resources allocated in DllStartup.
//----------------------------------------------------------------------------

BOOL
DllCleanup(
    ) {

    BOOL bErr;


    bErr = TRUE;

    do {


        //
        // delete and deallocate the event message queue
        //

        if (ig.IG_EventQueue != NULL) {

            if (LOCKED_LIST_CREATED(ig.IG_EventQueue)) {
                DELETE_LOCKED_LIST(ig.IG_EventQueue);
            }

            BOOTP_FREE(ig.IG_EventQueue);
        }



        //
        // destroy the global heap
        //

        if (ig.IG_GlobalHeap != NULL) {

            HeapDestroy(ig.IG_GlobalHeap);
        }


        //
        // delete the global critical section
        //

        DeleteCriticalSection(&ig.IG_CS);


        if (ig.IG_LoggingHandle != NULL)
            RouterLogDeregister(ig.IG_LoggingHandle);
        if (ig.IG_TraceID != INVALID_TRACEID) {
            TraceDeregister(ig.IG_TraceID);
        }

    } while(FALSE);


    return bErr;
}



//----------------------------------------------------------------------------
// Function:    ProtocolStartup
//
// This function is called by the router manager to start IPBOOTP.
// It sets up the data structures needed and starts the input thread.
//----------------------------------------------------------------------------

DWORD
ProtocolStartup(
    HANDLE hEventEvent,
    PSUPPORT_FUNCTIONS pFunctionTable,
    PVOID pConfig
    ) {

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


    ig.IG_TraceID = TraceRegister("IPBOOTP");
    ig.IG_LoggingHandle = RouterLogRegister("IPBOOTP");


    //
    // acquire the global critical section
    // while we look at the status code
    //

    EnterCriticalSection(&ig.IG_CS);


    //
    // make sure that BOOTP has not already started up
    //

    if (ig.IG_Status != IPBOOTP_STATUS_STOPPED) {

        TRACE0(START, "StartProtocol() has already been called");
        LOGWARN0(ALREADY_STARTED, 0);

        LeaveCriticalSection(&ig.IG_CS);

        return ERROR_CAN_NOT_COMPLETE;
    }


    //
    // initialize the global structures:
    //


    bCleanupWinsock = FALSE;


    do { // error break-out loop


        TRACE0(START, "IPBOOTP is starting up...");



        //
        // copy the global configuration passed in:
        // find its size, and the allocate space for the copy
        //

        pgcsrc = (PIPBOOTP_GLOBAL_CONFIG)pConfig;
        dwSize = GC_SIZEOF(pgcsrc);

        pgcdst = BOOTP_ALLOC(dwSize);

        if (pgcdst == NULL) {

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

            break;
        }


        RtlCopyMemory(pgcdst, pgcsrc, dwSize);

        ig.IG_Config = pgcdst;
        ig.IG_LoggingLevel = pgcdst->GC_LoggingLevel;



        //
        // initialize Windows Sockets
        //

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

        if (dwErr != NO_ERROR) {

            TRACE1(START, "error %d initializing Windows Sockets", dwErr);
            LOGERR0(INIT_WINSOCK_FAILED, dwErr);

            break;
        }


        bCleanupWinsock = TRUE;


        //
        // create the global structure lock
        //

        try {
            CREATE_READ_WRITE_LOCK(&ig.IG_RWL);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {

            dwErr = GetExceptionCode();
            TRACE1(START, "error %d creating synchronization object", dwErr);
            LOGERR0(CREATE_RWL_FAILED, dwErr);

            break;
        }


        //
        // initialize the interface table
        //

        ig.IG_IfTable = BOOTP_ALLOC(sizeof(IF_TABLE));

        if (ig.IG_IfTable == NULL) {

            dwErr = GetLastError();
            TRACE2(
                START, "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 the receive queue
        //

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

        if (ig.IG_RecvQueue == NULL) {

            dwErr = GetLastError();
            TRACE2(
                START, "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 locked list", dwErr);
            LOGERR0(INIT_CRITSEC_FAILED, dwErr);

            break;
        }


        //
        // copy the support-function table and Router Manager event
        //

        ig.IG_FunctionTable = pFunctionTable;

        ig.IG_EventEvent = hEventEvent;



        //
        // initialize count of active threads, and create the semaphore
        // signalled by threads exiting API functions and work functions
        //

        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", dwErr);
            LOGERR0(CREATE_SEMAPHORE_FAILED, dwErr);

            break;
        }



        //
        // create the event used to signal on incoming packets
        //

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

        if (ig.IG_InputEvent == NULL) {

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

            break;
        }


        //
        // register the InputEvent with the NtdllWait thread
        //

         
        if (! RegisterWaitForSingleObject(
                  &ig.IG_InputEventHandle,
                  ig.IG_InputEvent,
                  CallbackFunctionNetworkEvents,
                  NULL,      //null context
                  INFINITE,  //no timeout
                  (WT_EXECUTEINWAITTHREAD|WT_EXECUTEONLYONCE)
                  )) {

            dwErr = GetLastError();
            TRACE1(
                START, "error %d returned by RegisterWaitForSingleObjectEx",
                dwErr
                );
            LOGERR0(REGISTER_WAIT_FAILED, dwErr);
            break;

        }



        //
        // now set the status to running
        //

        ig.IG_Status = IPBOOTP_STATUS_RUNNING;


#if DBG

        //
        // register a timer queue with the NtdllTimer thread
        //
        ig.IG_TimerQueueHandle = CreateTimerQueue();

        if (!ig.IG_TimerQueueHandle) {

            dwErr = GetLastError();
            TRACE1(START, "error %d returned by CreateTimerQueue()", dwErr);
            LOGERR0(CREATE_TIMER_QUEUE_FAILED, dwErr);

            break;
        }



        //
        // set timer with NtdllTimer thread to display IPBOOTP MIB periodically
        //

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

        if (ig.IG_MibTraceID != INVALID_TRACEID) {

             
            if (! CreateTimerQueueTimer(
                      &ig.IG_MibTimerHandle,
                      ig.IG_TimerQueueHandle,
                      CallbackFunctionMibDisplay,
                      NULL,           // null context
                      10000,          // display after 10 seconds
                      10000,          // display every 10 seconds
                      0               // execute in timer thread
                      )) {

                dwErr = GetLastError();
                TRACE1(
                    START, "error %d returned by CreateTimerQueueTimer()",
                    dwErr
                    );
                break;
            }
        }

#endif


        TRACE0(START, "IP BOOTP started successfully");

        LOGINFO0(STARTED, 0);


        LeaveCriticalSection(&ig.IG_CS);

        return NO_ERROR;

    } while(FALSE);


    //
    // an error occurred if control-flow brings us here
    //

    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 cleans up resources used by IPBOOTP while it is
// in operation. Essentially, everything created in ProtocolStartup
// is cleaned up by the function.
//----------------------------------------------------------------------------

DWORD
ProtocolCleanup(
    BOOL bCleanupWinsock
    ) {

    DWORD dwErr;


    //
    // lock things down while we clean up
    //

    EnterCriticalSection(&ig.IG_CS);

#if DBG

    TraceDeregister(ig.IG_MibTraceID);

#endif


    if (ig.IG_InputEvent != NULL) {

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


    if (ig.IG_ActivitySemaphore != NULL) {

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


    if (ig.IG_RecvQueue != NULL) {

        if (LOCKED_LIST_CREATED(ig.IG_RecvQueue)) {
            DELETE_LOCKED_LIST(ig.IG_RecvQueue);
        }

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


    if (ig.IG_IfTable != NULL) {

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

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


    if (READ_WRITE_LOCK_CREATED(&ig.IG_RWL)) {

        try {
            DELETE_READ_WRITE_LOCK(&ig.IG_RWL);
        }
        except (EXCEPTION_EXECUTE_HANDLER) {
            dwErr = GetExceptionCode();
        }
    }


    if (bCleanupWinsock) {
        WSACleanup();
    }


    if (ig.IG_Config != NULL) {

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


    ig.IG_Status = IPBOOTP_STATUS_STOPPED;

    LeaveCriticalSection(&ig.IG_CS);

    return NO_ERROR;
}



//----------------------------------------------------------------------------
// Function:    RegisterProtocol
//
// This function is called by the router manager
// to retrieve information about IPBOOTP's capabilities
//----------------------------------------------------------------------------

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

    pServiceChar->fSupportedFunctionality = 0;

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

    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       = NULL;

    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
//
// This function is called by the router manager
// to start IPBOOTP.
//----------------------------------------------------------------------------

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



//----------------------------------------------------------------------------
// Function:    StartComplete
//
// This function is called by the router manager
// to start IPBOOTP.
//----------------------------------------------------------------------------

DWORD
WINAPI
StartComplete (
    VOID
    )
{
    return NO_ERROR;
}




//----------------------------------------------------------------------------
// Function:    StopProtocol
//
// This function notifies all active threads to stop, and frees resources
// used by IP BOOTP
//----------------------------------------------------------------------------

DWORD
APIENTRY
StopProtocol(
    VOID
    ) {


    DWORD dwErr;
    LONG lThreadCount;
    HANDLE WaitHandle;
    

    //
    // make sure IPBOOTP has not already stopped
    //

    EnterCriticalSection(&ig.IG_CS);

    if (ig.IG_Status != IPBOOTP_STATUS_RUNNING) {

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


    TRACE0(ENTER, "entering StopProtocol");



    //
    // update the status to prevent any APIs or worker-functions from running
    //

    ig.IG_Status = IPBOOTP_STATUS_STOPPING;



    //
    // see how many threads are already in API calls
    // or in worker-function code
    //

    lThreadCount = ig.IG_ActivityCount;

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



    LeaveCriticalSection(&ig.IG_CS);



    //
    // wait for active threads to stop
    //

    while (lThreadCount-- > 0) {
        WaitForSingleObject(ig.IG_ActivitySemaphore, INFINITE);
    }


    //
    // deregister the mib timer from the Ntdll threads
    // This has to be done outside IG_CS lock.
    //

#if DBG
    DeleteTimerQueueEx(ig.IG_TimerQueueHandle, INVALID_HANDLE_VALUE);
#endif

    //
    // set the handle to NULL, so that Unregister wont be called
    //

    WaitHandle = InterlockedExchangePointer(&ig.IG_InputEventHandle, NULL);
        
    if (WaitHandle) {
        UnregisterWaitEx( WaitHandle, INVALID_HANDLE_VALUE ) ;
    }



    //
    // enter the critical section and leave,
    // to make certain all the threads have returned from LeaveBootpWorker
    //

    EnterCriticalSection(&ig.IG_CS);
    LeaveCriticalSection(&ig.IG_CS);


    //
    // now all threads have stopped
    //

    TRACE0(STOP, "all threads stopped, BOOTP is cleaning up resources");

    LOGINFO0(STOPPED, 0);


    ProtocolCleanup(TRUE);

    return NO_ERROR;
}





//----------------------------------------------------------------------------
// Function:    GetGlobalInfo
//
// Copies BOOTP's global config into the buffer provided.
//----------------------------------------------------------------------------

DWORD WINAPI
GetGlobalInfo (
    PVOID   OutGlobalInfo,
    PULONG  GlobalInfoSize,
    PULONG  StructureVersion,
    PULONG  StructureSize,
    PULONG  StructureCount
    )
{
    DWORD dwErr = NO_ERROR, dwSize;

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

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


    //
    // in order to do anything, we need a valid size pointer
    //

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

        //
        // check the size of the config block passed in
        // and copy the config if the buffer is large enough
        //

        ACQUIRE_READ_LOCK(&ig.IG_RWL);

        dwSize = GC_SIZEOF(ig.IG_Config);
        if (*GlobalInfoSize < dwSize) {
            dwErr = ERROR_INSUFFICIENT_BUFFER;
        }
        else
        if (OutGlobalInfo != NULL) {

            RtlCopyMemory(
                OutGlobalInfo,
                ig.IG_Config,
                dwSize
                );
        }

        *GlobalInfoSize = dwSize;

        if (StructureSize) *StructureSize = *GlobalInfoSize;
        if (StructureCount) *StructureCount = 1;
        if (StructureVersion) *StructureVersion = BOOTP_CONFIG_VERSION_500;
        
        RELEASE_READ_LOCK(&ig.IG_RWL);
    }

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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    SetGlobalInfo
//
// Copies over the specified configuration .
//----------------------------------------------------------------------------

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

    if (!GlobalInfo || !ENTER_BOOTP_API()) { return ERROR_CAN_NOT_COMPLETE; }

    TRACE1(ENTER, "entering SetGlobalInfo: %p", GlobalInfo);


    ACQUIRE_WRITE_LOCK(&ig.IG_RWL);

    pgcsrc = (PIPBOOTP_GLOBAL_CONFIG)GlobalInfo;
    dwSize = GC_SIZEOF(pgcsrc);


    //
    // allocate memory for the new config block, and copy it over
    //

    pgcdst = BOOTP_ALLOC(dwSize);

    if (pgcdst == NULL) {

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

        RtlCopyMemory(
            pgcdst,
            pgcsrc,
            dwSize
            );

        BOOTP_FREE(ig.IG_Config);
        ig.IG_Config = pgcdst;

        dwErr = NO_ERROR;
    }

    RELEASE_WRITE_LOCK(&ig.IG_RWL);


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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    AddInterface
//
// Adds an interface with the specified index and configuration.
//----------------------------------------------------------------------------

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;
    PIF_TABLE pTable;

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

    TRACE3(
        ENTER, "entering AddInterface: %d %d %p",
        InterfaceIndex, InterfaceType, InterfaceInfo
        );


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = CreateIfEntry(pTable, InterfaceIndex, InterfaceInfo);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    LEAVE_BOOTP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    DeleteInterface
//
// Removes the interface with the specified index.
//----------------------------------------------------------------------------
DWORD
APIENTRY
DeleteInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

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

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


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = DeleteIfEntry(pTable, dwIndex);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    GetEventMessage
//
// Returns the first event in the ROuter Manager event queue, if any.
//----------------------------------------------------------------------------
DWORD
APIENTRY
GetEventMessage(
    OUT ROUTING_PROTOCOL_EVENTS *pEvent,
    OUT MESSAGE *pResult
    ) {

    DWORD dwErr;
    PLOCKED_LIST pll;

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

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


    pll = ig.IG_EventQueue;

    ACQUIRE_LIST_LOCK(pll);

    dwErr = DequeueEvent(pll, pEvent, pResult);

    RELEASE_LIST_LOCK(pll);


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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    GetInterfaceConfigInfo
//
// Returns the configuration for the specified interface.
//----------------------------------------------------------------------------

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

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

    TRACE3(
        ENTER, "entering GetInterfaceConfigInfo: %d %p %p",
        InterfaceIndex, InterfaceInfoSize, OutInterfaceInfo
        );


    //
    // in order to do anything, we need a valid size pointer
    //

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

        pTable = ig.IG_IfTable;

        ACQUIRE_READ_LOCK(&pTable->IT_RWL);


        //
        // retrieve the interface to be re-configured
        //

        pite = GetIfByIndex(pTable, InterfaceIndex);

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


            //
            // compute the interface configuration's size,
            // and copy the config to the caller's buffer
            // if the caller's buffer is large enough
            //

            dwSize = IC_SIZEOF(pite->ITE_Config);

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

                PIPBOOTP_IF_CONFIG picdst = OutInterfaceInfo;

                CopyMemory(picdst, pite->ITE_Config, dwSize);

                picdst->IC_State = 0;

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

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

                dwErr = NO_ERROR;
            }


            *InterfaceInfoSize = dwSize;
            
            if (StructureSize) *StructureSize = *InterfaceInfoSize;
            if (StructureCount) *StructureCount = 1;
            if (StructureVersion) *StructureVersion = BOOTP_CONFIG_VERSION_500;
        
        }

        RELEASE_READ_LOCK(&pTable->IT_RWL);
    }



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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    SetInterfaceConfigInfo
//
// Copies over the specified interface configuration.
//----------------------------------------------------------------------------

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

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

    TRACE2(
        ENTER, "entering SetInterfaceConfigInfo: %d %p", InterfaceIndex, InterfaceInfo
        );


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = ConfigureIfEntry(pTable, InterfaceIndex, InterfaceInfo);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    LEAVE_BOOTP_API();

    return dwErr;
}


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

    if (!ENTER_BOOTP_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_BOOTP_API();

    return dwResult;
}



//----------------------------------------------------------------------------
// Function:    BindInterface
//
// Sets the IP address and network mask for the specified interface.
//----------------------------------------------------------------------------

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

    DWORD dwErr;
    PIF_TABLE pTable;


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


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = BindIfEntry(pTable, dwIndex, pBinding);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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


    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    UnBindInterface
//
// Removes the IP address associated with the specified interface
//----------------------------------------------------------------------------

DWORD
APIENTRY
UnBindInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;


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


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = UnBindIfEntry(pTable, dwIndex);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    EnableInterface
//
//----------------------------------------------------------------------------

DWORD
APIENTRY
EnableInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;

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


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = EnableIfEntry(pTable, dwIndex);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    DisableInterface
//
//----------------------------------------------------------------------------

DWORD
APIENTRY
DisableInterface(
    IN DWORD dwIndex
    ) {

    DWORD dwErr;
    PIF_TABLE pTable;
    PIF_TABLE_ENTRY pite;

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


    pTable = ig.IG_IfTable;

    ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


    dwErr = DisableIfEntry(pTable, dwIndex);


    RELEASE_WRITE_LOCK(&pTable->IT_RWL);


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

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    DoUpdateRoutes
//
// This API is unsupported since BOOTP is not a routing protocol.
//----------------------------------------------------------------------------

DWORD
APIENTRY
DoUpdateRoutes(
    IN DWORD dwIndex
    ) {

    return ERROR_CAN_NOT_COMPLETE;
}



//----------------------------------------------------------------------------
// Function:    MibCreate
//
// BOOTP does not have create-able MIB fields.
//----------------------------------------------------------------------------

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

    return ERROR_CAN_NOT_COMPLETE;
}



//----------------------------------------------------------------------------
// Function:    MibDelete
//
// BOOTP does not have delete-able MIB fields
//----------------------------------------------------------------------------

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

    return ERROR_CAN_NOT_COMPLETE;
}



//----------------------------------------------------------------------------
// Function:    MibSet
//
// This is called to modify writable MIB variables.
// The writable entries are the global config and interface config.
//----------------------------------------------------------------------------

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

    DWORD dwErr;
    PIPBOOTP_MIB_SET_INPUT_DATA pimsid;

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

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


    dwErr = NO_ERROR;

    do { // breakout loop


        //
        // make certain the parameters are acceptable
        //

        if (pInputData == NULL ||
            dwInputSize < sizeof(IPBOOTP_MIB_SET_INPUT_DATA)) {

            dwErr = ERROR_INVALID_PARAMETER;
            break;
        }


        //
        // see which entry type is to be set
        //

        pimsid = (PIPBOOTP_MIB_SET_INPUT_DATA)pInputData;

        switch(pimsid->IMSID_TypeID) {


            case IPBOOTP_GLOBAL_CONFIG_ID: {

                PIPBOOTP_GLOBAL_CONFIG pigc;


                //
                // make sure the buffer is big enough
                // to hold a global config block
                //

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


                //
                // call the router manager API to set the config
                //

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

                if (dwErr == NO_ERROR) {

                    //
                    // the set succeeded, so notify the router manager
                    // that the global config has changed and should be saved
                    //

                    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 IPBOOTP_IF_CONFIG_ID: {

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


                //
                // make sure the buffer is big enough
                // to hold an interface config block
                //

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


                pic = (PIPBOOTP_IF_CONFIG)pimsid->IMSID_Buffer;

                pTable = ig.IG_IfTable;


                ACQUIRE_WRITE_LOCK(&pTable->IT_RWL);


                //
                // find the interface and update its config
                //

                pite = GetIfByIndex(
                            pTable,
                            pimsid->IMSID_IfIndex
                            );

                if (pite == NULL) {

                    TRACE1(
                        CONFIG, "MibSet: could not find interface %d",
                        pimsid->IMSID_IfIndex
                        );

                    dwErr = ERROR_INVALID_PARAMETER;
                }
                else {

                    //
                    // configure the interface
                    //

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


                if (dwErr == NO_ERROR) {

                    //
                    // notify Router manager that config has changed
                    //

                    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_WRITE_LOCK(&pTable->IT_RWL);

                break;
            }
            default: {
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
    } while(FALSE);

    LEAVE_BOOTP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    MibGet
//
// This function retrieves a MIB entry.
//----------------------------------------------------------------------------

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

    DWORD dwErr;
    PIPBOOTP_MIB_GET_INPUT_DATA pimgid;
    PIPBOOTP_MIB_GET_OUTPUT_DATA pimgod;

    if (!ENTER_BOOTP_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(IPBOOTP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {

        //
        // invoke the internal function for retrieving the MIB
        //

        pimgid = (PIPBOOTP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPBOOTP_MIB_GET_OUTPUT_DATA)pOutputData;

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


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

    LEAVE_BOOTP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    MibGetFirst
//
// This function retrieve a MIB entry from one of the MIB tables,
// but it differs from MibGet in that it always returns the first entry
// in the table specified.
//----------------------------------------------------------------------------
DWORD
APIENTRY
MibGetFirst(
    IN DWORD dwInputSize,
    IN PVOID pInputData,
    IN OUT PDWORD pdwOutputSize,
    OUT PVOID pOutputData
    ) {

    DWORD dwErr;
    PIPBOOTP_MIB_GET_INPUT_DATA pimgid;
    PIPBOOTP_MIB_GET_OUTPUT_DATA pimgod;

    if (!ENTER_BOOTP_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(IPBOOTP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {

        pimgid = (PIPBOOTP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPBOOTP_MIB_GET_OUTPUT_DATA)pOutputData;

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


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

    LEAVE_BOOTP_API();

    return dwErr;
}



//----------------------------------------------------------------------------
// Function:    MibGetNext
//
// This function retrieves a MIB entry from one of the MIB tables.
// It differs from MibGet() and MibGetFirst() in that the input
// specifies the index of a MIB entry, and this entry returns the MIB entry
// which is AFTER the entry whose index is specified.
//
// If the index specified is that of the last entry in the specified table,
// this function wraps to the FIRST entry in 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
// will return the first entry in the interface config table.
//----------------------------------------------------------------------------

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

    DWORD dwErr, dwOutSize = 0, dwBufSize = 0;
    PIPBOOTP_MIB_GET_INPUT_DATA pimgid;
    PIPBOOTP_MIB_GET_OUTPUT_DATA pimgod;

    if (!ENTER_BOOTP_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(IPBOOTP_MIB_GET_INPUT_DATA) ||
        pdwOutputSize == NULL) {
        dwErr = ERROR_INVALID_PARAMETER;
    }
    else {

        pimgid = (PIPBOOTP_MIB_GET_INPUT_DATA)pInputData;
        pimgod = (PIPBOOTP_MIB_GET_OUTPUT_DATA)pOutputData;

        dwOutSize = *pdwOutputSize;

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

        if (dwErr == ERROR_NO_MORE_ITEMS) {

            //
            // wrap to the first entry in the next table
            //

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


            //
            // restore the size passed in
            //

            *pdwOutputSize = dwOutSize;


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

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

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

    LEAVE_BOOTP_API();

    return dwErr;
}




//----------------------------------------------------------------------------
// Function:    MibGetInternal
//
// This function handles the structure queries necessary to read MIB data.
// Each table exposed by IPBOOTP supports three types of queries:
// EXACT, FIRST, and NEXT, which correspond to the functions MibGet(),
// MibGetFirst(), and MibGetNext() respectively.
//----------------------------------------------------------------------------

DWORD
MibGetInternal(
    PIPBOOTP_MIB_GET_INPUT_DATA pimgid,
    PIPBOOTP_MIB_GET_OUTPUT_DATA pimgod,
    PDWORD pdwOutputSize,
    DWORD dwGetMode
    ) {

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

    dwErr = NO_ERROR;


    //
    // first we use pdwOutputSize  to compute the size of the buffer
    // available (i.e. the size of IMGOD_Buffer
    //

    if (pimgod == NULL ||
        *pdwOutputSize < sizeof(IPBOOTP_MIB_GET_OUTPUT_DATA)) {
        dwBufSize = 0;
    }
    else {
        dwBufSize = *pdwOutputSize - sizeof(IPBOOTP_MIB_GET_OUTPUT_DATA) + 1;
    }

    *pdwOutputSize = 0;


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

    switch (pimgid->IMGID_TypeID) {

        case IPBOOTP_GLOBAL_CONFIG_ID: {

            //
            // the global config struct is variable-length,
            // so we wait until it has been retrieved before setting the size;
            // GETMODE_NEXT is invalid since there is only one global config
            //

            if (pimgod) { pimgod->IMGOD_TypeID = IPBOOTP_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 it will set the required size. Then all we need to do
            // is write out the size set by GetGlobalInfo.
            //

            if (pimgod == NULL) {
                dwErr = GetGlobalInfo(NULL, &dwBufSize, NULL, NULL, NULL);
            }
            else {

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

            *pdwOutputSize = sizeof(IPBOOTP_MIB_GET_OUTPUT_DATA) - 1 +
                             dwBufSize;

            break;
        }


        case IPBOOTP_IF_STATS_ID: {

            //
            // the interface stats struct is fixed-length,
            // with as many entries as there are interfaces
            //

            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPBOOTP_IF_STATS pissrc, pisdst;


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

            *pdwOutputSize = sizeof(IPBOOTP_MIB_GET_OUTPUT_DATA) - 1 +
                             sizeof(IPBOOTP_IF_STATS);
            if (pimgod) { pimgod->IMGOD_TypeID = IPBOOTP_IF_STATS_ID; }


            pTable = ig.IG_IfTable;


            ACQUIRE_READ_LOCK(&pTable->IT_RWL);

            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
            // GETMODE_NEXT was attempted on the last interface,
            // in which case dwErr contains ERROR_NO_MORE_ITEMS.
            // In any case, we make sure dwErr contains an error code
            // and then return.
            //

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

                //
                // write the index of the interface
                // whose stats are to be returned
                //

                pimgod->IMGOD_IfIndex = pite->ITE_Index;


                //
                // if the buffer is large enough, copy the stats to it
                //

                if (dwBufSize < sizeof(IPBOOTP_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 = (PIPBOOTP_IF_STATS)pimgod->IMGOD_Buffer;

                    pisdst->IS_State = 0;

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

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

                    pisdst->IS_SendFailures =
                            pissrc->IS_SendFailures;
                    pisdst->IS_ReceiveFailures =
                            pissrc->IS_ReceiveFailures;
                    pisdst->IS_ArpUpdateFailures =
                            pissrc->IS_ArpUpdateFailures;
                    pisdst->IS_RequestsReceived =
                            pissrc->IS_RequestsReceived;
                    pisdst->IS_RequestsDiscarded =
                            pissrc->IS_RequestsDiscarded;
                    pisdst->IS_RepliesReceived =
                            pissrc->IS_RepliesReceived;
                    pisdst->IS_RepliesDiscarded =
                            pissrc->IS_RepliesDiscarded;
                }
            }

            RELEASE_READ_LOCK(&pTable->IT_RWL);


            break;
        }

        case IPBOOTP_IF_CONFIG_ID: {


            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPBOOTP_IF_CONFIG picsrc, picdst;

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

            pTable = ig.IG_IfTable;

            ACQUIRE_READ_LOCK(&pTable->IT_RWL);


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

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

            //
            // if the interface was not 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_INVALID_PARAMETER; }
            }
            else {

                picsrc = pite->ITE_Config;
                dwSize = IC_SIZEOF(picsrc);
                *pdwOutputSize = sizeof(IPBOOTP_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 (dwBufSize < dwSize) {
                        dwErr = ERROR_INSUFFICIENT_BUFFER;
                    }
                    else {

                        //
                        // copy the configuration
                        //

                        picdst = (PIPBOOTP_IF_CONFIG)pimgod->IMGOD_Buffer;
                        CopyMemory(picdst, picsrc, dwSize);

                        picdst->IC_State = 0;

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

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

                    pimgod->IMGOD_IfIndex = pite->ITE_Index;
                }

            }

            RELEASE_READ_LOCK(&pTable->IT_RWL);

            break;
        }

        case IPBOOTP_IF_BINDING_ID: {

            PIF_TABLE pTable;
            PIF_TABLE_ENTRY pite;
            PIPBOOTP_IF_BINDING pibsrc, pibdst;

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

            pTable = ig.IG_IfTable;

            ACQUIRE_READ_LOCK(&pTable->IT_RWL);


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

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

            //
            // if the interface was not 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_INVALID_PARAMETER; }
            }
            else {

                pibsrc = pite->ITE_Binding;
                
                if (pibsrc == NULL ) {
                    TRACE1(
                        IF, "MibGetInternal: interface %d not bound", 
                        pimgid->IMGID_IfIndex
                        );

                    dwErr = ERROR_INVALID_PARAMETER;
                }
                else {

                    dwSize = (pibsrc ? IPBOOTP_IF_BINDING_SIZE(pibsrc)
                                     : sizeof(IPBOOTP_IF_BINDING));
                    *pdwOutputSize = sizeof(IPBOOTP_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 (dwBufSize < dwSize) {
                            dwErr = ERROR_INSUFFICIENT_BUFFER;
                        }
                        else {

                            //
                            // copy the binding
                            //

                            pibdst = (PIPBOOTP_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 |= IPBOOTP_STATE_ENABLED;
                            }

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

                        pimgod->IMGOD_IfIndex = pite->ITE_Index;
                    }

                }

            }

            RELEASE_READ_LOCK(&pTable->IT_RWL);

            break;
        }

        default: {
            dwErr = ERROR_INVALID_PARAMETER;
        }
    }

    return dwErr;
}


//----------------------------------------------------------------------------
// Function:    EnableDhcpInformServer
//
// Called to supply the address of a server to whom DHCP inform messages
// will be redirected. Note that this is an exported routine, invoked
// in the context of the caller's process, whatever that might be;
// the assumption is that it will be called from within the router process.
//
// If the relay-agent is configured, then this sets an address which will
// be picked up in 'ProcessRequest' for every incoming request.
// If the relay-agent is not configured, the routine has no effect.
// If the relay-agent is configured *after* this routine is called,
// then the DHCP inform server will be encountered as soon as the relay-agent
// starts, since it is saved directly into the relay-agents 'IPBOOTP_GLOBALS'.
//----------------------------------------------------------------------------

VOID APIENTRY
EnableDhcpInformServer(
    DWORD DhcpInformServer
    ) {
    InterlockedExchange(&ig.IG_DhcpInformServer, DhcpInformServer);
}

//----------------------------------------------------------------------------
// Function:    DisableDhcpInformServer
//
// Called to clear the previously-enabled DHCP inform server, if any.
//----------------------------------------------------------------------------

VOID APIENTRY
DisableDhcpInformServer(
    VOID
    ) {
    InterlockedExchange(&ig.IG_DhcpInformServer, 0);
}