windows-server-2003/net/rras/ipx/rtrmgr/adptmgr.c

/*++

Copyright (c) 1995 Microsoft Corporation

Module Name:

    adptmgr.c

Abstract:

    This module contains the adapter management functions

Author:

    Stefan Solomon  03/07/1995

Revision History:


--*/

#include "precomp.h"
#pragma hdrstop

//
// Adapter Manager Globals
//


HANDLE	    AdapterConfigPortHandle;
HANDLE	    AdapterNotificationThreadHandle;

//  Counter of created adapters
ULONG	    AdaptersCount = 0;

PICB
GetInterfaceByAdptNameAndPktType(LPWSTR AdapterName, DWORD dwType);

DWORD 
PnpAdapterConfigHandler(ADAPTER_INFO * pAdapterInfo,
                        ULONG AdapterIndex,
                        ULONG AdapterConfigurationStatus);

DWORD 
ReConfigureAdapter(IN DWORD dwAdapterIndex, 
                   IN PWSTR pszAdapterName, 
                   IN PADAPTER_INFO pAdapter);
                            
VOID
CreateAdapter(ULONG		AdapterIndex,
	      PWSTR		AdapterNamep,
	      PADAPTER_INFO	adptip);

VOID
DeleteAdapter(ULONG	AdapterIndex);

VOID
AdapterUp(ULONG 	AdapterIndex);

VOID
AdapterDown(ULONG	AdapterIndex);

/*++

Function:	StartAdapterManager

Descr:		opens the IPX stack notification port

--*/

DWORD
StartAdapterManager(VOID)
{
    ADAPTERS_GLOBAL_PARAMETERS		AdptGlobalParameters;
    DWORD				threadid;

    Trace(ADAPTER_TRACE, "StartAdapterManager: Entered\n");

    // create adapter config port
    if((AdapterConfigPortHandle = IpxCreateAdapterConfigurationPort(
	    g_hEvents[ADAPTER_NOTIFICATION_EVENT],
	    &AdptGlobalParameters)) == INVALID_HANDLE_VALUE) {

	// can't create config port
	return (1);
    }

    return (0);
}

/*++

Function:	StopAdapterManager

Descr:		Closes the IPX notification port

--*/

VOID
StopAdapterManager(VOID)
{
    DWORD	    rc;
    ULONG	    AdapterIndex;

    Trace(ADAPTER_TRACE, "StopAdapterManager: Entered\n");

    // Close the IPX stack notification port
    IpxDeleteAdapterConfigurationPort(AdapterConfigPortHandle);
}
// Debugging functions
char * DbgTypeToString(DWORD dwType) {
    switch (dwType) {
	    case MISN_FRAME_TYPE_ETHERNET_II:
            return "EthII";
	    case MISN_FRAME_TYPE_802_3:
            return "802.3";
	    case MISN_FRAME_TYPE_802_2:
            return "802.2";
	    case MISN_FRAME_TYPE_SNAP:
            return "SNAP";
	    case MISN_FRAME_TYPE_ARCNET:
            return "Arcnet";
	    case ISN_FRAME_TYPE_AUTO:
            return "Autodetect";
    }

    return "Unknown";
}

// Helper debug function traces out information about a given interface
VOID DbgTraceAdapterInfo(IN PADAPTER_INFO pAdapter, DWORD dwIndex, LPSTR pszTitle) {
    Trace(ADAPTER_TRACE, "%s: Ind=%d IfInd=%d Net=%x Lcl=%x Rmt=%x Spd=%d Type=%d", 
                         pszTitle,
                         dwIndex,
                         pAdapter->InterfaceIndex,
                         *((LONG*)(pAdapter->Network)), 
                         *((LONG*)(pAdapter->LocalNode)),
                         *((LONG*)(pAdapter->RemoteNode)),
                         pAdapter->LinkSpeed,
                         pAdapter->NdisMedium);
}

// Outputs the current status of an adapter to the trace window
VOID DbgTraceAdapter(PACB acbp) {
    Trace(ADAPTER_TRACE, "[%d]  Interface: %d, Network: %x, Type: %s", 
                         acbp->AdapterIndex,
                         (acbp->icbp) ? acbp->icbp->InterfaceIndex : -1,
                         *((LONG*)(acbp->AdapterInfo.Network)),
                         DbgTypeToString(acbp->AdapterInfo.PacketType));
}


// Outputs the current list of adapters to the trace window
VOID DbgTraceAdapterList() {
    PLIST_ENTRY lep;
    DWORD i;
    PACB	    acbp;

    ACQUIRE_DATABASE_LOCK;

	Trace(ADAPTER_TRACE, "List of current adapters:");
	Trace(ADAPTER_TRACE, "=========================");
    // Loop through the adapter hash table, printing as we go
    for (i = 0; i < ADAPTER_HASH_TABLE_SIZE; i++) {
        lep = IndexAdptHt[i].Flink;
        while(lep != &IndexAdptHt[i]) {
    	    acbp = CONTAINING_RECORD(lep, ACB, IndexHtLinkage);
    	    DbgTraceAdapter(acbp);
    	    lep = acbp->IndexHtLinkage.Flink;
    	}
    }
    Trace(ADAPTER_TRACE, "\n");

	RELEASE_DATABASE_LOCK;
}

/*++

Function:	    AdapterNotification

Descr:		    Processes adapter notification events

--*/

VOID
AdapterNotification(VOID)
{
    ADAPTER_INFO    AdapterInfo;
    ULONG	    AdapterIndex;
    ULONG	    AdapterConfigurationStatus;
    DWORD	    rc;

    Trace(ADAPTER_TRACE, "AdapterNotification: Entered");

    // Adaptif manages the adapter information.  Get the next piece of
    // information that adptif has queued for us.
    while((rc = IpxGetQueuedAdapterConfigurationStatus(
					AdapterConfigPortHandle,
					&AdapterIndex,
					&AdapterConfigurationStatus,
					&AdapterInfo)) == NO_ERROR) 
    {
	    switch(AdapterConfigurationStatus) {
            // An adapter is being created.  This is happening either
            // because we are receiving the list of current adapters 
            // at initialization time or as a result of a PnP event.
            // Either way, the smarts to deal with the situation are built
            // into our PnP handler.  
            // 
            // This message is also sent when an existing adapter is 
            // being configured.
	        case ADAPTER_CREATED:
                PnpAdapterConfigHandler(&AdapterInfo,
                                         AdapterIndex,
                                         AdapterConfigurationStatus);
		        break;
            // Handle an adapter being deleted -- this can happen as a result of
            // pcmcia removing the adapter or as a result of a binding change
            // or a wan link removal.
	        case ADAPTER_DELETED:
		        DeleteAdapter(AdapterIndex);
		        break;
            // A wan line came up.
	        case ADAPTER_UP:
		        AdapterUp(AdapterIndex);
		        break;
            // A wan line went down
	        case ADAPTER_DOWN:
		        AdapterDown(AdapterIndex);
		        break;

            // Some internal error has occured.
	        default:
		        SS_ASSERT(FALSE);
		        break;
	     }
    }
    DbgTraceAdapterList();
}

// Handles adapter creation and configuration notifications.
DWORD PnpAdapterConfigHandler(ADAPTER_INFO * pAdapterInfo,
                              ULONG AdapterIndex,
                              ULONG AdapterConfigurationStatus) 
{
    ULONG AdapterNameSize;
    LPWSTR AdapterNameBuffer;
    DWORD dwErr;

    Trace(ADAPTER_TRACE, "PnpAdapterConfigHandler: Entered for adpt #%d", AdapterIndex);

    // If this is the internal adapter, we don't need an adapter name
    if (AdapterIndex == 0)
        AdapterNameBuffer = L"";

    // Otherwise, get the adapter name from the stack
    else {
        AdapterNameSize = wcslen(pAdapterInfo->pszAdpName) * sizeof (WCHAR) + sizeof(WCHAR);

        //Allocate the memory to hold the name of the adapter
		if((AdapterNameBuffer = GlobalAlloc(GPTR, AdapterNameSize)) == NULL)
			return ERROR_NOT_ENOUGH_MEMORY;

		wcscpy(AdapterNameBuffer, pAdapterInfo->pszAdpName);
	}

    // Either create or configure the adapter depending on whether
    // it has already exists in the adapter database.
    ACQUIRE_DATABASE_LOCK;
    
    if(GetAdapterByIndex(AdapterIndex))
        ReConfigureAdapter(AdapterIndex, AdapterNameBuffer, pAdapterInfo);
    else 
        CreateAdapter(AdapterIndex, AdapterNameBuffer, pAdapterInfo);
        
	RELEASE_DATABASE_LOCK;

    // Cleanup
    if (AdapterIndex != 0)
   		GlobalFree(AdapterNameBuffer);

    return NO_ERROR;
}

// Attempt to bind an unbound adapter
DWORD AttemptAdapterBinding (PACB acbp) {
    PICB icbp;

    // Make sure we aren't already bound
    if (acbp->icbp)
        return NO_ERROR;
    
    if(acbp->AdapterInfo.NdisMedium != NdisMediumWan) {
	    // this is a DEDICATED (e.g	LAN) adapter. If an interface already exists for it,
	    // bind it to its interface and notify the other modules
	    if(acbp->AdapterIndex != 0) {
	        icbp = GetInterfaceByAdptNameAndPktType(acbp->AdapterNamep, 
	                                                acbp->AdapterInfo.PacketType);
	        if (icbp)
		        BindInterfaceToAdapter(icbp, acbp);
	    }
	    else {
	        // This is the internal adapter
	        InternalAdapterp = acbp;

            // If the internal network number was set to zero (nullnet), then
            // we have a configuration problem -- don't barf on this, just log
            // the fact.
	        if(!memcmp(acbp->AdapterInfo.Network, nullnet, 4)) {
                IF_LOG (EVENTLOG_ERROR_TYPE) {
                    RouterLogErrorDataA (RMEventLogHdl, 
                        ROUTERLOG_IPX_NO_VIRTUAL_NET_NUMBER,
                        0, NULL, 0, NULL);
                }
		        Trace(ADAPTER_TRACE, "CreateAdapter: Internal net number is not configured !");
		        // [pmay] now when we get a bad internal net number, we re-configure.
		        // SS_ASSERT(FALSE);
		        PnpAutoSelectInternalNetNumber(ADAPTER_TRACE);
	        }

	        // if the internal interface already exists, bind to it
	        if(icbp = InternalInterfacep) {
    		    BindInterfaceToAdapter(icbp, acbp);
	        }
	    }
    }
    else {
	    // this is a connected WAN adapter
	    SS_ASSERT(acbp->icbp == NULL);

	    // bind to corresponding interface
	    if(icbp = GetInterfaceByIndex(acbp->AdapterInfo.InterfaceIndex)) {
	        // bind all interfaces to this adapter
	        BindInterfaceToAdapter(icbp, acbp);
	    }
    }

    return NO_ERROR;
}

// Resets the configuration of the given adapter.  This function assumes that
// the database is locked and that the given adapter index references an
// adapter in the database.  Furthermore this function assumes that it does
// not need to release its lock on the database.
DWORD ReConfigureAdapter(IN DWORD dwAdapterIndex, 
                         IN PWSTR pszAdapterName, 
                         IN PADAPTER_INFO pAdapter)
{
    PACB	acbp;
    PICB	icbp;

    Trace(
        ADAPTER_TRACE, 
        "ReConfigureAdapter: Entered for %d: %S: %x, %d", 
        dwAdapterIndex, 
        pszAdapterName, 
        *((DWORD*)(pAdapter->Network)),
        pAdapter->InterfaceIndex
        );

    // If the adapter being configured is the internal adapter and if it is to be
    // re-configured to a zero net number, that is to be a signal to automatically
    // assign a new network number.
    if ((dwAdapterIndex == 0) && (*((DWORD*)pAdapter->Network) == 0)) {
        DWORD dwErr;
        
        Trace(ADAPTER_TRACE, "ReConfigureAdapter: Internal Net = 0, selecting new number");
        if ((dwErr = PnpAutoSelectInternalNetNumber(ADAPTER_TRACE)) != NO_ERROR) 
            Trace(ADAPTER_TRACE, "ReConfigureAdapter: Auto-select of new net number FAILED!");
        return dwErr;
    }

    // Get a reference to the adapter and the interface
    if (dwAdapterIndex == 0)
        acbp = InternalAdapterp;
    else
        acbp = GetAdapterByIndex(dwAdapterIndex);
        
    if (!acbp) {
        Trace(ADAPTER_TRACE, "ReConfigureAdapter: Invalid adapter %d!", dwAdapterIndex);
        return ERROR_CAN_NOT_COMPLETE;
    }
    icbp = acbp->icbp;

    // If this adapter isn't bound yet, update it and then
    // try to bind it.
    if (!icbp) {
        acbp->AdapterInfo = *pAdapter;
        AttemptAdapterBinding (acbp);
    }        

    // Otherwise, unbind and then re-bind the adapter
    else {
        // Unbind the interface from the adapter
        UnbindInterfaceFromAdapter(icbp);

        // Update the information
        acbp->AdapterInfo = *pAdapter;

        // Rebind the interface to the adapter
        AttemptAdapterBinding(acbp);
    }

    return NO_ERROR;
}

/*++

Function:	CreateAdapter

Descr:		creates the adapter control block

Modification:
            [pmay] Assume the database lock is aquired before this function enters
                   and that the given adapter index has not already been added
                   to the adapter database.
--*/
VOID
CreateAdapter(ULONG	AdapterIndex,
	          PWSTR	AdapterNamep,
	          PADAPTER_INFO	adptip)
{
    PACB	acbp;
    PICB	icbp;
    ULONG	namelen;
    PUCHAR  ln = adptip->LocalNode;

    Trace(
        ADAPTER_TRACE, 
        "CreateAdapter: Entered for %d (%x%x%x%x%x%x)(%S), %d", 
        AdapterIndex, 
        ln[0], ln[1], ln[2], ln[3], ln[4], ln[5], 
        AdapterNamep, 
        adptip->InterfaceIndex);
    
	// adapter name len including the unicode null
	namelen = (wcslen(AdapterNamep) + 1) * sizeof(WCHAR);

    // new adapter, try to get an ACB
    if((acbp = GlobalAlloc(GPTR, sizeof(ACB) + namelen)) == NULL) {
        Trace(ADAPTER_TRACE, "CreateAdapter: RETURNING BECAUSE INSUFFICIENT MEMORY TO ALLOCATE ADAPTER");
        // [pmay] PnP handler takes care of aquiring and releasing the database lock.
	    // RELEASE_DATABASE_LOCK;       
	    SS_ASSERT(FALSE);
	    return;
    }

    // make the ACB
    acbp->AdapterIndex = AdapterIndex;
    AddToAdapterHt(acbp);
    memcpy(acbp->Signature, AdapterSignature, 4);

    // We haven't bound to any interface at this point
    acbp->icbp = NULL;

    // Store the adapter information pertinent to this adapter
    acbp->AdapterInfo = *adptip;

    // Copy of the adapter name
    acbp->AdapterNamep = (LPWSTR)((PUCHAR)acbp + sizeof(ACB));
	wcscpy(acbp->AdapterNamep, AdapterNamep);
	acbp->AdapterNameLen = namelen - 1; // without the unicode null

	// Attempt to bind the adapter
	AttemptAdapterBinding (acbp);

    AdaptersCount++;

    if(acbp->AdapterInfo.NdisMedium != NdisMediumWan) {
	    if(acbp->AdapterIndex == 0) {
	        Trace(ADAPTER_TRACE, "CreateAdapter: Created INTERNAL adapter index 0");
	    }
	    else {
	        Trace(ADAPTER_TRACE, "CreateAdapter: Created LAN adapter # %d name %S",
			       acbp->AdapterIndex,
			       acbp->AdapterNamep);
	    }
    }
    else {
	    Trace(ADAPTER_TRACE, "CreateAdapter: created WAN adapter # %d", acbp->AdapterIndex);
    }

    // [pmay] PnP handler takes care of aquiring and releasing the database lock.
    // RELEASE_DATABASE_LOCK;
}

/*++

Function:	DeleteAdapter
Descr:

--*/

VOID
DeleteAdapter(ULONG	AdapterIndex)
{
    PACB	acbp, acbp2;
    PICB    icbp;
    WCHAR   pszAdapterName[MAX_ADAPTER_NAME_LEN];

    Trace(ADAPTER_TRACE, "DeleteAdapter: Entered for adapter # %d", AdapterIndex);

    ACQUIRE_DATABASE_LOCK;

    // Get the adapter
    if((acbp = GetAdapterByIndex(AdapterIndex)) == NULL) {
    	RELEASE_DATABASE_LOCK;
    	Trace(ADAPTER_TRACE, "DeleteAdapter: Ignored. There is no adapter # %d to be deleted !\n", AdapterIndex);
    	return;
    }

    // 1. if the adapter is bound to an interface -> unbind it.  Also, save the adapter name.
    if((icbp = acbp->icbp) != NULL) {
    	wcscpy(pszAdapterName, acbp->AdapterNamep);
    	UnbindInterfaceFromAdapter(acbp->icbp);
    }

    // Remove the adapter from the database
    RemoveFromAdapterHt(acbp);
    AdaptersCount--;

    // [pmay]
    // Since pnp can cause adapters to be added and removed from the database 
    // in unpredictable orders, see if there is already another adapter in the 
    // database with which the bound interface can immediately re-bind.
    if (icbp) {
        if((acbp2 = GetAdapterByNameAndPktType (pszAdapterName, icbp->PacketType)) != NULL)
            BindInterfaceToAdapter(icbp, acbp2);
    }

    RELEASE_DATABASE_LOCK;

    Trace(ADAPTER_TRACE, "DeleteAdapter: deleted adapter # %d", acbp->AdapterIndex);
    GlobalFree(acbp);

    return;
}

/*++

Function:	AdapterDown

Descr:		Called if the LAN adapter isn't functional.
		It calls back into the SNMP Agent with a trap - AdapterDown

--*/

VOID
AdapterDown(ULONG	AdapterIndex)
{
    // Call AdapterDownTrap
}

/*++

Function:	AdapterUp

Descr:		Called if the LAN adapter isn't functional.
		It calls back into the SNMP Agent with a trap - AdapterUP

--*/

VOID
AdapterUp(ULONG	AdapterIndex)
{
    // Call AdapterUpTrap
}

VOID
DestroyAllAdapters(VOID)
{
    PLIST_ENTRY     IfHtBucketp, lep;
    PACB	    acbp;
    ULONG	    AdapterIndex;
    int 	    i;

    for(i=0, IfHtBucketp = IndexAdptHt;	i<ADAPTER_HASH_TABLE_SIZE;	i++, IfHtBucketp++) {
    	if (!IsListEmpty(IfHtBucketp)) {
    	    acbp = CONTAINING_RECORD(IfHtBucketp->Flink, ACB, IndexHtLinkage);
    	    RemoveFromAdapterHt(acbp);
    	    AdaptersCount--;
    	    Trace(ADAPTER_TRACE, "DestroyAllAdapters: destroyed adapter # %d\n", acbp->AdapterIndex);
    	    GlobalFree(acbp);
    	}
    }
}