windows-nt-4.0/private/ntos/tdi/tcpip/ip/ipstatus.c

/********************************************************************/
/**                     Microsoft LAN Manager                      **/
/**               Copyright(c) Microsoft Corp., 1990-1992          **/
/********************************************************************/
/* :ts=4 */

//***   ipstatus.c - IP status routines.
//
//      This module contains all routines related to status indications.
//


#include        "oscfg.h"
#include        "cxport.h"
#include        "ndis.h"
#include        "ip.h"
#include        "ipdef.h"
#include        "llipif.h"
#include        "iproute.h"
#include		"ipinfo.h"

#if 0
EXTERNAL_LOCK(PILock)
#endif
extern  ProtInfo IPProtInfo[];	// Protocol information table.
extern  int     NextPI;			// Next PI field to be used.
extern  ProtInfo *RawPI;        // Raw IP protinfo

//* FindULStatus - Find the upper layer status handler.
//
//	Called when we need to find the upper layer status handler for a particular
//	protocol.
//
//	Entry:  Protocol        - Protocol to look up
//
//	Returns: A pointer to the ULStatus proc, or NULL if it can't find one.
//
ULStatusProc
FindULStatus(uchar Protocol)
{
    ULStatusProc            StatusProc = (ULStatusProc)NULL;
    int                                     i;
#if 0
	CTELockHandle           Handle;


    CTEGetLock(&PILock, &Handle);
#endif
    for ( i = 0; i < NextPI; i++) {
		if (IPProtInfo[i].pi_protocol == Protocol) {
			StatusProc = IPProtInfo[i].pi_status;
#if 0
            CTEFreeLock(&PILock, Handle);
#endif
            return StatusProc;
		}
    }

    if (RawPI != NULL) {
        StatusProc = RawPI->pi_status;
    }

#if 0
    CTEFreeLock(&PILock, Handle);
#endif

    return StatusProc;
}


//*	ULMTUNotify - Notify the upper layers of an MTU change.
//
//	Called when we need to notify the upper layers of an MTU change. We'll
//	loop through the status table, calling each status proc with the info.
//
//	This routine doesn't do any locking of the protinfo table. We might need
// 	to check this.
//
//	Input:  Dest		- Destination address affected.
// 			Src			- Source address affected.
//			Prot		- Protocol that triggered change, if any.
//			Ptr			- Pointer to protocol info, if any.
//			NewMTU		- New MTU to tell them about.
//
//      Returns: Nothing.
//
void
ULMTUNotify(IPAddr Dest, IPAddr Src, uchar Prot, void *Ptr, uint NewMTU)
{
	ULStatusProc		StatusProc;
    int					i;

    // First, notify the specific client that a frame has been dropped
    // and needs to be retransmitted.

    StatusProc = FindULStatus(Prot);
    if (StatusProc != NULL)
		(*StatusProc)(IP_NET_STATUS, IP_SPEC_MTU_CHANGE, Dest, Src,
			NULL_IP_ADDR, NewMTU, Ptr);

    // Now notify all UL entities that the MTU has changed.
    for (i = 0; i < NextPI; i++) {
		StatusProc = IPProtInfo[i].pi_status;

		if (StatusProc != NULL)
			(*StatusProc)(IP_HW_STATUS, IP_MTU_CHANGE, Dest, Src, NULL_IP_ADDR,
				NewMTU, Ptr);
    }
}

#ifdef	CHICAGO

//*	IPULUnloadNotify - Notify clients that we're unloading.
//
//	Called when we receive an unload message. We'll notify the upper layers
//	that we're unloading.
//
//	Input:  Nothing.
//
//  Returns: Nothing.
//
void
IPULUnloadNotify(void)
{
	ULStatusProc		StatusProc;
    int					i;
	
    // Now notify all UL entities that the MTU has changed.
    for (i = 0; i < NextPI; i++) {
		StatusProc = IPProtInfo[i].pi_status;

		if (StatusProc != NULL)
			(*StatusProc)(IP_HW_STATUS, IP_UNLOAD, NULL_IP_ADDR, NULL_IP_ADDR,
				NULL_IP_ADDR, 0, NULL);
    }
}

#endif

//*	IPStatus - Handle a link layer status call.
//
//	This is the routine called by the link layer when some sort of 'important'
//	status change occurs.
//
//	Entry:  Context         - Context value we gave to the link layer.
//			Status          - Status change code.
//			Buffer          - Pointer to buffer of status information.
//			BufferSize      - Size of Buffer.
//
//	Returns: Nothing.
//
void
IPStatus(void *Context, uint Status, void *Buffer, uint BufferSize)
{
	NetTableEntry			*NTE = (NetTableEntry *)Context;
	LLIPSpeedChange			*LSC;
	LLIPMTUChange			*LMC;
	LLIPAddrMTUChange		*LAM;
	uint					NewMTU;
	Interface				*IF;


	switch  (Status) {

		case LLIP_STATUS_SPEED_CHANGE:
			if (BufferSize < sizeof(LLIPSpeedChange))
				break;
			LSC = (LLIPSpeedChange *)Buffer;
			NTE->nte_if->if_speed = LSC->lsc_speed;
			break;
		case LLIP_STATUS_MTU_CHANGE:
			if (BufferSize < sizeof(LLIPMTUChange))
				break;
			// Walk through the NTEs on the IF, updating their MTUs.
			IF = NTE->nte_if;
			LMC = (LLIPMTUChange *)Buffer;
			IF->if_mtu = LMC->lmc_mtu;
			NewMTU = LMC->lmc_mtu - sizeof(IPHeader);
			NTE = IF->if_nte;
			while (NTE != NULL) {
				NTE->nte_mss = NewMTU;
				NTE = NTE->nte_ifnext;
			}
			RTWalk(SetMTUOnIF, IF, &NewMTU);
			break;
		case LLIP_STATUS_ADDR_MTU_CHANGE:
			if (BufferSize < sizeof(LLIPAddrMTUChange))
				break;
			// The MTU for a specific remote address has changed. Update all
			// routes that use that remote address as a first hop, and then
			// add a host route to that remote address, specifying the new
			// MTU.
			LAM = (LLIPAddrMTUChange *)Buffer;
			NewMTU = LAM->lam_mtu - sizeof(IPHeader);
			RTWalk(SetMTUToAddr, &LAM->lam_addr, &NewMTU);
			AddRoute(LAM->lam_addr, HOST_MASK, IPADDR_LOCAL, NTE->nte_if, NewMTU,
				1, IRE_PROTO_LOCAL, ATYPE_OVERRIDE, GetRouteContext(LAM->lam_addr,
				NTE->nte_addr));
			break;
		default:
			break;
    }

}