/********************************************************************/
/** Microsoft LAN Manager **/
/** Copyright(c) Microsoft Corp., 1990-1995 **/
/********************************************************************/
/* :ts=4 */
//*** iproute.c - IP routing routines.
//
// This file contains all the routines related to IP routing, including
// routing table lookup and management routines.
#include "oscfg.h"
#include "cxport.h"
#include "ndis.h"
#include "ip.h"
#include "ipdef.h"
#include "ipinit.h"
#include "info.h"
#include "tdistat.h"
#include "iproute.h"
#include "iprtdef.h"
#include "ipxmit.h"
#include "igmp.h"
#include "tdiinfo.h"
#include "ipfilter.h"
extern NetTableEntry *NetTableList; // Pointer to the net table.
extern NetTableEntry *DHCPNTE; // Pointer to NTE being DHCP'd.
extern NetTableEntry *LoopNTE; // Pointer to loopback NTE.
extern Interface LoopInterface; // Pointer to loopback interface.
extern AddrTypeCache ATCache[];
extern int ATCIndex;
extern IP_STATUS SendICMPErr(IPAddr, IPHeader UNALIGNED *, uchar, uchar, ulong);
extern uchar ParseRcvdOptions(IPOptInfo *, OptIndex *);
extern void ULMTUNotify(IPAddr Dest, IPAddr Src, uchar Prot, void *Ptr,
uint NewMTU);
extern Interface *IFList;
extern Interface *FirstIF;
#define ROUTE_TABLE_SIZE 32 // Size of the route table.
DEFINE_LOCK_STRUCTURE(RouteTableLock)
#define FWPACKET_GROW_AMOUNT 20
#define FW_BUF_SIZE 256 // Size of a forwarding buffer.
#define FW_BUF_GROW_AMOUNT 30720 // Enough for 20 Ethernet packets.
#define NO_SR 0
RouteTableEntry *RouteTable[ROUTE_TABLE_SIZE];
DEFINE_LOCK_STRUCTURE(FWPacketFreeLock)
DEFINE_LOCK_STRUCTURE(FWBufFreeLock)
PNDIS_PACKET FWPacketFree; // Free list of forwarding packets.
PNDIS_BUFFER FWBufFree; // Free list of forwarding buffers.
uint MaxFWPackets; // Maximum number of forward packets allowed.
uint CurrentFWPackets; // Number of forwarding packets currently
// allocated.
uint MaxFWBufferSize; // Maximum number of forwarding buffers allowed.
uint CurrentFWBufferSize; // Number of forwarding buffers allocated.
uchar ForwardPackets; // Flag indicating whether we should forward.
uchar RouterConfigured; // TRUE if we were initially
// configured as a router.
uchar ForwardBCast; // Flag indicating if we should forward bcasts.
RouteSendQ *BCastRSQ;
uint DefGWConfigured; // Number of default gateways configed.
uint DefGWActive; // Number of def. gateways active.
uint DeadGWDetect;
uint PMTUDiscovery;
ProtInfo *RtPI = NULL;
IPMask IPMaskTable[] = {
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSA_MASK,
CLASSB_MASK,
CLASSB_MASK,
CLASSB_MASK,
CLASSB_MASK,
CLASSC_MASK,
CLASSC_MASK,
CLASSD_MASK,
CLASSE_MASK };
extern void TransmitFWPacket(PNDIS_PACKET, uint);
uint MTUTable[] = {
65535 - sizeof(IPHeader),
32000 - sizeof(IPHeader),
17914 - sizeof(IPHeader),
8166 - sizeof(IPHeader),
4352 - sizeof(IPHeader),
2002 - sizeof(IPHeader),
1492 - sizeof(IPHeader),
1006 - sizeof(IPHeader),
508 - sizeof(IPHeader),
296 - sizeof(IPHeader),
MIN_VALID_MTU - sizeof(IPHeader)
};
CTETimer IPRouteTimer;
// Pointer to callout routine for dial on demand.
IPMapRouteToInterfacePtr DODCallout;
// Pointer to packet filter handler.
IPPacketFilterPtr ForwardFilterPtr;
RouteInterface DummyInterface; // Dummy interface.
#ifdef NT
#ifdef ALLOC_PRAGMA
//
// Make init code disposable.
//
int InitRouting(IPConfigInfo *ci);
#pragma alloc_text(INIT, InitRouting)
#endif // ALLOC_PRAGMA
#endif // NT
#define InsertAfterRTE(P, R) (R)->rte_next = (P)->rte_next;\
(P)->rte_next = (R)
#define InsertRTE(R) {\
RouteTableEntry *__P__; \
__P__ = FindInsertPoint((R)); \
InsertAfterRTE(__P__, (R)); \
}
#define RemoveRTE(P, R) (P)->rte_next = (R)->rte_next;
//** DuumyXmit - Dummy interface transmit handler.
//
// A dummy routine that should never be called.
//
// Entry: Context - NULL.
// Packet - Pointer to packet to be transmitted.
// Dest - Destination addres of packet.
// RCE - Pointer to RCE (should be NULL).
//
// Returns: NDIS_STATUS_PENDING
//
NDIS_STATUS
DummyXmit(void *Context, PNDIS_PACKET Packet, IPAddr Dest, RouteCacheEntry *RCE)
{
DbgPrint("TCPIP: Dummy Xmit called - NOT GOOD\n");
CTEAssert(FALSE);
return NDIS_STATUS_SUCCESS;
}
//* DummyXfer - Dummy interface transfer data routine.
//
// A dummy routine that should never be called.
//
// Entry: Context - NULL.
// TDContext - Original packet that was sent.
// Dummy - Unused
// Offset - Offset in frame from which to start copying.
// BytesToCopy - Number of bytes to copy.
// DestPacket - Packet describing buffer to copy into.
// BytesCopied - Place to return bytes copied.
//
// Returns: NDIS_STATUS_SUCCESS
//
NDIS_STATUS
DummyXfer(void *Context, NDIS_HANDLE TDContext, uint Dummy, uint Offset, uint BytesToCopy,
PNDIS_PACKET DestPacket, uint *BytesCopied)
{
DbgPrint("TCPIP: DummyXfer called - NOT GOOD\n");
CTEAssert(FALSE);
return NDIS_STATUS_FAILURE;
}
//* DummyClose - Dummy close routine.
//
// A dummy routine that should never be called.
//
// Entry: Context - Unused.
//
// Returns: Nothing.
//
void
DummyClose(void *Context)
{
DbgPrint("TCPIP: Dummy Close called - NOT GOOD\n");
CTEAssert(FALSE);
}
//* DummyInvalidate - .
//
// A dummy routine that should never be called.
//
// Entry: Context - Unused.
// RCE - Pointer to RCE to be invalidated.
//
// Returns: Nothing.
//
void
DummyInvalidate(void *Context, RouteCacheEntry *RCE)
{
DbgPrint("TCPIP: Dummy Invalidate called - NOT GOOD\n");
CTEAssert(FALSE);
}
//* DummyQInfo - Dummy query information handler.
//
// A dummy routine that should never be called.
//
// Input: IFContext - Interface context (unused).
// ID - TDIObjectID for object.
// Buffer - Buffer to put data into.
// Size - Pointer to size of buffer. On return, filled with
// bytes copied.
// Context - Pointer to context block.
//
// Returns: Status of attempt to query information.
//
int
DummyQInfo(void *IFContext, TDIObjectID *ID, PNDIS_BUFFER Buffer, uint *Size,
void *Context)
{
DbgPrint("TCPIP: DummyQInfo called - NOT GOOD\n");
CTEAssert(FALSE);
return TDI_INVALID_REQUEST;
}
//* DummySetInfo - Dummy query information handler.
//
// A dummy routine that should never be called.
//
// Input: IFContext - Interface context (unused).
// ID - TDIObjectID for object.
// Buffer - Buffer to put data into.
// Size - Pointer to size of buffer. On return, filled with
// bytes copied.
//
// Returns: Status of attempt to query information.
//
int
DummySetInfo(void *IFContext, TDIObjectID *ID, void *Buffer, uint Size)
{
DbgPrint("TCPIP: DummySetInfo called - NOT GOOD\n");
CTEAssert(FALSE);
return TDI_INVALID_REQUEST;
}
//* DummyAddAddr - Dummy add address routine.
//
// Called at init time when we need to initialize ourselves.
//
uint
DummyAddAddr(void *Context, uint Type, IPAddr Address, IPMask Mask, void *Context2)
{
CTEAssert(FALSE);
return TRUE;
}
//* DummyDelAddr - Dummy del address routine.
//
// Called at init time when we need to initialize ourselves.
//
uint
DummyDelAddr(void *Context, uint Type, IPAddr Address, IPMask Mask)
{
DbgPrint("TCPIP: DummyAddAddr called - NOT GOOD\n");
CTEAssert(FALSE);
return TRUE;
}
//* DummyGetEList - Dummy get entity list.
//
// A dummy routine that should never be called.
//
// Input: Context - Unused.
// EntityList - Pointer to entity list to be filled in.
// Count - Pointer to number of entries in the list.
//
// Returns Status of attempt to get the info.
//
int
DummyGetEList(void *Context, TDIEntityID *EntityList, uint *Count)
{
DbgPrint("TCPIP: DummyGetEList called - NOT GOOD\n");
CTEAssert(FALSE);
return FALSE;
}
#ifdef _PNP_POWER
//* DerefIF - Dereference an interface.
//
// Called when we need to dereference an interface. We decrement the
// refcount, and if it goes to zero we signal whoever is blocked on
// it.
//
// Input: IF - Interfaec to be dereferenced.
//
// Returns: Nothing.
//
void
DerefIF(Interface *IF)
{
uint Original;
Original = CTEInterlockedAddUlong(
&IF->if_refcount,
(ULONG)-1,
&RouteTableLock
);
if (Original != 1) {
return;
} else {
// We just decremented the last reference. Wake whoever is
// blocked on it.
CTEAssert(IF->if_block != NULL);
CTESignal(IF->if_block, NDIS_STATUS_SUCCESS);
}
}
//* LockedDerefIF - Dereference an interface w/RouteTableLock held.
//
// Called when we need to dereference an interface. We decrement the
// refcount, and if it goes to zero we signal whoever is blocked on
// it. The difference here is that we assume the caller already holds
// the RouteTableLock.
//
// Input: IF - Interfaec to be dereferenced.
//
// Returns: Nothing.
//
void
LockedDerefIF(Interface *IF)
{
uint Original;
IF->if_refcount--;
if (IF->if_refcount != 0) {
return;
} else {
// We just decremented the last reference. Wake whoever is
// blocked on it.
CTEAssert(IF->if_block != NULL);
CTESignal(IF->if_block, NDIS_STATUS_SUCCESS);
}
}
#endif
//* GetHashMask - Get mask to use with address when hashing.
//
// Called when we need to decide on the mask to use when hashing. If the
// supplied mask is the host mask or the default mask, we'll use that. Else
// if the supplied mask is at least as specific as the net mask, we'll use the
// net mask. Otherwise we drop back to the default mask.
//
// Input: Destination - Destination we'll be hashing on.
// Mask - Caller supplied mask.
//
// Returns: Mask to use.
//
IPMask
GetHashMask(IPAddr Destination, IPMask Mask)
{
IPMask NetMask;
if (Mask == HOST_MASK || Mask == DEFAULT_MASK)
return Mask;
NetMask = IPNetMask(Destination);
if ((NetMask & Mask) == NetMask)
return NetMask;
return DEFAULT_MASK;
}
//** AddrOnIF - Check to see if a given address is local to an IF
//
// Called when we want to see if a given address is a valid local address
// for an interface. We walk down the chain of NTEs in the interface, and
// see if we get a match. We assume the caller holds the RouteTableLock
// at this point.
//
// Input: IF - Interface to check.
// Addr - Address to check.
//
// Returns: TRUE if Addr is an address for IF, FALSE otherwise.
//
uint
AddrOnIF(Interface *IF, IPAddr Addr)
{
NetTableEntry *NTE;
NTE = IF->if_nte;
while (NTE != NULL) {
if ((NTE->nte_flags & NTE_VALID) && IP_ADDR_EQUAL(NTE->nte_addr, Addr))
return TRUE;
else
NTE = NTE->nte_ifnext;
}
return FALSE;
}
//** BestNTEForIF - Find the 'best match' NTE on a given interface.
//
// This is a utility function that takes an address and tries to find the
// 'best match' NTE on a given interface. This is really only useful when we
// have multiple IP addresses on a single interface.
//
// Input: Address - Source address of packet.
// IF - Pointer to IF to be searched.
//
// Returns: The 'best match' NTE.
//
NetTableEntry *
BestNTEForIF(IPAddr Address, Interface *IF)
{
NetTableEntry *CurrentNTE, *FoundNTE;
if (IF->if_nte != NULL) {
// Walk the list of NTEs, looking for a valid one.
CurrentNTE = IF->if_nte;
FoundNTE = NULL;
do {
if (CurrentNTE->nte_flags & NTE_VALID) {
if (IP_ADDR_EQUAL(Address & CurrentNTE->nte_mask,
CurrentNTE->nte_addr & CurrentNTE->nte_mask))
return CurrentNTE;
else
if (FoundNTE == NULL)
FoundNTE = CurrentNTE;
}
CurrentNTE = CurrentNTE->nte_ifnext;
} while (CurrentNTE != NULL);
// If we found a match, or we didn't and the destination is not
// a broadcast, return the result. We have special case code to
// handle broadcasts, since the interface doesn't really matter there.
if (FoundNTE != NULL || (!IP_ADDR_EQUAL(Address, IP_LOCAL_BCST) &&
!IP_ADDR_EQUAL(Address, IP_ZERO_BCST)))
return FoundNTE;
}
// An 'anonymous' I/F, or the address we're reaching is a broadcast and the
// first interface has no address. Find a valid (non-loopback) address.
for (CurrentNTE = NetTableList; CurrentNTE != NULL;
CurrentNTE = CurrentNTE->nte_next) {
if (CurrentNTE != LoopNTE && (CurrentNTE->nte_flags & NTE_VALID))
return CurrentNTE;
}
return NULL;
}
//** IsBCastonNTE - Determine if the specified addr. is a bcast on a spec. NTE.
//
// This routine is called when we need to know if an address is a broadcast
// on a particular net. We check in the order we expect to be most common - a
// subnet bcast, an all ones broadcast, and then an all subnets broadcast. We
// return the type of broadcast it is, or return DEST_LOCAL if it's not a
// broadcast.
//
// Entry: Address - Address in question.
// NTE - NetTableEntry to check Address against.
//
// Returns: Type of broadcast.
//
uchar
IsBCastOnNTE(IPAddr Address, NetTableEntry *NTE)
{
IPMask Mask;
IPAddr BCastAddr;
BCastAddr = NTE->nte_if->if_bcast;
if (NTE->nte_flags & NTE_VALID) {
Mask = NTE->nte_mask;
if(Mask != 0xFFFFFFFF)
{
if (IP_ADDR_EQUAL(Address, (NTE->nte_addr & Mask) | (BCastAddr & ~Mask)))
return DEST_SN_BCAST;
}
// See if it's an all subnet's broadcast.
if (!CLASSD_ADDR(Address)) {
Mask = IPNetMask(Address);
if (IP_ADDR_EQUAL(Address,
(NTE->nte_addr & Mask) | (BCastAddr & ~Mask)))
return DEST_BCAST;
} else {
// This is a class D address. If we're allowed to receive
// mcast datagrams, check our list.
if (IGMPLevel == 2) {
IGMPAddr *AddrPtr;
CTELockHandle Handle;
CTEGetLock(&NTE->nte_lock, &Handle);
AddrPtr = NTE->nte_igmplist;
while (AddrPtr != NULL) {
if (IP_ADDR_EQUAL(Address, AddrPtr->iga_addr))
break;
else
AddrPtr = AddrPtr->iga_next;
}
CTEFreeLock(&NTE->nte_lock, Handle);
if (AddrPtr != NULL)
return DEST_MCAST;
}
}
}
// A global bcast is certainly a bcast on this net.
if (IP_ADDR_EQUAL(Address, BCastAddr))
return DEST_BCAST;
return DEST_LOCAL;
}
//** InvalidSourceAddress - Check to see if a source address is invalid.
//
// This function takes an input address and checks to see if it is valid
// if used as the source address of an incoming packet. An address is invalid
// if it's 0, -1, a Class D or Class E address, is a net or subnet broadcast,
// or has a 0 subnet or host part.
//
// Input: Address - Address to be check.
//
// Returns: FALSE if the address is not invalid, TRUE if it is invalid.
//
uint
InvalidSourceAddress(IPAddr Address)
{
NetTableEntry *NTE; // Pointer to current NTE.
IPMask Mask; // Mask for address.
uchar Result; // Result of broadcast check.
IPMask SNMask;
IPAddr MaskedAddress;
IPAddr LocalAddress;
if ( !CLASSD_ADDR(Address) &&
!CLASSE_ADDR(Address) &&
!IP_ADDR_EQUAL(Address, IP_ZERO_BCST) &&
!IP_ADDR_EQUAL(Address, IP_LOCAL_BCST)
) {
// It's not an obvious broadcast. See if it's an all subnets
// broadcast, or has a zero host part.
Mask = IPNetMask(Address);
MaskedAddress = Address & Mask;
if (!IP_ADDR_EQUAL(Address, MaskedAddress) &&
!IP_ADDR_EQUAL(Address, (MaskedAddress | ~Mask))
) {
// It's not an all subnet's broadcast, and it has a non-zero
// host/subnet part. Walk our local IP addresses, and see if it's
// a subnet broadcast.
NTE = NetTableList;
do {
LocalAddress = NTE->nte_addr;
if ((NTE->nte_flags & NTE_VALID) &&
!IP_LOOPBACK(LocalAddress)) {
Mask = NTE->nte_mask;
MaskedAddress = LocalAddress & Mask;
if (IP_ADDR_EQUAL(Address, MaskedAddress) ||
IP_ADDR_EQUAL(Address,
(MaskedAddress |
(NTE->nte_if->if_bcast & ~Mask)))) {
return TRUE;
}
}
NTE = NTE->nte_next;
} while (NTE != NULL);
return FALSE;
}
}
return TRUE;
}
//** FlushATCache - Flush an address from the ATCache
//
// This function takes an input address, and removes it from the ATCache,
// if it is present.
//
// Input: Address - Address to be check.
//
// Returns: Destination type.
//
void
FlushATCache(IPAddr Address)
{
uint i;
for (i=0; i<ATC_SIZE; i++) {
if (ATCache[i].atc_flags & (ATCache[i].atc_addr == Address)) {
ATCache[i].atc_flags = 0;
}
}
}
//** GetAddrType - Return the type of a specified address.
//
// This function takes an input address, and determines what type it is. An
// address can be local, bcast, remote, or remote bcast.
//
// Input: Address - Address to be check.
//
// Returns: Destination type.
//
uchar
GetAddrType(IPAddr Address)
{
NetTableEntry *NTE; // Pointer to current NTE.
IPMask Mask; // Mask for address.
uchar Result; // Result of broadcast check.
IPMask SNMask;
uint saveATCIndex;
uint i;
saveATCIndex = ATCIndex & ATC_MASK;
i = saveATCIndex;
do {
if (ATCache[i].atc_flags && (ATCache[i].atc_addr == Address)) {
Result = ATCache[i].atc_type;
if (ATCache[i].atc_flags && (ATCache[i].atc_addr == Address)) {
return(Result);
}
}
i = (--i) & ATC_MASK;
} while (i != saveATCIndex );
if (!CLASSE_ADDR(Address)) {
// See if it's one of our local addresses, or a broadcast
// on a local address.
NTE = NetTableList;
do {
if (IP_ADDR_EQUAL(NTE->nte_addr, Address) &&
(NTE->nte_flags & NTE_VALID)) {
Result = DEST_LOCAL;
goto gat_exit;
}
if ((Result = IsBCastOnNTE(Address, NTE)) != DEST_LOCAL) {
goto gat_exit;
}
// See if the destination has a valid host part.
if (NTE->nte_flags & NTE_VALID) {
SNMask = NTE->nte_mask;
if (IP_ADDR_EQUAL(Address & SNMask, NTE->nte_addr & SNMask)) {
// On this subnet. See if the host part is invalid.
if (IP_ADDR_EQUAL(Address & SNMask, Address)) {
Result = DEST_INVALID; // Invalid 0 host part.
goto gat_exit;
}
}
}
NTE = NTE->nte_next;
} while (NTE != NULL);
// It's not a local address, see if it's loopback.
if (IP_LOOPBACK(Address)) {
Result = DEST_LOCAL;
goto gat_exit;
}
// If we're doing IGMP, see if it's a Class D address. If it it,
// return that.
if (CLASSD_ADDR(Address)) {
if (IGMPLevel != 0) {
Result = DEST_REM_MCAST;
goto gat_exit;
}
else {
Result = DEST_INVALID;
goto gat_exit;
}
}
Mask = IPNetMask(Address);
// Now check remote broadcast. When we get here we know that the
// address is not a global broadcast, a subnet broadcast for a subnet
// of which we're a member, or an all-subnets broadcast for a net of
// which we're a member. Since we're avoiding making assumptions about
// all subnet of a net having the same mask, we can't really check for
// a remote subnet broadcast. We'll use the net mask and see if it's
// a remote all-subnet's broadcast.
if (IP_ADDR_EQUAL(Address, (Address & Mask) | (IP_LOCAL_BCST & ~Mask))) {
Result = DEST_REM_BCAST;
goto gat_exit;
}
// Check for invalid 0 parts. All we can do from here is see if he's
// sending to a remote net with all zero subnet and host parts. We
// can't check to see if he's sending to a remote subnet with an all
// zero host part.
if (IP_ADDR_EQUAL(Address, Address & Mask) ||
IP_ADDR_EQUAL(Address, NULL_IP_ADDR)) {
Result = DEST_INVALID;
goto gat_exit;
}
// Must be remote.
Result = DEST_REMOTE;
goto gat_exit;
}
Result = DEST_INVALID;
gat_exit:
++ATCIndex;
i = ATCIndex & ATC_MASK;
ATCache[i].atc_addr = Address;
ATCache[i].atc_type = Result;
ATCache[i].atc_flags = 1;
return(Result);
}
//** IPHash - IP hash function.
//
// This is the function to compute the hash index from a masked address.
//
// Input: Address - Masked address to be hashed.
//
// Returns: Hashed value.
//
uint
IPHash(IPAddr Address)
{
uchar *i = (uchar *)&Address;
return (i[0] + i[1] + i[2] + i[3]) & (ROUTE_TABLE_SIZE-1);
}
//** GetLocalNTE - Get the local NTE for an incoming packet.
//
// Called during receive processing to find a matching NTE for a packet.
// First we check against the NTE we received it on, then against any NTE.
//
// Input: Address - The dest. address of the packet.
// NTE - Pointer to NTE packet was received on - filled in on
// exit w/correct NTE.
//
// Returns: DEST_LOCAL if the packet is destined for this host, DEST_REMOTE if it needs to
// be routed, DEST_SN_BCAST or DEST_BCAST if it's some sort of a broadcast.
uchar
GetLocalNTE(IPAddr Address, NetTableEntry **NTE)
{
NetTableEntry *LocalNTE = *NTE;
IPMask Mask;
uchar Result;
int i;
Interface *LocalIF;
NetTableEntry *OriginalNTE;
// Quick check to see if it is for the NTE it came in on (the common case).
if (IP_ADDR_EQUAL(Address, LocalNTE->nte_addr) &&
(LocalNTE->nte_flags & NTE_VALID))
return DEST_LOCAL; // For us, just return.
// Now check to see if it's a broadcast of some sort on the interface it
// came in on.
if ((Result = IsBCastOnNTE(Address, LocalNTE)) != DEST_LOCAL)
return Result;
// The common cases failed us. Loop through the NetTable and see if
// it is either a valid local address or is a broadcast on one of the NTEs
// on the incoming interface. We won't check the NTE we've already looked
// at. We look at all NTEs, including the loopback NTE, because a loopback
// frame could come through here. Also, frames from ourselves to ourselves
// will come in on the loopback NTE.
i = 0;
LocalIF = LocalNTE->nte_if;
OriginalNTE = LocalNTE;
LocalNTE = NetTableList;
do {
if (LocalNTE != OriginalNTE) {
if (IP_ADDR_EQUAL(Address, LocalNTE->nte_addr) &&
(LocalNTE->nte_flags & NTE_VALID)) {
*NTE = LocalNTE;
return DEST_LOCAL; // For us, just return.
}
// If this NTE is on the same interface as the NTE it arrived on,
// see if it's a broadcast.
if (LocalIF == LocalNTE->nte_if)
if ((Result = IsBCastOnNTE(Address, LocalNTE)) != DEST_LOCAL) {
*NTE = LocalNTE;
return Result;
}
}
LocalNTE = LocalNTE->nte_next;
} while (LocalNTE != NULL);
// It's not a local address, see if it's loopback.
if (IP_LOOPBACK(Address)) {
*NTE = LoopNTE;
return DEST_LOCAL;
}
// If it's a class D address and we're receiveing multicasts, handle it
// here.
if (CLASSD_ADDR(Address)) {
if (IGMPLevel != 0)
return DEST_REM_MCAST;
else
return DEST_INVALID;
}
// It's not local. Check to see if maybe it's a net broadcast for a net
// of which we're not a member. If so, return remote bcast. We can't check
// for subnet broadcast of subnets for which we're not a member, since we're
// not making assumptions about all subnets of a single net having the
// same mask. If we're here it's not a subnet broadcast for a net of which
// we're a member, so we don't know a subnet mask for it. We'll just use
// the net mask.
Mask = IPNetMask(Address);
if (IP_ADDR_EQUAL(Address, (Address & Mask) |
((*NTE)->nte_if->if_bcast & ~Mask)))
return DEST_REM_BCAST;
// If it's to the 0 address, or a Class E address, or has an all-zero
// subnet and net part, it's invalid.
if (IP_ADDR_EQUAL(Address, IP_ZERO_BCST) ||
IP_ADDR_EQUAL(Address, (Address & Mask)) ||
CLASSE_ADDR(Address))
return DEST_INVALID;
// If we're DHCPing the interface on which this came in we'll accept this.
// If it came in as a broadcast a check in IPRcv() will reject it. If it's
// a unicast to us we'll pass it up.
if (DHCPNTE != NULL && DHCPNTE == *NTE) {
return DEST_LOCAL;
}
return DEST_REMOTE;
}
//** FindSpecificRTE - Look for a particular RTE.
//
// Called when we're adding a route and want to find a particular RTE.
// We take in the destination, mask, first hop, and src addr, and search
// the appropriate routeing table chain. We assume the caller has the
// RouteTableLock held. If we find the match, we'll return a pointer to the
// RTE with the RTE lock held, as well as a pointer to the previous RTE in
// the chain.
//
// Input: Dest - Destination to search for.
// Mask - Mask for destination.
// FirstHop - FirstHop to Dest.
// OutIF - Pointer to outgoing interface structure.
// PrevRTE - Place to put PrevRTE, if found.
//
// Returns: Pointer to matching RTE if found, or NULL if not.
//
RouteTableEntry *
FindSpecificRTE(IPAddr Dest, IPMask Mask, IPAddr FirstHop, Interface *OutIF,
RouteTableEntry **PrevRTE)
{
uint Index;
IPMask HashMask;
RouteTableEntry *TempRTE, *CurrentRTE;
HashMask = GetHashMask(Dest, Mask);
Index = IPHash(Dest & HashMask);
TempRTE = STRUCT_OF(RouteTableEntry, &RouteTable[Index], rte_next);
CurrentRTE = TempRTE->rte_next;
//
// If this has been called because user mode was trying to set the route
// to INVALID, then the OUTIF will be DummyInterface, but we want to match
// any interface, since the IF will have already been plumbed by DODCallOut
//
if(OutIF == (Interface *)&DummyInterface)
{
//
// Match everything but the interface
//
while (CurrentRTE != NULL)
{
if (IP_ADDR_EQUAL(CurrentRTE->rte_dest,Dest) &&
CurrentRTE->rte_mask == Mask &&
IP_ADDR_EQUAL(CurrentRTE->rte_addr, FirstHop))
{
break;
}
TempRTE = CurrentRTE;
CurrentRTE = CurrentRTE->rte_next;
}
}
else
{
// Walk the table, looking for a match.
while (CurrentRTE != NULL) {
// See if everything matches.
if (IP_ADDR_EQUAL(CurrentRTE->rte_dest,Dest) &&
CurrentRTE->rte_mask == Mask &&
IP_ADDR_EQUAL(CurrentRTE->rte_addr, FirstHop) &&
CurrentRTE->rte_if == OutIF)
break;
TempRTE = CurrentRTE;
CurrentRTE = CurrentRTE->rte_next;
}
}
*PrevRTE = TempRTE;
return CurrentRTE;
}
//** IsRouteICMP - This function is used by Router Discovery to determine
// how we learned about the route. We are not allowed to update or timeout
// routes that were not learned about via icmp. If the route is new then
// we treat it as icmp and add a new entry.
// Input: Dest - Destination to search for.
// Mask - Mask for destination.
// FirstHop - FirstHop to Dest.
// OutIF - Pointer to outgoing interface structure.
//
// Returns: TRUE if learned via ICMP, FALSE otherwise.
//
uint
IsRouteICMP(IPAddr Dest, IPMask Mask, IPAddr FirstHop, Interface *OutIF)
{
RouteTableEntry *RTE;
RouteTableEntry *TempRTE;
RTE = FindSpecificRTE(Dest, Mask, FirstHop, OutIF, &TempRTE);
if (RTE == NULL)
return(TRUE);
if (RTE->rte_proto == IRE_PROTO_ICMP) {
return(TRUE);
} else {
return(FALSE);
}
}
//** FindRTE - Find a matching RTE in a hash table chain.
//
// Called when we want to find a matching RTE. We take in a destination,
// a source, a hash index, and a maximum priority, and walk down the
// chain specified by the index looking for a matching RTE. If we can find
// one, we'll keep looking hoping for a match on the source address.
//
// The caller must hold the RouteTableLock before calling this function.
//
// Input: Dest - Destination we're trying to reach.
// Source - Source address to match.
// Index - Index of chain to search.
// MaxPri - Maximum acceptable priority.
// MinPri - Minimum acceptable priority.
//
// Returns: Pointer to RTE if found, or NULL if not.
//
RouteTableEntry *
FindRTE(IPAddr Dest, IPAddr Source, uint Index, uint MaxPri, uint MinPri)
{
RouteTableEntry *CurrentRTE;
uint RTEPri;
uint Metric;
RouteTableEntry *FoundRTE;
// First walk down the chain, skipping those RTEs that have a
// a priority greater than what we want.
CurrentRTE = RouteTable[Index];
for (;;) {
if (CurrentRTE == NULL)
return NULL; // Hit end of chain, bounce out.
if (CurrentRTE->rte_priority <= MaxPri)
break; // He's a possible match.
// Priority is too big. Try the next one.
CurrentRTE = CurrentRTE->rte_next;
}
FoundRTE = NULL;
// When we get here, we have a locked RTE with a priority less than or
// equal to what was specifed.
// Examine it, and if it doesn't match try the next one. If it does match
// we'll stash it temporarily and keep looking for one that matches the
// specifed source.
for (;;) {
// The invariant at the top of this loop is that CurrentRTE points to
// a candidate RTE, locked with the handle in CurrentHandle.
if (CurrentRTE->rte_flags & RTE_VALID) {
// He's valid. Make sure he's at least the priority we need. If
// he is, see if he matches. Otherwise we're done.
if (CurrentRTE->rte_priority < MinPri) {
// His priority is too small. Since the list is in sorted order,
// all following routes must have too low a priority, so we're
// done.
return NULL;
}
if (IP_ADDR_EQUAL(Dest & CurrentRTE->rte_mask, CurrentRTE->rte_dest)) {
// He's valid for this route. Save the current information,
// and look for a matching source.
FoundRTE = CurrentRTE;
if (!IP_ADDR_EQUAL(Source, NULL_IP_ADDR) &&
!AddrOnIF(CurrentRTE->rte_if, Source)) {
RTEPri = CurrentRTE->rte_priority;
Metric = CurrentRTE->rte_metric;
CurrentRTE = CurrentRTE->rte_next;
// We've save the info. Starting at the next RTE, look for
// an RTE that matches both the mask criteria and the source
// address. The search will terminate when we hit the end
// of the list, or the RTE we're examing has a different
// (presumably lesser) priority (or greater metric), or we
// find a match.
while (CurrentRTE != NULL &&
CurrentRTE->rte_priority == RTEPri &&
CurrentRTE->rte_metric == Metric) {
// Skip invalid route types.
if (CurrentRTE->rte_flags & RTE_VALID) {
if (IP_ADDR_EQUAL(Dest & CurrentRTE->rte_mask,
CurrentRTE->rte_dest)) {
if (AddrOnIF(CurrentRTE->rte_if, Source)) {
// He matches the source. Free the old lock,
// and break out.
FoundRTE = CurrentRTE;
break;
}
}
}
CurrentRTE = CurrentRTE->rte_next;
}
}
// At this point, FoundRTE points to the RTE we want to return,
// and *Handle has the lock handle for the RTE. Break out.
break;
}
}
CurrentRTE = CurrentRTE->rte_next;
if (CurrentRTE != NULL) {
continue;
} else
break;
}
return FoundRTE;
}
//* ValidateDefaultGWs - Mark all default gateways as valid.
//
// Called to one or all of our default gateways as up. The caller specifies
// the IP address of the one to mark as up, or NULL_IP_ADDR if they're all
// supposed to be marked up. We return a count of how many we marked as
// valid.
//
// Input: IP address of G/W to mark as up.
//
// Returns: Count of gateways marked as up.
//
uint
ValidateDefaultGWs(IPAddr Addr)
{
RouteTableEntry *RTE;
uint Count = 0;
uint Now = CTESystemUpTime() / 1000L;
RTE = RouteTable[IPHash(0)];
while (RTE != NULL) {
if (RTE->rte_mask == DEFAULT_MASK && !(RTE->rte_flags & RTE_VALID) &&
(IP_ADDR_EQUAL(Addr, NULL_IP_ADDR) ||
IP_ADDR_EQUAL(Addr, RTE->rte_addr))) {
RTE->rte_flags |= RTE_VALID;
RTE->rte_valid = Now;
Count++;
}
RTE = RTE->rte_next;
}
DefGWActive += Count;
return Count;
}
//* InvalidateRCEChain - Invalidate the RCEs on an RCE.
//
// Called to invalidate the RCE chain on an RTE. We assume the caller holds
// the route table lock.
//
// Input: RTE - RTE on which to invalidate RCEs.
//
// Returns: Nothing.
//
void
InvalidateRCEChain(RouteTableEntry *RTE)
{
CTELockHandle RCEHandle; // Lock handle for RCE being updated.
RouteCacheEntry *TempRCE, *CurrentRCE;
Interface *OutIF;
OutIF = RTE->rte_if;
// If there is an RCE chain on this RCE, invalidate the RCEs on it. We still
// hold the RouteTableLock, so RCE closes can't happen.
CurrentRCE = RTE->rte_rcelist;
RTE->rte_rcelist = NULL;
// Walk down the list, nuking each RCE.
while (CurrentRCE != NULL) {
CTEGetLock(&CurrentRCE->rce_lock, &RCEHandle);
if (CurrentRCE->rce_flags & RCE_VALID) {
CTEAssert(CurrentRCE->rce_rte == RTE);
CurrentRCE->rce_flags &= ~RCE_VALID;
CurrentRCE->rce_rte = (RouteTableEntry *)OutIF;
if ((CurrentRCE->rce_flags & RCE_CONNECTED) &&
CurrentRCE->rce_usecnt == 0) {
(*(OutIF->if_invalidate))(OutIF->if_lcontext, CurrentRCE);
#ifdef _PNP_POWER
if (CurrentRCE->rce_flags & RCE_REFERENCED) {
LockedDerefIF(OutIF);
CurrentRCE->rce_flags &= ~RCE_REFERENCED;
}
#endif
}
} else
CTEAssert(FALSE);
TempRCE = CurrentRCE->rce_next;
CTEFreeLock(&CurrentRCE->rce_lock, RCEHandle);
CurrentRCE = TempRCE;
}
}
//** FindValidIFForRTE - Find a valid inteface for an RTE.
//
// Called when we're going to send a packet out a route that currently marked
// as disconnected. If we have a valid callout routine we'll call it to find
// the outgoing interface index, and set up the RTE to point at that interface.
// This routine is called with the RouteTableLock held.
//
// Input: RTE - A pointer to the RTE for the route being used.
// Destination - Destination IP address we're trying to reach.
// Source - Source IP address we're sending from.
// Protocol - Protocol type of packet that caused send.
// Buffer - Pointer to first part of packet that caused send.
// Length - Length of buffer.
//
// Returns: A pointer to the RTE, or NULL if that RTE couldn't be connected.
//
RouteTableEntry *
FindValidIFForRTE(RouteTableEntry *RTE, IPAddr Destination, IPAddr Source,
uchar Protocol, uchar *Buffer, uint Length)
{
uint NewIFIndex;
Interface *NewIF;
NetTableEntry *NewNTE;
if (DODCallout != NULL) {
// There is a callout. See if it can help us.
NewIFIndex = (*DODCallout)(RTE->rte_context, Destination, Source,
Protocol, Buffer, Length);
if (NewIFIndex != INVALID_IF_INDEX) {
// We got what should be a valid index. Walk our interface table list
// and see if we can find a matching interface structure.
for (NewIF = IFList; NewIF != NULL; NewIF = NewIF->if_next) {
if (NewIF->if_index == NewIFIndex) {
// Found one.
break;
}
}
if (NewIF != NULL) {
// We found a matching structure. Set the RTE interface to point
// to this, and mark as connected.
if (RTE->rte_addr != IPADDR_LOCAL) {
// See if the first hop of the route is a local address on this
// new interface. If it is, mark it as local.
for (NewNTE = NewIF->if_nte; NewNTE != NULL;
NewNTE = NewNTE->nte_ifnext) {
// Don't look at him if he's not valid.
if (!(NewNTE->nte_flags & NTE_VALID)) {
continue;
}
// See if the first hop in the RTE is equal to this IP
// address.
if (IP_ADDR_EQUAL(NewNTE->nte_addr, RTE->rte_addr)) {
// It is, so mark as local and quit looking.
RTE->rte_addr = IPADDR_LOCAL;
RTE->rte_type = IRE_TYPE_DIRECT;
break;
}
}
}
// Set the RTE to the new interface, and mark him as valid.
RTE->rte_if = NewIF;
RTE->rte_flags |= RTE_IF_VALID;
RTE->rte_mtu = NewIF->if_mtu - sizeof(IPHeader);
return RTE;
} else
CTEAssert(FALSE);
}
}
// Either the callout is NULL, or the callout couldn't map a inteface index.
return NULL;
}
//** LookupRTE - Lookup a routing table entry.
//
// This routine looks up a routing table entry, and returns with the entry
// locked if it finds one. If it doesn't find one, it returns NULL. This
// routine assumes that the routing table is locked when it is called.
//
// The routeing table is organized as an open hash table. The table contains
// routes to hosts, subnets, and nets. Host routes are hashed on the host
// address, other non-default routes on the destination anded with the net
// mask, and default routes wind up in bucket 0. Within each bucket chain
// the routes are sorted with the greatest priority (i.e. number of bits in the
// route mask) first, and within each priority class the routes are sorted
// with the lowest metric first. The caller may specify a maximum priority
// for the route to be found. We look for routes in order of most specific to
// least specifc, i.e. first host routes, then other non-default routes, and
// finally default routes. We give preference to routes that are going out
// on an interface with an address that matches the input source address.
//
// It might be worthile in the future to split this up into multiple tables,
// so that we have a table for host routes, a table for non-default routes,
// and a list of default routes.
//
// Entry: Address - Address for which a route is to be found.
// Src - IPAddr of source (may be 0).
// MaxPri - Maximum priority of route to find.
//
// Returns: A pointer to the locked RTE if we find one, or NULL if we don't
//
RouteTableEntry *
LookupRTE(IPAddr Address, IPAddr Src, uint MaxPri)
{
RouteTableEntry *RTE;
// First try to find a host route, if we're allowed to.
if (MaxPri == HOST_ROUTE_PRI) {
RTE = FindRTE(Address, Src, IPHash(Address), MaxPri, MaxPri);
if (RTE != NULL) {
return RTE;
}
}
// Don't have or weren't allowed to find a host route. See if we can
// find a non-default route.
if (MaxPri > DEFAULT_ROUTE_PRI) {
RTE = FindRTE(Address, Src, IPHash(Address & IPNetMask(Address)),
MaxPri, DEFAULT_ROUTE_PRI + 1);
if (RTE != NULL) {
return RTE;
}
}
// No non-default route. Try a default route.
RTE = FindRTE(Address, Src, IPHash(0), MaxPri, DEFAULT_ROUTE_PRI);
return RTE;
}
//** GetRouteContext - Routine to get the route context for a specific route.
//
// Called when we need to get the route context for a path, usually when we're adding
// a route derived from an existing route. We return the route context for the
// existing route, or NULL if we can't find one.
//
// Input: Destination - Destination address of path.
// Source - Source address of path.
//
// Returns: A ROUTE_CONTEXT, or NULL.
//
void *
GetRouteContext(IPAddr Destination, IPAddr Source)
{
CTELockHandle Handle;
RouteTableEntry *RTE;
ROUTE_CONTEXT Context;
CTEGetLock(&RouteTableLock, &Handle);
RTE = LookupRTE(Destination, Source, HOST_ROUTE_PRI);
if (RTE != NULL) {
Context = RTE->rte_context;
} else
Context = NULL;
CTEFreeLock(&RouteTableLock, Handle);
return(Context);
}
//* FindInsertPoint - Find out where to insert an RTE in the table.
//
// Called to find out where to insert an RTE. We hash into the table,
// and walk the chain until we hit the end or we find an RTE with a
// lesser priority or a greater metric. Once we find the appropriate spot
// we return a pointer to the RTE immediately prior to the one we want to
// insert. We assume the caller holds the lock on the route table when calling
// this function.
//
// Input: InsertRTE - RTE we're going to (eventually) insert.
//
// Returns: Pointer to RTE in insert after.
//
RouteTableEntry *
FindInsertPoint(RouteTableEntry *InsertRTE)
{
RouteTableEntry *PrevRTE, *CurrentRTE;
IPMask HashMask, Mask;
uint Priority, Metric;
uint Index;
Priority = InsertRTE->rte_priority;
Metric = InsertRTE->rte_metric;
// First figure out where he should go. We'll hash on the whole address
// if the mask allows us to, or on the net portion if this is a non-default
// route.
Mask = InsertRTE->rte_mask;
HashMask = GetHashMask(InsertRTE->rte_dest, Mask);
Index = IPHash(InsertRTE->rte_dest & HashMask);
PrevRTE = STRUCT_OF(RouteTableEntry, &RouteTable[Index], rte_next);
CurrentRTE = PrevRTE->rte_next;
// Walk the table, looking for a place to insert it.
while (CurrentRTE != NULL) {
if (CurrentRTE->rte_priority < Priority) {
break;
}
if (CurrentRTE->rte_priority == Priority) {
// Priorities match. Check the metrics.
if (CurrentRTE->rte_metric > Metric) {
// Our metric is smaller than his, so we're done.
break;
}
}
// Either his priority is greater than ours or his metric is less
// than or equal to ours. Check the next one.
PrevRTE = CurrentRTE;
CurrentRTE = CurrentRTE->rte_next;
}
// At this point, we've either found the correct spot or hit the end
// of the list.
return PrevRTE;
}
//** LookupNextHop - Look up the next hop
//
// Called when we need to find the next hop on our way to a destination. We
// call LookupRTE to find it, and return the appropriate information.
//
// In a PnP build, the interface is referenced here.
//
// Entry: Destination - IP address we're trying to reach.
// Src - Source address of datagram being routed.
// NextHop - Pointer to IP address of next hop (returned).
// MTU - Pointer to where to return max MTU used on the
// route.
//
// Returns: Pointer to outgoing interface if we found one, NULL otherwise.
//
Interface *
LookupNextHop(IPAddr Destination, IPAddr Src, IPAddr *NextHop, uint *MTU)
{
CTELockHandle TableLock; // Lock handle for routing table.
RouteTableEntry *Route; // Pointer to route table entry for route.
Interface *IF;
CTEGetLock(&RouteTableLock, &TableLock);
Route = LookupRTE(Destination, Src, HOST_ROUTE_PRI);
if (Route != (RouteTableEntry *)NULL) {
IF = Route->rte_if;
// If this is a direct route, send straight to the destination.
*NextHop = IP_ADDR_EQUAL(Route->rte_addr, IPADDR_LOCAL) ? Destination :
Route->rte_addr;
*MTU = Route->rte_mtu;
#ifdef _PNP_POWER
IF->if_refcount++;
#endif
CTEFreeLock(&RouteTableLock, TableLock);
return IF;
} else { // Couldn't find a route.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL;
}
}
//** LookupNextHopWithBuffer - Look up the next hop, with packet information.
//
// Called when we need to find the next hop on our way to a destination and we
// have packet information that we may use for dial on demand support. We call
// LookupRTE to find it, and return the appropriate information. We may bring up
// the link if neccessary.
//
// In a PnP build, the interface is referenced here.
//
// Entry: Destination - IP address we're trying to reach.
// Src - Source address of datagram being routed.
// NextHop - Pointer to IP address of next hop (returned).
// MTU - Pointer to where to return max MTU used on the
// route.
// Protocol - Protocol type for packet that's causing this lookup.
// Buffer - Pointer to first part of packet causing lookup.
// Length - Length of Buffer.
//
// Returns: Pointer to outgoing interface if we found one, NULL otherwise.
//
Interface *
LookupNextHopWithBuffer(IPAddr Destination, IPAddr Src, IPAddr *NextHop,
uint *MTU, uchar Protocol, uchar *Buffer, uint Length)
{
CTELockHandle TableLock; // Lock handle for routing table.
RouteTableEntry *Route; // Pointer to route table entry for route.
Interface *IF;
CTEGetLock(&RouteTableLock, &TableLock);
Route = LookupRTE(Destination, Src, HOST_ROUTE_PRI);
if (Route != (RouteTableEntry *)NULL) {
// If this is a direct route, send straight to the destination.
*NextHop = IP_ADDR_EQUAL(Route->rte_addr, IPADDR_LOCAL) ? Destination :
Route->rte_addr;
// See if the route we found is connected. If not, try to connect it.
if (!(Route->rte_flags & RTE_IF_VALID)) {
Route = FindValidIFForRTE(Route, Destination, Src, Protocol, Buffer,
Length);
if (Route == NULL) {
// Couldn't bring it up.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL;
} else
IF = Route->rte_if;
} else
IF = Route->rte_if;
*MTU = Route->rte_mtu;
#ifdef _PNP_POWER
IF->if_refcount++;
#endif
CTEFreeLock(&RouteTableLock, TableLock);
return IF;
} else { // Couldn't find a route.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL;
}
}
//* RTReadNext - Read the next route in the table.
//
// Called by the GetInfo code to read the next route in the table. We assume
// the context passed in is valid, and the caller has the RouteTableLock.
//
// Input: Context - Pointer to a RouteEntryContext.
// Buffer - Pointer to an IPRouteEntry structure.
//
// Returns: TRUE if more data is available to be read, FALSE is not.
//
uint
RTReadNext(void *Context, void *Buffer)
{
RouteEntryContext *REContext = (RouteEntryContext *)Context;
IPRouteEntry *IPREntry = (IPRouteEntry *)Buffer;
RouteTableEntry *CurrentRTE;
uint i;
uint Now = CTESystemUpTime() / 1000L;
Interface *IF;
NetTableEntry *SrcNTE;
CurrentRTE = REContext->rec_rte;
// Fill in the buffer.
IF = CurrentRTE->rte_if;
IPREntry->ire_dest = CurrentRTE->rte_dest;
IPREntry->ire_index = IF->if_index;
IPREntry->ire_metric1 = CurrentRTE->rte_metric;
IPREntry->ire_metric2 = IRE_METRIC_UNUSED;
IPREntry->ire_metric3 = IRE_METRIC_UNUSED;
IPREntry->ire_metric4 = IRE_METRIC_UNUSED;
IPREntry->ire_metric5 = IRE_METRIC_UNUSED;
if (IP_ADDR_EQUAL(CurrentRTE->rte_addr, IPADDR_LOCAL)) {
SrcNTE = BestNTEForIF(CurrentRTE->rte_dest, IF);
if (IF->if_nte != NULL && SrcNTE != NULL)
IPREntry->ire_nexthop = SrcNTE->nte_addr;
else
IPREntry->ire_nexthop = IPREntry->ire_dest;
} else {
IPREntry->ire_nexthop = CurrentRTE->rte_addr;
}
IPREntry->ire_type = (CurrentRTE->rte_flags & RTE_VALID ?
CurrentRTE->rte_type : IRE_TYPE_INVALID);
IPREntry->ire_proto = CurrentRTE->rte_proto;
IPREntry->ire_age = Now - CurrentRTE->rte_valid;
IPREntry->ire_mask = CurrentRTE->rte_mask;
IPREntry->ire_context = CurrentRTE->rte_context;
// We've filled it in. Now update the context.
if (CurrentRTE->rte_next != NULL) {
REContext->rec_rte = CurrentRTE->rte_next;
return TRUE;
} else {
// The next RTE is NULL. Loop through the RouteTable looking for a new
// one.
i = REContext->rec_index + 1;
while (i < ROUTE_TABLE_SIZE) {
if (RouteTable[i] != NULL) {
REContext->rec_rte = RouteTable[i];
REContext->rec_index = i;
return TRUE;
break;
} else
i++;
}
REContext->rec_index = 0;
REContext->rec_rte = NULL;
return FALSE;
}
}
//* RTValidateContext - Validate the context for reading the route table.
//
// Called to start reading the route table sequentially. We take in
// a context, and if the values are 0 we return information about the
// first route in the table. Otherwise we make sure that the context value
// is valid, and if it is we return TRUE.
// We assume the caller holds the route table lock.
//
// Input: Context - Pointer to a RouteEntryContext.
// Valid - Where to return information about context being
// valid.
//
// Returns: TRUE if more data to be read in table, FALSE if not. *Valid set
// to TRUE if input context is valid
//
uint
RTValidateContext(void *Context, uint *Valid)
{
RouteEntryContext *REContext = (RouteEntryContext *)Context;
uint i;
RouteTableEntry *TargetRTE;
RouteTableEntry *CurrentRTE;
i = REContext->rec_index;
TargetRTE = REContext->rec_rte;
// If the context values are 0 and NULL, we're starting from the beginning.
if (i == 0 && TargetRTE == NULL) {
*Valid = TRUE;
do {
if ((CurrentRTE = RouteTable[i]) != NULL) {
break;
}
i++;
} while (i < ROUTE_TABLE_SIZE);
if (CurrentRTE != NULL) {
REContext->rec_index = i;
REContext->rec_rte = CurrentRTE;
return TRUE;
} else
return FALSE;
} else {
// We've been given a context. We just need to make sure that it's
// valid.
if (i < ROUTE_TABLE_SIZE) {
CurrentRTE = RouteTable[i];
while (CurrentRTE != NULL) {
if (CurrentRTE == TargetRTE) {
*Valid = TRUE;
return TRUE;
break;
} else {
CurrentRTE = CurrentRTE->rte_next;
}
}
}
// If we get here, we didn't find the matching RTE.
*Valid = FALSE;
return FALSE;
}
}
//* DeleteRTE - Delete an RTE.
//
// Called when we need to delete an RTE. We assume the caller has the
// RouteTableLock. We'll splice out the RTE, invalidate his RCEs, and
// free the memory.
//
// Input: PrevRTE - RTE in 'front' of one being deleted.
// RTE - RTE to be deleted.
//
// Returns: Nothing.
//
void
DeleteRTE(RouteTableEntry *PrevRTE, RouteTableEntry *RTE)
{
PrevRTE->rte_next = RTE->rte_next; // Splice him from the table.
IPSInfo.ipsi_numroutes--;
if (RTE->rte_mask == DEFAULT_MASK) {
// We're deleting a default route.
DefGWConfigured--;
if (RTE->rte_flags & RTE_VALID)
DefGWActive--;
if (DefGWActive == 0)
ValidateDefaultGWs(NULL_IP_ADDR);
}
InvalidateRCEChain(RTE);
// Free the old route.
CTEFreeMem(RTE);
}
//* DeleteRTEOnIF - Delete all RTEs on a particular IF.
//
// A function called by RTWalk when we want to delete all RTEs on a particular
// inteface. We just check the I/F of each RTE, and if it matches we return
// FALSE.
//
// Input: RTE - RTE to check.
// Context - Interface on which we're deleting.
//
// Returns: FALSE if we want to delete it, TRUE otherwise.
//
uint
DeleteRTEOnIF(RouteTableEntry *RTE, void *Context, void *Context1)
{
Interface *IF = (Interface *)Context;
if (RTE->rte_if == IF && !IP_ADDR_EQUAL(RTE->rte_dest, IF->if_bcast))
return FALSE;
else
return TRUE;
}
//* InvalidateRCEOnIF - Invalidate all RCEs on a particular IF.
//
// A function called by RTWalk when we want to invalidate all RCEs on a
// particular inteface. We just check the I/F of each RTE, and if it
// matches we call InvalidateRCEChain to invalidate the RCEs.
//
// Input: RTE - RTE to check.
// Context - Interface on which we're invalidating.
//
// Returns: TRUE.
//
uint
InvalidateRCEOnIF(RouteTableEntry *RTE, void *Context, void *Context1)
{
Interface *IF = (Interface *)Context;
if (RTE->rte_if == IF)
InvalidateRCEChain(RTE);
return TRUE;
}
//* SetMTUOnIF - Set the MTU on an interface.
//
// Called when we need to set the MTU on an interface.
//
// Input: RTE - RTE to check.
// Context - Pointer to a context.
// Context1 - Pointer to the new MTU.
//
// Returns: TRUE.
//
uint
SetMTUOnIF(RouteTableEntry *RTE, void *Context, void *Context1)
{
uint NewMTU = *(uint *)Context1;
Interface *IF = (Interface *)Context;
if (RTE->rte_if == IF)
RTE->rte_mtu = NewMTU;
return TRUE;
}
//* SetMTUToAddr - Set the MTU to a specific address.
//
// Called when we need to set the MTU to a specific address. We set the MTU
// for all routes that use the specified address as a first hop to the new
// MTU.
//
// Input: RTE - RTE to check.
// Context - Pointer to a context.
// Context1 - Pointer to the new MTU.
//
// Returns: TRUE.
//
uint
SetMTUToAddr(RouteTableEntry *RTE, void *Context, void *Context1)
{
uint NewMTU = *(uint *)Context1;
IPAddr Addr = *(IPAddr *)Context;
if (IP_ADDR_EQUAL(RTE->rte_addr, Addr))
RTE->rte_mtu = NewMTU;
return TRUE;
}
//* RTWalk - Routine to walk the route table.
//
// This routine walks the route table, calling the specified function
// for each entry. If the called function returns FALSE, the RTE is
// deleted.
//
// Input: CallFunc - Function to call for each entry.
// Context - Context value to pass to each call.
//
// Returns: Nothing.
//
void
RTWalk(uint (*CallFunc)(struct RouteTableEntry *, void *, void *),
void *Context, void *Context1)
{
uint i;
CTELockHandle Handle;
RouteTableEntry *RTE, *PrevRTE;
CTEGetLock(&RouteTableLock, &Handle);
for (i = 0; i < ROUTE_TABLE_SIZE; i++) {
PrevRTE = STRUCT_OF(RouteTableEntry, &RouteTable[i], rte_next);
RTE = RouteTable[i];
while (RTE != NULL) {
if (!(*CallFunc)(RTE, Context, Context1)) {
DeleteRTE(PrevRTE, RTE);
} else {
PrevRTE = RTE;
}
RTE = PrevRTE->rte_next;
}
}
CTEFreeLock(&RouteTableLock, Handle);
}
//** AttachRCEToRTE - Attach an RCE to an RTE.
//
// This procedure takes an RCE, finds the appropriate RTE, and attaches it.
// We check to make sure that the source address is still valid.
//
// Entry: RCE - RCE to be attached.
// Protocol - Protocol type for packet causing this call.
// Buffer - Pointer to buffer for packet causing this
// call.
// Length - Length of buffer.
//
// Returns: TRUE if we attach it, false if we don't.
//
uint
AttachRCEToRTE(RouteCacheEntry *RCE, uchar Protocol, uchar *Buffer, uint Length)
{
CTELockHandle TableHandle, RCEHandle;
RouteTableEntry *RTE;
NetTableEntry *NTE;
uint Status;
CTEGetLock(&RouteTableLock, &TableHandle);
for (NTE = NetTableList; NTE != NULL; NTE = NTE->nte_next)
if ((NTE->nte_flags & NTE_VALID) &&
IP_ADDR_EQUAL(RCE->rce_src, NTE->nte_addr))
break;
if (NTE == NULL) {
// Didn't find a match.
CTEFreeLock(&RouteTableLock, TableHandle);
return FALSE;
}
RTE = LookupRTE(RCE->rce_dest, RCE->rce_src, HOST_ROUTE_PRI);
// See if we found an RTE.
if (RTE != NULL) {
Status = TRUE;
// Yep, we found one. Get the lock on the RCE, and make sure he's
// not pointing at an RTE already. We also need to make sure that the usecnt
// is 0, so that we can invalidate the RCE at the low level. If we set valid
// to TRUE without doing this we may get into a wierd situation where we
// link the RCE onto an RTE but the lower layer information is wrong, so we
// send to IP address X at mac address Y. So to be safe we don't set valid
// to TRUE until both usecnt is 0 and valid is FALSE. We'll keep coming
// through this routine on every send until that happens.
CTEGetLock(&RCE->rce_lock, &RCEHandle);
if (RCE->rce_usecnt == 0) {
// Nobody is using him, so we can link him up.
if (!(RCE->rce_flags & RCE_VALID)) {
Interface *IF;
// He's not valid. Invalidate the lower layer info, just in
// case. Make sure he's connected before we try to do this. If
// he's not marked as connected, don't bother to try and invalidate
// him as there is no interface.
if (RCE->rce_flags & RCE_CONNECTED) {
IF = (Interface *)RCE->rce_rte;
(*(IF->if_invalidate))(IF->if_lcontext, RCE);
#ifdef _PNP_POWER
if (RCE->rce_flags & RCE_REFERENCED) {
LockedDerefIF(IF);
RCE->rce_flags &= ~RCE_REFERENCED;
}
#endif
} else {
CTEAssert(!(RCE->rce_flags & RCE_REFERENCED));
}
// Link the RCE on the RTE, and set up the back pointer.
RCE->rce_rte = RTE;
RCE->rce_flags |= RCE_VALID;
RCE->rce_next = RTE->rte_rcelist;
RTE->rte_rcelist = RCE;
// Make sure the RTE is connected. If not, try to connect him.
if (!(RTE->rte_flags & RTE_IF_VALID)) {
// Not connected. Try to connect him.
RTE = FindValidIFForRTE(RTE, RCE->rce_dest, RCE->rce_src,
Protocol, Buffer, Length);
if (RTE != NULL) {
// Got one, so mark as connected.
CTEAssert(!(RCE->rce_flags & RCE_REFERENCED));
#ifdef _PNP_POWER
RCE->rce_flags |= (RCE_CONNECTED | RCE_REFERENCED);
RTE->rte_if->if_refcount++;
#else
RCE->rce_flags |= RCE_CONNECTED;
#endif
} else {
// Couldn't get a valid i/f. Mark the RCE as not connected,
// and set up to fail this call.
CTEAssert(FALSE);
RCE->rce_flags &= ~RCE_CONNECTED;
Status = FALSE;
}
} else {
// The RTE is connected, mark the RCE as connected.
CTEAssert(!(RCE->rce_flags & RCE_REFERENCED));
#ifdef _PNP_POWER
RCE->rce_flags |= (RCE_CONNECTED | RCE_REFERENCED);
RTE->rte_if->if_refcount++;
#else
RCE->rce_flags |= RCE_CONNECTED;
#endif
}
} else {
// The RCE is valid. See if it's connected.
if (!(RCE->rce_flags & RCE_CONNECTED)) {
// Not connected, try to get a valid i/f.
if (!(RTE->rte_flags & RTE_IF_VALID)) {
RTE = FindValidIFForRTE(RTE, RCE->rce_dest, RCE->rce_src,
Protocol, Buffer, Length);
if (RTE != NULL) {
RCE->rce_flags |= RCE_CONNECTED;
#ifdef _PNP_POWER
CTEAssert(!(RCE->rce_flags & RCE_REFERENCED));
RCE->rce_flags |= RCE_REFERENCED;
RTE->rte_if->if_refcount++;
#endif
} else {
// Couldn't connect, so fail.
CTEAssert(FALSE);
Status = FALSE;
}
} else { // Already connected, just mark as valid.
RCE->rce_flags |= RCE_CONNECTED;
#ifdef _PNP_POWER
if (!(RCE->rce_flags & RCE_REFERENCED)) {
RCE->rce_flags |= RCE_REFERENCED;
RTE->rte_if->if_refcount++;
}
#endif
}
}
}
}
// Free the locks and we're done.
CTEFreeLock(&RCE->rce_lock, RCEHandle);
CTEFreeLock(&RouteTableLock, TableHandle);
return Status;
} else {
// No route! Fail the call.
CTEFreeLock(&RouteTableLock, TableHandle);
return FALSE;
}
}
//** IPGetPInfo - Get information..
//
// Called by an upper layer to get information about a path. We return the
// MTU of the path and the maximum link speed to be expected on the path.
//
// Input: Dest - Destination address.
// Src - Src address.
// NewMTU - Where to store path MTU (may be NULL).
// MaxPathSpeed - Where to store maximum path speed (may be NULL).
//
// Returns: Status of attempt to get new MTU.
//
IP_STATUS
IPGetPInfo(IPAddr Dest, IPAddr Src, uint *NewMTU, uint *MaxPathSpeed)
{
CTELockHandle Handle;
RouteTableEntry *RTE;
IP_STATUS Status;
CTEGetLock(&RouteTableLock, &Handle);
RTE = LookupRTE(Dest, Src, HOST_ROUTE_PRI);
if (RTE != NULL) {
if (NewMTU != NULL)
*NewMTU = RTE->rte_mtu;
if (MaxPathSpeed != NULL)
*MaxPathSpeed = RTE->rte_if->if_speed;
Status = IP_SUCCESS;
} else
Status = IP_DEST_HOST_UNREACHABLE;
CTEFreeLock(&RouteTableLock, Handle);
return Status;
}
//** IPCheckRoute - Check that a route is valid.
//
// Called by an upper layer when it believes a route might be invalid.
// We'll check if we can. If the upper layer is getting there through a
// route derived via ICMP (presumably a redirect) we'll check to see
// if it's been learned within the last minute. If it has, it's assumed
// to still be valid. Otherwise, we'll mark it as down and try to find
// another route there. If we can, we'll delete the old route. Otherwise
// we'll leave it. If the route is through a default gateway we'll switch
// to another one if we can. Otherwise, we'll just leave - we don't mess
// with manually configured routes.
//
// Input: Dest - Destination to be reached.
// Src - Src we're sending from.
//
// Returns: Nothing.
//
void
IPCheckRoute(IPAddr Dest, IPAddr Src)
{
RouteTableEntry *RTE;
RouteTableEntry *NewRTE;
RouteTableEntry *TempRTE;
CTELockHandle Handle;
uint Now = CTESystemUpTime() / 1000L;
if (DeadGWDetect) {
// We are doing dead G/W detection. Get the lock, and try and
// find the route.
CTEGetLock(&RouteTableLock, &Handle);
RTE = LookupRTE(Dest, Src, HOST_ROUTE_PRI);
if (RTE != NULL && ((Now - RTE->rte_valid) > MIN_RT_VALID)) {
// Found a route, and it's older than the minimum valid time. If it
// goes through a G/W, and is a route we learned via ICMP or is a
// default route, do something with it.
if (!IP_ADDR_EQUAL(RTE->rte_addr, IPADDR_LOCAL)) {
// It's not through a G/W.
if (RTE->rte_proto == IRE_PROTO_ICMP) {
// Came from ICMP. Mark as invalid, and then make sure
// we have another route there.
RTE->rte_flags &= ~RTE_VALID;
NewRTE = LookupRTE(Dest, Src, HOST_ROUTE_PRI);
if (NewRTE == NULL) {
// Can't get there any other way so leave this
// one alone.
RTE->rte_flags |= RTE_VALID;
} else {
// There is another route, so destroy this one. Use
// FindSpecificRTE to find the previous RTE.
TempRTE = FindSpecificRTE(RTE->rte_dest, RTE->rte_mask,
RTE->rte_addr, RTE->rte_if, &NewRTE);
CTEAssert(TempRTE == RTE);
DeleteRTE(NewRTE, TempRTE);
}
} else {
if (RTE->rte_mask == DEFAULT_MASK) {
// This is a default gateway. If we have more than one
// configured move to the next one.
if (DefGWConfigured > 1) {
// Have more than one. Try the next one. First
// invalidate any RCEs on this G/W.
InvalidateRCEChain(RTE);
if (DefGWActive == 1) {
// No more active. Revalidate all of them,
// and try again.
ValidateDefaultGWs(NULL_IP_ADDR);
CTEAssert(DefGWActive == DefGWConfigured);
} else {
// More than one active, so invalidate this
// one, and move to the next one. Stamp the
// next one with a valid time of Now, so we
// don't move from him too easily.
--DefGWActive;
RTE->rte_flags &= ~RTE_VALID;
RTE = FindRTE(Dest, Src, IPHash(0),
DEFAULT_ROUTE_PRI, DEFAULT_ROUTE_PRI);
if (RTE == NULL) {
// No more default gateways! This is bad.
CTEAssert(FALSE);
ValidateDefaultGWs(NULL_IP_ADDR);
CTEAssert(DefGWActive == DefGWConfigured);
} else {
CTEAssert(RTE->rte_mask == DEFAULT_MASK);
RTE->rte_valid = Now;
}
}
}
}
}
}
}
CTEFreeLock(&RouteTableLock, Handle);
}
}
//** FindRCE - Find an RCE on an RTE.
//
// A routine to find an RCE that's chained on an RTE. We assume the lock
// is held on the RTE.
//
// Entry: RTE - RTE to search.
// Dest - Destination address of RTE to find.
// Src - Source address of RTE to find.
//
// Returns: Pointer to RTE found, or NULL.
//
RouteCacheEntry *
FindRCE(RouteTableEntry *RTE, IPAddr Dest, IPAddr Src)
{
RouteCacheEntry *CurrentRCE;
CTEAssert(!IP_ADDR_EQUAL(Src, NULL_IP_ADDR));
for (CurrentRCE = RTE->rte_rcelist; CurrentRCE != NULL;
CurrentRCE = CurrentRCE->rce_next) {
if ( IP_ADDR_EQUAL(CurrentRCE->rce_dest, Dest) &&
IP_ADDR_EQUAL(CurrentRCE->rce_src, Src)) {
break;
}
}
return CurrentRCE;
}
//** OpenRCE - Open an RCE for a specific route.
//
// Called by the upper layer to open an RCE. We look up the type of the address
// - if it's invalid, we return 'Destination invalid'. If not, we look up the
// route, fill in the RCE, and link it on the correct RTE.
//
// As an added bonus, this routine will return the local address to use
// to reach the destination.
//
// Entry: Address - Address for which we are to open an RCE.
// Src - Source address we'll be using.
// RCE - Pointer to where to return pointer to RCE.
// Type - Pointer to where to return destination type.
// MSS - Pointer to where to return MSS for route.
// OptInfo - Pointer to option information, such as TOS and
// any source routing info.
//
// Returns: Source IP address to use. This will be NULL_IP_ADDR if the
// specified destination is unreachable for any reason.
//
IPAddr
OpenRCE(IPAddr Address, IPAddr Src, RouteCacheEntry **RCE, uchar *Type,
ushort *MSS, IPOptInfo *OptInfo)
{
RouteTableEntry *RTE; // Pointer to RTE to put RCE on.
CTELockHandle TableLock;
uchar LocalType;
if (!IP_ADDR_EQUAL(OptInfo->ioi_addr, NULL_IP_ADDR))
Address = OptInfo->ioi_addr;
CTEGetLock(&RouteTableLock, &TableLock);
// Make sure we're not in DHCP update.
if (DHCPActivityCount != 0) {
// We are updating DHCP. Just fail this now, since we're in an
// indeterminate state.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
LocalType = GetAddrType(Address);
*Type = LocalType;
// If the specified address isn't invalid, continue.
if (LocalType != DEST_INVALID) {
RouteCacheEntry *NewRCE;
// If he's specified a source address, loop through the NTE table
// now and make sure it's valid.
if (!IP_ADDR_EQUAL(Src, NULL_IP_ADDR)) {
NetTableEntry *NTE;
for (NTE = NetTableList; NTE != NULL; NTE = NTE->nte_next)
if ((NTE->nte_flags & NTE_VALID) &&
IP_ADDR_EQUAL(Src, NTE->nte_addr))
break;
if (NTE == NULL) {
// Didn't find a match.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
}
// Find the route for this guy. If we can't find one, return NULL.
RTE = LookupRTE(Address, Src, HOST_ROUTE_PRI);
if (RTE != (RouteTableEntry *)NULL) {
CTELockHandle RCEHandle;
RouteCacheEntry *OldRCE;
// We found one.
*MSS = (ushort)RTE->rte_mtu; // Return the route MTU.
if (IP_LOOPBACK_ADDR(Src) && (RTE->rte_if != &LoopInterface)) {
// The upper layer is sending from a loopback address, but the
// destination isn't reachable through the loopback interface.
// Fail the request.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
// We have the RTE. Fill in the RCE, and link it on the RTE.
if (!IP_ADDR_EQUAL(RTE->rte_addr, IPADDR_LOCAL))
*Type |= DEST_OFFNET_BIT; // Tell upper layer it's off
// net.
//
// If no source address was specified, then use the best address
// for the interface. This will generally prevent dynamic NTE's from
// being chosen as the source for wildcard binds.
//
if (IP_ADDR_EQUAL(Src, NULL_IP_ADDR)) {
if (LocalType == DEST_LOCAL)
Src = Address;
else {
NetTableEntry *SrcNTE;
SrcNTE = BestNTEForIF(
ADDR_FROM_RTE(RTE, Address),
RTE->rte_if
);
if (SrcNTE == NULL) {
// Can't find an address! Fail the request.
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
Src = SrcNTE->nte_addr;
}
}
// Now, see if an RCE already exists for this.
if ((OldRCE = FindRCE(RTE, Address, Src)) == NULL) {
// Don't have an existing RCE. See if we can get a new one,
// and fill it in.
NewRCE = CTEAllocMem(sizeof(RouteCacheEntry));
*RCE = NewRCE;
if (NewRCE != NULL) {
CTEMemSet(NewRCE, 0, sizeof(RouteCacheEntry));
NewRCE->rce_src = Src;
NewRCE->rce_dtype = LocalType;
NewRCE->rce_cnt = 1;
CTEInitLock(&NewRCE->rce_lock);
NewRCE->rce_dest = Address;
NewRCE->rce_rte = RTE;
NewRCE->rce_flags = RCE_VALID;
if (RTE->rte_flags & RTE_IF_VALID) {
NewRCE->rce_flags |= RCE_CONNECTED;
#ifdef _PNP_POWER
//* Update the ref. count for this interface.
NewRCE->rce_flags |= RCE_REFERENCED;
RTE->rte_if->if_refcount++;
#endif
}
NewRCE->rce_next = RTE->rte_rcelist;
RTE->rte_rcelist = NewRCE;
}
CTEFreeLock(&RouteTableLock, TableLock);
return Src;
} else {
// We have an existing RCE. We'll return his source as the
// valid source, bump the reference count, free the locks
// and return.
CTEGetLock(&OldRCE->rce_lock, &RCEHandle);
OldRCE->rce_cnt++;
*RCE = OldRCE;
CTEFreeLock(&OldRCE->rce_lock, RCEHandle);
CTEFreeLock(&RouteTableLock, TableLock);
return Src;
}
} else {
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
}
CTEFreeLock(&RouteTableLock, TableLock);
return NULL_IP_ADDR;
}
//* CloseRCE - Close an RCE.
//
// Called by the upper layer when it wants to close the RCE. We unlink it from
// the RTE.
//
// Entry: RCE - Pointer to the RCE to be closed.
//
// Exit: Nothing.
//
void
CloseRCE(RouteCacheEntry *RCE)
{
RouteTableEntry *RTE; // Route on which RCE is linked.
RouteCacheEntry *PrevRCE;
CTELockHandle TableLock; // Lock handles used.
CTELockHandle RCEHandle;
Interface *IF;
if (RCE != NULL) {
CTEGetLock(&RouteTableLock, &TableLock);
CTEGetLock(&RCE->rce_lock, &RCEHandle);
if (--RCE->rce_cnt == 0) {
CTEAssert(RCE->rce_usecnt == 0);
if (RCE->rce_flags & RCE_VALID) {
// The RCE is valid, so we have a valid RTE in the pointer
// field. Walk down the RTE rcelist, looking for this guy.
RTE = RCE->rce_rte;
IF = RTE->rte_if;
PrevRCE = STRUCT_OF(RouteCacheEntry, &RTE->rte_rcelist,
rce_next);
// Walk down the list until we find him.
while (PrevRCE != NULL) {
if (PrevRCE->rce_next == RCE)
break;
PrevRCE = PrevRCE->rce_next;
}
CTEAssert(PrevRCE != NULL);
PrevRCE->rce_next = RCE->rce_next;
} else
IF = (Interface *)RCE->rce_rte;
if (RCE->rce_flags & RCE_CONNECTED) {
(*(IF->if_invalidate))(IF->if_lcontext, RCE);
}
#ifdef _PNP_POWER
if (RCE->rce_flags & RCE_REFERENCED) {
LockedDerefIF(IF);
}
#endif
CTEFreeLock(&RCE->rce_lock, RCEHandle);
CTEFreeMem(RCE);
}
else {
CTEFreeLock(&RCE->rce_lock, RCEHandle);
}
CTEFreeLock(&RouteTableLock, TableLock);
}
}
//* LockedAddRoute - Add a route to the routing table.
//
// Called by AddRoute to add a route to the routing table. We assume the
// route table lock is already held. If the route to be added already exists
// we update it. Routes are identified by a (Destination, Mask, FirstHop,
// Interface) tuple. If an exact match exists we'll update the metric, which
// may cause us to promote RCEs from other RTEs, or we may be demoted in which
// case we'll invalidate our RCEs and let them be reassigned at transmission
// time.
//
// If we have to create a new RTE we'll do so, and find the best previous
// RTE, and promote RCEs from that one to the new one.
//
// The route table is an open hash structure. Within each hash chain the
// RTEs with the longest masks (the 'priority') come first, and within
// each priority the RTEs with the smallest metric come first.
//
//
// Entry: Destination - Destination address for which route is being
// added.
// Mask - Mask for destination.
// FirstHop - First hop for address. Could be IPADDR_LOCAL.
// OutIF - Pointer to outgoing I/F.
// MTU - Maximum MTU for this route.
// Metric - Metric for this route.
// Proto - Protocol type to store in route.
// AType - Administrative type of route.
//
// Returns: Status of attempt to add route.
//
IP_STATUS
LockedAddRoute(IPAddr Destination, IPMask Mask, IPAddr FirstHop,
Interface *OutIF, uint MTU, uint Metric, uint Proto, uint AType,
ROUTE_CONTEXT Context)
{
uint RouteType; // SNMP route type.
RouteTableEntry *NewRTE, *OldRTE; // Entries for new and previous
// RTEs.
RouteTableEntry *PrevRTE; // Pointer to previous RTE.
CTELockHandle RCEHandle; // Lock handle for RCEs.
uint OldMetric; // Previous metric in use.
uint OldPriority; // Priority of previous route to
// destination.
RouteCacheEntry *CurrentRCE; // Current RCE being examined.
RouteCacheEntry *PrevRCE; // Previous RCE examined.
Interface *IF; // Interface being added on.
uint Priority; // Priority of the route.
uint TempMask; // Temporary copy of the mask.
uint Now = CTESystemUpTime() / 1000L; // System up time,
// in seconds.
uint MoveAny; // TRUE if we'll move any RCE.
ushort OldFlags;
// First do some consistency checks. Make sure that the Mask and
// Destination agree.
if (!IP_ADDR_EQUAL(Destination & Mask, Destination))
return IP_BAD_DESTINATION;
if (AType != ATYPE_PERM && AType != ATYPE_OVERRIDE && AType != ATYPE_TEMP)
return IP_BAD_REQ;
#ifdef _PNP_POWER
// If the interface is marked as going away, fail this.
if (OutIF->if_flags & IF_FLAGS_DELETING) {
return IP_BAD_REQ;
}
#endif
RouteType = IP_ADDR_EQUAL(FirstHop, IPADDR_LOCAL) ? IRE_TYPE_DIRECT :
IRE_TYPE_INDIRECT;
MTU = MAX(MTU, MIN_VALID_MTU);
// If the outgoing interface has NTEs attached but none are valid, fail
// this request unless it's a request to add the broadcast route.
if (OutIF != (Interface *)&DummyInterface) {
if (OutIF->if_ntecount == 0 && OutIF->if_nte != NULL &&
!IP_ADDR_EQUAL(Destination, OutIF->if_bcast) ) {
// This interface has NTEs attached, but none are valid. Fail the
// request.
return IP_BAD_REQ;
}
}
// First look and see if the RTE already exists.
NewRTE = FindSpecificRTE(Destination, Mask, FirstHop, OutIF, &PrevRTE);
if (NewRTE != NULL) {
// The RTE already exists, and we have a lock on it. See if we're
// updating the metric. If we're not, just return. Otherwise
// we'll remove the RTE and update the metric. If the metric is
// increasing, walk down the RCE chain on the RTE and invalidate
// the RCE back pointers so that they'll be revalidated upon
// transmits, and then reinsert the RTE. If the metric is
// decreasing we'll just fall through to the case below where we'll
// promote RCEs and insert the RTE.
// Update the things that won't cause routing table motion.
NewRTE->rte_mtu = MTU;
NewRTE->rte_proto = Proto;
NewRTE->rte_valid = Now;
NewRTE->rte_mtuchange = Now;
NewRTE->rte_context = Context;
OldFlags = NewRTE->rte_flags;
// We always turn off the increase flag when a route is updated, so
// that we take the long timeout to try to increase it. We also
// always turn on the valid flag.
NewRTE->rte_flags = (OldFlags & ~RTE_INCREASE) | RTE_VALID;
if (OutIF != (Interface *)&DummyInterface) {
NewRTE->rte_flags |= RTE_IF_VALID;
} else {
//
// Invalidating a previously valid route
//
NewRTE->rte_flags &= ~RTE_IF_VALID;
}
// If the RTE is for a default gateway and the old flags indicate
// he wasn't valid then we're essentially creating a new active
// default gateway. In the case bump the active default gateway count.
if (NewRTE->rte_mask == DEFAULT_MASK && !(OldFlags & RTE_VALID))
DefGWActive++;
// Need to update the metric, which will cause this RTE to move
// in the table.
OldMetric = NewRTE->rte_metric; // Save the old one.
RemoveRTE(PrevRTE, NewRTE); // Pull him from the chain.
NewRTE->rte_metric = Metric;
// Now see if we're increasing or decreasing the metric, or
// re-validating a previously invalid route. By definition, if the
// route wasn't valid before this there can't have been any RCEs
// attached to it, so we'll fall through to the promotion code
// and see if we can move any onto it. Otherwise, if we're
// demoting this route invalidate any RCEs on it.
if (Metric >= OldMetric && (OldFlags & RTE_VALID)) {
// We're increasing it, or leaving it the same. His valid state
// may have changed, so we'll we'll invalidate any RCEs on him
// now in any case.
InsertRTE(NewRTE);
InvalidateRCEChain(NewRTE);
//
// Whether the IF has changed or not, we can always overwrite it
// We wait till here to overwrite because if old rte_if was
// not dummy if, then we will want to invalidate RCEChain
// Since the invalidate function is stored in the interface
// structure we want to keep it around
//
NewRTE->rte_if = OutIF;
return IP_SUCCESS;
}
NewRTE->rte_if = OutIF;
// The metric is less than the old metric, so we're promoting this
// RTE. Fall through to the code below that deals with this, after
// saving the priority of the RTE.
Priority = NewRTE->rte_priority;
} else {
// Didn't find a matching RTE. Allocate a new one, and fill it in.
NewRTE = CTEAllocMem(sizeof(RouteTableEntry));
if (NewRTE == NULL) {
// Couldn't get the memory.
return IP_NO_RESOURCES;
}
IPSInfo.ipsi_numroutes++;
// Fill him in, and take the lock on him. To do this we'll need to
// calculate the priority.
Priority = 0;
TempMask = Mask;
while (TempMask) {
Priority += TempMask & 1;
TempMask >>= 1;
}
// Now initialize all of his fields.
NewRTE->rte_priority = Priority;
NewRTE->rte_dest = Destination;
NewRTE->rte_mask = Mask;
if (Mask == DEFAULT_MASK) {
// We're adding a default route.
DefGWConfigured++;
DefGWActive++;
}
NewRTE->rte_addr = FirstHop;
NewRTE->rte_metric = Metric;
NewRTE->rte_mtu = MTU;
NewRTE->rte_if = OutIF;
NewRTE->rte_rcelist = NULL;
NewRTE->rte_type = (ushort)RouteType;
NewRTE->rte_flags = RTE_VALID;
if (OutIF != (Interface *)&DummyInterface) {
NewRTE->rte_flags |= RTE_IF_VALID;
}
NewRTE->rte_proto = Proto;
NewRTE->rte_valid = Now;
NewRTE->rte_mtuchange = Now;
NewRTE->rte_admintype = AType;
NewRTE->rte_context = Context;
}
// At this point, NewRTE points to an initialized RTE that is not in the
// table. We hold the lock on NewRTE and on the RouteTable. First we'll
// find where we'll eventually insert the new RTE (we can't insert it
// yet, because we'll still need to search the table again and we can't
// do that while we hold a lock on an element in the table). Then we'll
// search the table for the next best route (i.e. a route with a priority
// less than or equal to ours), and if we find one we'll promote RCEs from
// that route to us. We'll actually have to search a chain of RTEs.
PrevRTE = FindInsertPoint(NewRTE);
OldRTE = LookupRTE(Destination, NULL_IP_ADDR, Priority);
// If we found one, try to promote from him.
if (OldRTE != NULL) {
// Found another RTE, and we have the lock on it. Starting with him,
// walk down the chain. At the start of this loop we know that the
// route described by OldRTE can reach our destination. If his metric
// is better than ours, we're done and we'll just insert our route.
// If his priority and metric are equal to ours we'll promote only
// those RCEs that exactly match our source address. Otherwise either
// his priority or metric is worse than ours, and we'll promote all
// appropriate RCEs.
//
// Since we specified the maximum priority in the call to LookupRTE
// as our priority, we know the priority of the route we found
// can't be greater than our priority.
OldMetric = OldRTE->rte_metric;
OldPriority = OldRTE->rte_priority;
// We'll do the search if his priority is less than ours, or his
// metric is > (i.e. worse than) our metric, or his metric equals
// our metric and the old route is on a different interface. We
// know OldPriority is <= our Priority, since we specified our
// priority in the call to LookupRTE above.
CTEAssert(OldPriority <= Priority);
if (OldPriority < Priority || OldMetric > Metric ||
(OldMetric == Metric && OldRTE->rte_if != OutIF)) {
// We're going to search. Figure out the mask to use in comparing
// source addresses.
if (OldPriority == Priority && OldMetric == Metric)
MoveAny = FALSE; // Only promote an exact match.
else
MoveAny = TRUE; // Promote any match.
for (;;) {
IF = OldRTE->rte_if;
PrevRCE = STRUCT_OF(RouteCacheEntry, &OldRTE->rte_rcelist,
rce_next);
CurrentRCE = PrevRCE->rce_next;
// Walk the list, promoting any that match.
while (CurrentRCE != NULL) {
CTEGetLock(&CurrentRCE->rce_lock, &RCEHandle);
// If the masked source address matches our masked address,
// and the destinations match, promote him.
if ((MoveAny || AddrOnIF(OutIF, CurrentRCE->rce_src)) &&
IP_ADDR_EQUAL(CurrentRCE->rce_dest & Mask, Destination)) {
// He matches. Pull him from the list and mark him as invalid.
// This will force a new lookup of the route next time he's
// used, which as a side effect will cause the route to be
// connected in the dial-on-demand case.
CTEAssert(CurrentRCE->rce_flags & RCE_VALID);
PrevRCE->rce_next = CurrentRCE->rce_next;
CurrentRCE->rce_flags &= ~RCE_VALID;
CurrentRCE->rce_rte = (RouteTableEntry *)IF;
if (CurrentRCE->rce_usecnt == 0) {
// No one's currently using him, so invalidate him.
if (CurrentRCE->rce_flags & RCE_CONNECTED) {
(*(IF->if_invalidate))(IF->if_lcontext, CurrentRCE);
#ifdef _PNP_POWER
if (CurrentRCE->rce_flags & RCE_REFERENCED) {
LockedDerefIF(IF);
CurrentRCE->rce_flags &= ~RCE_REFERENCED;
}
#endif
} else {
#ifdef _PNP_POWER
CTEAssert(!(CurrentRCE->rce_flags & RCE_REFERENCED));
#endif
}
}
} else {
// Doesn't match. Try the next one.
PrevRCE = CurrentRCE;
}
CTEFreeLock(&CurrentRCE->rce_lock, RCEHandle);
CurrentRCE = PrevRCE->rce_next;
}
// We've walked the RCE list on that old RTE. Look at the
// next one. If it has the same priority and metric as the
// old one, and also matches our destination, check it also. We
// don't need to RTEs that don't match this criteria, since we know
// RCEs are always kept on the 'best' RTE.
OldRTE = OldRTE->rte_next;
if (OldRTE != NULL) {
// We have another one. Check it out.
if (OldRTE->rte_priority == Priority &&
OldRTE->rte_metric == OldMetric &&
IP_ADDR_EQUAL(Destination & OldRTE->rte_mask,
OldRTE->rte_dest))
continue; // It matches, so try to promote
// RCEs.
}
break; // Exit out of the for (;;) loop.
}
} else {
// OldRTE is a better route than the one we're inserting, so don't
// do anything.
}
}
// At this point we're promoted any routes we need to, we hold the lock
// on NewRTE which still isn't inserted, and PrevRTE describes where to
// insert NewRTE. Insert it, free the lock, and return success.
InsertAfterRTE(PrevRTE, NewRTE);
return IP_SUCCESS;
}
//* AddRoute - Add a route to the routing table.
//
// This is just a shell for the real add route routine. All we do is take
// the route table lock, and call the LockedAddRoute routine to deal with
// the request. This is done this way because there are certain routines that
// need to be able to atomically examine and add routes.
//
// Entry: Destination - Destination address for which route is being
// added.
// Mask - Mask for destination.
// FirstHop - First hop for address. Could be IPADDR_LOCAL.
// OutIF - Pointer to outgoing I/F.
// MTU - Maximum MTU for this route.
// Metric - Metric for this route.
// Proto - Protocol type to store in route.
// AType - Administrative type of route.
// Context - Context for this route.
//
// Returns: Status of attempt to add route.
//
IP_STATUS
AddRoute(IPAddr Destination, IPMask Mask, IPAddr FirstHop,
Interface *OutIF, uint MTU, uint Metric, uint Proto, uint AType,
ROUTE_CONTEXT Context)
{
CTELockHandle TableHandle;
IP_STATUS Status;
CTEGetLock(&RouteTableLock, &TableHandle);
Status = LockedAddRoute(Destination, Mask, FirstHop, OutIF, MTU, Metric,
Proto, AType, Context);
CTEFreeLock(&RouteTableLock, TableHandle);
return Status;
}
//* DeleteRoute - Delete a route from the routing table.
//
// Called by upper layer or management code to delete a route from the routing
// table. If we can't find the route we return an error. If we do find it, we
// remove it, and invalidate any RCEs associated with it. These RCEs will be
// reassigned the next time they're used. A route is uniquely identified by
// a (Destination, Mask, FirstHop, Interface) tuple.
//
// Entry: Destination - Destination address for which route is being
// deleted.
// Mask - Mask for destination.
// FirstHop - First hop on way to Destination. -1 means route is
// local.
// OutIF - Outgoing interface for route.
//
// Returns: Status of attempt to delete route.
//
IP_STATUS
DeleteRoute(IPAddr Destination, IPMask Mask, IPAddr FirstHop, Interface *OutIF)
{
RouteTableEntry *RTE; // RTE being deleted.
RouteTableEntry *PrevRTE; // Pointer to RTE in front of one
// being deleted.
CTELockHandle TableLock; // Lock handle for table.
// Look up the route by calling FindSpecificRTE. If we can't find it,
// fail the call.
CTEGetLock(&RouteTableLock, &TableLock);
RTE = FindSpecificRTE(Destination, Mask, FirstHop, OutIF, &PrevRTE);
if (RTE == NULL) {
// Didn't find the route, so fail the call.
CTEFreeLock(&RouteTableLock, TableLock);
return IP_BAD_ROUTE;
}
#ifndef NT
//
// Disable admin check for NT, because the RAS server needs to be able to
// delete a subnet route. This ability is restricted to Administrators only
// by NT security checks.
//
//
if (RTE->rte_admintype == ATYPE_PERM) {
// Can't delete a permanent route.
CTEFreeLock(&RouteTableLock, TableLock);
return IP_BAD_REQ;
}
#endif
// When we reach here we hold the lock on the RTE to be deleted, and
// PrevRTE points to the RTE immediately ahead of ours in the table.
// Call DeleteRTE to delete him.
DeleteRTE(PrevRTE, RTE);
CTEFreeLock(&RouteTableLock, TableLock);
return IP_SUCCESS;
}
//** Redirect - Process a redirect request.
//
// This is the redirect handler . We treat all redirects as host redirects as per the
// host requirements RFC. We make a few sanity checks on the new first hop address, and then
// we look up the current route. If it's not through the source of the redirect, just return.
// If the current route to the destination is a host route, update the first hop and return.
// If the route is not a host route, remove any RCE for this route from the RTE, create a
// host route and place the RCE (if any) on the new RTE.
//
// Entry: NTE - Pointer to NetTableEntry for net on which Redirect
// arrived.
// RDSrc - IPAddress of source of redirect.
// Target - IPAddress being redirected.
// Src - Src IP address of DG that triggered RD.
// FirstHop - New first hop for Target.
//
// Returns: Nothing.
//
void
Redirect(NetTableEntry *NTE, IPAddr RDSrc, IPAddr Target, IPAddr Src,
IPAddr FirstHop)
{
uint MTU;
RouteTableEntry *RTE;
CTELockHandle Handle;
if (IP_ADDR_EQUAL(FirstHop, NULL_IP_ADDR) || IP_LOOPBACK(FirstHop))
return; // Can't redirect to loopback
// address.
CTEAssert(IP_ADDR_EQUAL(NTE->nte_addr, Src));
// First make sure that this came from the gateway we're currently using to
// get to Target, and then lookup up the route to the new first hop. The new
// firsthop must be directly reachable, and on the same subnetwork or
// physical interface on which we received the redirect.
CTEGetLock(&RouteTableLock, &Handle);
// Make sure the source of the redirect is the current first hop gateway.
RTE = LookupRTE(Target, Src, HOST_ROUTE_PRI);
if (RTE == NULL || IP_ADDR_EQUAL(RTE->rte_addr, IPADDR_LOCAL) ||
!IP_ADDR_EQUAL(RTE->rte_addr, RDSrc)) {
CTEFreeLock(&RouteTableLock, Handle);
return; // A bad redirect.
}
CTEAssert(RTE->rte_flags & RTE_IF_VALID);
// If the current first hop gateway is a default gateway, see if we have
// another default gateway at FirstHop that is down. If so, mark him as
// up and invalidate the RCEs on this guy.
if (RTE->rte_mask == DEFAULT_MASK && ValidateDefaultGWs(FirstHop) != 0) {
// Have a default gateway that's been newly activated. Invalidate RCEs
// on the route, and we're done.
InvalidateRCEChain(RTE);
CTEFreeLock(&RouteTableLock, Handle);
return;
}
// We really need to add a host route through FirstHop. Make sure he's
// a valid first hop.
RTE = LookupRTE(FirstHop, Src, HOST_ROUTE_PRI);
if (RTE == NULL) {
CTEFreeLock(&RouteTableLock, Handle);
return; // Can't get there from here.
}
CTEAssert(RTE->rte_flags & RTE_IF_VALID);
// Check to make sure the new first hop is directly reachable, and is on the
// same subnet or physical interface we received the redirect on.
if (!IP_ADDR_EQUAL(RTE->rte_addr, IPADDR_LOCAL) || // Not directly reachable
// or wrong subnet.
((NTE->nte_addr & NTE->nte_mask) != (FirstHop & NTE->nte_mask))) {
CTEFreeLock(&RouteTableLock, Handle);
return;
}
MTU = RTE->rte_mtu;
// Now add a host route. AddRoute will do the correct things with shifting
// RCEs around. We know that FirstHop is on the same subnet as NTE (from
// the check above), so it's valid to add the route to FirstHop as out
// going through NTE.
LockedAddRoute(Target, HOST_MASK, IP_ADDR_EQUAL(FirstHop, Target) ? IPADDR_LOCAL :
FirstHop, NTE->nte_if, MTU, 1, IRE_PROTO_ICMP, ATYPE_OVERRIDE,
RTE->rte_context);
CTEFreeLock(&RouteTableLock, Handle);
}
//* GetRaisedMTU - Get the next largest MTU in table..
//
// A utility function to search the MTU table for a larger value.
//
// Input: PrevMTU - MTU we're currently using. We want the
// next largest one.
//
// Returns: New MTU size.
//
uint
GetRaisedMTU(uint PrevMTU)
{
uint i;
for (i = (sizeof(MTUTable)/sizeof(uint)) - 1; i != 0; i--) {
if (MTUTable[i] > PrevMTU)
break;
}
return MTUTable[i];
}
//* GuessNewMTU - Guess a new MTU, giving a DG size too big.
//
// A utility function to search the MTU table. As input we take in an MTU
// size we believe to be too large, and search the table looking for the
// next smallest one.
//
// Input: TooBig - Size that's too big.
//
// Returns: New MTU size.
//
uint
GuessNewMTU(uint TooBig)
{
uint i;
for (i = 0; i < ((sizeof(MTUTable)/sizeof(uint)) - 1); i++)
if (MTUTable[i] < TooBig)
break;
return MTUTable[i];
}
//* RouteFragNeeded - Handle being told we need to fragment.
//
// Called when we receive some external indication that we need to fragment
// along a particular path. If we're doing MTU discovery we'll try to
// update the route, if we can. We'll also notify the upper layers about
// the new MTU.
//
// Input: IPH - Pointer to IP Header of datagram needing
// fragmentation.
// NewMTU - New MTU to be used (may be 0).
//
// Returns: Nothing.
//
void
RouteFragNeeded(IPHeader UNALIGNED *IPH, ushort NewMTU)
{
uint OldMTU;
CTELockHandle Handle;
RouteTableEntry *RTE;
ushort HeaderLength;
// If we're not doing PMTU discovery, don't do anything.
if (PMTUDiscovery) {
// We're doing PMTU discovery. Correct the given new MTU for the IP
// header size, which we don't save as we track MTUs.
if (NewMTU != 0) {
// Make sure the new MTU we got is at least the minimum valid size.
NewMTU = MAX(NewMTU, MIN_VALID_MTU);
NewMTU -= sizeof(IPHeader);
}
HeaderLength = (IPH->iph_verlen & (uchar)~IP_VER_FLAG) << 2;
// Get the current routing information.
CTEGetLock(&RouteTableLock, &Handle);
// Find an RTE for the destination.
RTE = LookupRTE(IPH->iph_dest, IPH->iph_src, HOST_ROUTE_PRI);
// If we couldn't find one, or the existing MTU is less than the new
// MTU, give up now.
if (RTE == NULL || (OldMTU = RTE->rte_mtu) < NewMTU) {
// No RTE, or an invalid new MTU. Just bail out now.
CTEFreeLock(&RouteTableLock, Handle);
return;
}
// If the new MTU is zero, figure out what the new MTU should be.
if (NewMTU == 0) {
ushort DGLength;
// The new MTU is zero. We'll make a best guess what the new
// MTU should be. We have the RTE for this route already.
// Get the length of the datagram that triggered this. Since we'll
// be comparing it against MTU values that we track without the
// IP header size included, subtract off that amount.
DGLength = (ushort)net_short(IPH->iph_length) - sizeof(IPHeader);
// We may need to correct this as per RFC 1191 for dealing with
// old style routers.
if (DGLength >= OldMTU) {
// The length of the datagram sent is not less than our
// current MTU estimate, so we need to back it down (assuming
// that the sending route has incorrectly added in the header
// length).
DGLength -= HeaderLength;
}
// If it's still larger than our current MTU, use the current
// MTU. This could happen if the upper layer sends a burst of
// packets which generate a sequence of ICMP discard messages. The
// first one we receive will cause us to lower our MTU. We then
// want to discard subsequent messages to avoid lowering it
// too much. This could conceivably be a problem if our
// first adjustment still results in an MTU that's too big,
// but we should converge adequately fast anyway, and it's
// better than accidentally underestimating the MTU.
if (DGLength > OldMTU)
NewMTU = OldMTU;
else
// Move down the table to the next lowest MTU.
NewMTU = GuessNewMTU(DGLength);
}
// We have the new MTU. Now add it to the table as a host route.
if (NewMTU != OldMTU)
LockedAddRoute(IPH->iph_dest, HOST_MASK, RTE->rte_addr, RTE->rte_if,
NewMTU, RTE->rte_metric, IRE_PROTO_ICMP, ATYPE_OVERRIDE,
RTE->rte_context);
CTEFreeLock(&RouteTableLock, Handle);
// We've added the route. Now notify the upper layers of the change.
ULMTUNotify(IPH->iph_dest, IPH->iph_src, IPH->iph_protocol,
(void *)((uchar *)IPH + HeaderLength), NewMTU);
}
}
//** IPRouteTimeout - IP routeing timeout handler.
//
// The IP routeing timeout routine, called once a minute. We look at all
// host routes, and if we raise the MTU on them we do so.
//
// Entry: Timer - Timer being fired.
// Context - Pointer to NTE being time out.
//
// Returns: Nothing.
//
void
IPRouteTimeout(CTEEvent *Timer, void *Context)
{
uint Now = CTESystemUpTime() / 1000L;
CTELockHandle Handle;
uint i;
RouteTableEntry *RTE, *PrevRTE;
uint RaiseMTU, Delta;
Interface *IF;
IPAddr Dest;
uint NewMTU;
NetTableEntry *NTE;
CTEGetLock(&RouteTableLock, &Handle);
for (i = 0; i < ROUTE_TABLE_SIZE; i++) {
// Walk down each chain, looking at the host routes. If we're
// doing PMTU discovery, see if we can raise the MTU.
PrevRTE = STRUCT_OF(RouteTableEntry, &RouteTable[i], rte_next);
RTE = RouteTable[i];
while (RTE != NULL && RTE->rte_mask == HOST_MASK) {
// Make sure he's valid.
if (RTE->rte_flags & RTE_VALID) {
if (PMTUDiscovery) {
// Check to see if we can raise the MTU on this guy.
Delta = Now - RTE->rte_mtuchange;
if (RTE->rte_flags & RTE_INCREASE)
RaiseMTU = (Delta >= MTU_INCREASE_TIME ? 1 : 0);
else
RaiseMTU = (Delta >= MTU_DECREASE_TIME ? 1 : 0);
if (RaiseMTU) {
// We need to raise this MTU. Set his change time to
// Now, so we don't do this again, and figure out
// what the new MTU should be.
RTE->rte_mtuchange = Now;
IF = RTE->rte_if;
if (RTE->rte_mtu < IF->if_mtu) {
RTE->rte_flags |= RTE_INCREASE;
// This is a candidate for change. Figure out
// what it should be.
NewMTU = MIN(GetRaisedMTU(RTE->rte_mtu),
IF->if_mtu);
RTE->rte_mtu = NewMTU;
Dest = RTE->rte_dest;
// We have the new MTU. Free the lock, and walk
// down the NTEs on the I/F. For each NTE,
// call up to the upper layer and tell him what
// his new MTU is.
CTEFreeLock(&RouteTableLock, Handle);
NTE = IF->if_nte;
while (NTE != NULL) {
if (NTE->nte_flags & NTE_VALID) {
ULMTUNotify(Dest, NTE->nte_addr, 0, NULL,
MIN(NewMTU, NTE->nte_mss));
}
NTE = NTE->nte_ifnext;
}
// We've notified everyone. Get the lock again,
// and start from the first element of this
// chain in case something's changed after we
// free the lock. We've updated the mtuchange
// time of this RTE, so we won't hit him again.
CTEGetLock(&RouteTableLock, &Handle);
PrevRTE = STRUCT_OF(RouteTableEntry, &RouteTable[i],
rte_next);
RTE = RouteTable[i];
continue;
} else
RTE->rte_flags &= ~RTE_INCREASE;
}
}
// If this route came in via ICMP, and we have no RCEs on it,
// and it's at least 10 minutes old, delete it.
if (RTE->rte_proto == IRE_PROTO_ICMP &&
RTE->rte_rcelist == NULL &&
(Now - RTE->rte_valid) > MAX_ICMP_ROUTE_VALID) {
// He needs to be deleted. Call DeleteRTE to do this.
DeleteRTE(PrevRTE, RTE);
RTE = PrevRTE->rte_next;
continue;
}
}
PrevRTE = RTE;
RTE = RTE->rte_next;
}
}
CTEFreeLock(&RouteTableLock, Handle);
CTEStartTimer(&IPRouteTimer, IP_ROUTE_TIMEOUT, IPRouteTimeout, NULL);
}
//* FreeFWPacket - Free a forwarding packet when we're done with it.
//
//
// Input: Packet - Packet to be freed.
//
// Returns: Nothing.
//
void
FreeFWPacket(PNDIS_PACKET Packet)
{
CTELockHandle Handle;
FWContext *FWC;
// BUGBUG - Portability issue
#ifdef VXD
Packet->Private.Head = (PNDIS_BUFFER)NULL;
Packet->Private.Count = 0;
Packet->Private.PhysicalCount = 0;
Packet->Private.TotalLength = 0;
#else // VXD
#ifdef NT
//
// BUGBUG: This is inefficient. Need something better.
//
NdisReinitializePacket(Packet);
#else // NT
#error Need portable way to do this.
#endif // NT
#endif // VXD
FWC = (FWContext *)Packet->ProtocolReserved;
if (FWC->fc_options) {
CTEFreeMem(FWC->fc_options);
FWC->fc_options = (uchar *)NULL;
}
if (FWC->fc_buffhead) {
CTEGetLock(&FWBufFreeLock, &Handle);
FWC->fc_bufftail->Next = FWBufFree; // BUGBUG more portable.
FWBufFree = FWC->fc_buffhead;
CTEFreeLock(&FWBufFreeLock, Handle);
FWC->fc_buffhead = (PNDIS_BUFFER)NULL;
}
#ifdef _PNP_POWER
// If there's an interface pointer here, dereference in now.
if (FWC->fc_if != NULL) {
DerefIF(FWC->fc_if);
FWC->fc_if = NULL;
}
#endif
CTEGetLock(&FWPacketFreeLock, &Handle);
FWC->fc_pc.pc_common.pc_link = FWPacketFree;
FWPacketFree = Packet;
CTEFreeLock(&FWPacketFreeLock, Handle);
}
//* GrowFWPackets - Grow the FW packet list, if we can.
//
// Called when we need to allocate a FW packet, but don't have one. We'll try to grow the
// FWPacket list now.
//
// Input: Nothing.
//
// Returns: TRUE if we succeeded in growing the list, FALSE otherwise.
//
uint
GrowFWPackets(void)
{
CTELockHandle Handle;
IPHeader *HeaderPtr;
NDIS_HANDLE BufferPool;
NDIS_HANDLE PacketPool;
PNDIS_BUFFER Buffer;
PNDIS_PACKET Packet;
NDIS_STATUS Status;
uint i;
uint AmountToGrow;
CTEGetLock(&FWPacketFreeLock, &Handle);
AmountToGrow = MIN(MaxFWPackets - CurrentFWPackets, FWPACKET_GROW_AMOUNT);
HeaderPtr = NULL;
if (AmountToGrow != 0) {
// We have room to grow yet, so try to. First get the memory for our header buffers.
HeaderPtr = CTEAllocMem(AmountToGrow * sizeof(IPHeader));
if (HeaderPtr == (IPHeader *)NULL)
goto failure; // Couldn't get it.
// Now try to get NDIS buffers for the headers.
NdisAllocateBufferPool(&Status, &BufferPool, AmountToGrow);
if (Status != NDIS_STATUS_SUCCESS) {
goto failure;
}
// Now try to get the packets themselves.
NdisAllocatePacketPool(&Status, &PacketPool, AmountToGrow, sizeof(FWContext));
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreeBufferPool(BufferPool);
goto failure;
}
// Since we have everything we need, update the current count.
CurrentFWPackets += AmountToGrow;
CTEFreeLock(&FWPacketFreeLock, Handle);
// We got the resources we need. Loop through and put them on.
for (i = 0; i < AmountToGrow; i++) {
FWContext *FWC;
NdisAllocateBuffer(&Status, &Buffer, BufferPool, HeaderPtr,
sizeof(IPHeader));
if (Status != NDIS_STATUS_SUCCESS)
CTEAssert(FALSE);
NdisAllocatePacket(&Status, &Packet, PacketPool);
if (Status != NDIS_STATUS_SUCCESS)
CTEAssert(FALSE);
CTEMemSet(Packet->ProtocolReserved, 0, sizeof(FWContext));
FWC = (FWContext *)Packet->ProtocolReserved;
FWC->fc_hndisbuff = Buffer;
FWC->fc_hbuff = HeaderPtr;
FWC->fc_pc.pc_common.pc_flags = PACKET_FLAG_FW;
FWC->fc_pc.pc_common.pc_owner = PACKET_OWNER_IP;
FWC->fc_pc.pc_pi = RtPI;
FWC->fc_pc.pc_context = Packet;
FreeFWPacket(Packet);
HeaderPtr++;
}
return TRUE;
}
failure:
CTEFreeLock(&FWPacketFreeLock, Handle);
if (HeaderPtr != NULL) {
CTEFreeMem(HeaderPtr);
}
return FALSE;
}
//* GrowFWBuffer - Grow the FW buffer pool, if we can.
//
// Called when we need to grow the FW buffer pool. We'll grow it up to the maximum size
// specified by the user.
//
// Input: Nothing.
//
// Returns: TRUE if we succeeded in growing the pool, FALSE otherwise.
//
uint
GrowFWBuffer(void)
{
CTELockHandle Handle;
uint AvailableBufferSpace;
uint NewBufferCount;
uint i;
uchar *BufferPtr = NULL;
NDIS_STATUS Status;
PNDIS_BUFFER Buffer;
NDIS_HANDLE BufferPool;
CTEGetLock(&FWPacketFreeLock, &Handle);
AvailableBufferSpace = MIN(MaxFWBufferSize - CurrentFWBufferSize, FW_BUF_GROW_AMOUNT);
// If we have room to grow, do so.
if (AvailableBufferSpace >= FW_BUF_SIZE) {
// We have room to grow the buffer, so do so. First, round to a multiple of our
// FW buffer size.
NewBufferCount = AvailableBufferSpace / FW_BUF_SIZE;
AvailableBufferSpace = NewBufferCount * FW_BUF_SIZE;
// Allocate the resources we need.
BufferPtr = CTEAllocMem(AvailableBufferSpace);
if (BufferPtr == NULL) {
goto failure;
}
NdisAllocateBufferPool(&Status, &BufferPool, NewBufferCount);
if (Status != NDIS_STATUS_SUCCESS) {
goto failure;
}
// We got what we needed. Now loop through and put them on the list.
for (i = 0; i < NewBufferCount; i++) {
NdisAllocateBuffer(&Status, &Buffer, BufferPool, BufferPtr, FW_BUF_SIZE);
if (Status != NDIS_STATUS_SUCCESS)
CTEAssert(FALSE);
Buffer->Next = FWBufFree;
FWBufFree = Buffer;
BufferPtr += FW_BUF_SIZE;
}
CurrentFWBufferSize += AvailableBufferSpace;
CTEFreeLock(&FWPacketFreeLock, Handle);
return TRUE;
}
failure:
CTEFreeLock(&FWPacketFreeLock, Handle);
if (BufferPtr != NULL) {
CTEFreeMem(BufferPtr);
}
return FALSE;
}
//* FWSendComplete - Complete the transmission of a forwarded packet.
//
// This is called when the send of a forwarded packet is done. We'll free the resources
// and get the next send going, if there is one. If there isn't, we'll decrement the pending
// count.
//
// Input: Packet - Packet being completed.
// Buffer - Pointer to buffer chain being completed.
//
// Returns: Nothing.
//
void
FWSendComplete(void *SendContext, PNDIS_BUFFER Buffer)
{
PNDIS_PACKET Packet = (PNDIS_PACKET)SendContext;
FWContext *FWC = (FWContext *)Packet->ProtocolReserved;
RouteSendQ *RSQ;
CTELockHandle Handle;
FWQ *NewFWQ;
PNDIS_PACKET NewPacket;
#ifdef DEBUG
if (!Buffer)
DEBUGCHK;
#endif
if (!IS_BCAST_DEST(FWC->fc_dtype))
RSQ = &((RouteInterface *)FWC->fc_if)->ri_q;
else
RSQ = BCastRSQ;
FreeFWPacket(Packet);
CTEGetLock(&RSQ->rsq_lock, &Handle);
CTEAssert(RSQ->rsq_pending <= RSQ->rsq_maxpending);
RSQ->rsq_pending--;
CTEAssert(*(int *)&RSQ->rsq_pending >= 0);
if (RSQ->rsq_qlength != 0) { // Have more to send.
// Make sure we're not already running through this. If we are, quit.
if (!RSQ->rsq_running) {
// We could schedule this off for an event, but under NT that
// could me a context switch for every completing packet in the
// normal case. For now, just do it in a loop guarded with
// rsq_running.
RSQ->rsq_running = TRUE;
// Loop while we haven't hit our send limit and we still have
// stuff to send.
while (RSQ->rsq_pending < RSQ->rsq_maxpending &&
RSQ->rsq_qlength != 0) {
#ifdef DEBUG
if (RSQ->rsq_qh.fq_next == &RSQ->rsq_qh)
DEBUGCHK; // Empty Q!
#endif
// Pull one off the queue, and update qlength.
NewFWQ = RSQ->rsq_qh.fq_next;
RSQ->rsq_qh.fq_next = NewFWQ->fq_next;
NewFWQ->fq_next->fq_prev = NewFWQ->fq_prev;
RSQ->rsq_qlength--;
// Update pending before we send.
RSQ->rsq_pending++;
CTEFreeLock(&RSQ->rsq_lock, Handle);
NewPacket = PACKET_FROM_FWQ(NewFWQ);
TransmitFWPacket(NewPacket,
((FWContext *)NewPacket->ProtocolReserved)->fc_datalength);
CTEGetLock(&RSQ->rsq_lock, &Handle);
}
RSQ->rsq_running = FALSE;
}
}
CTEFreeLock(&RSQ->rsq_lock, Handle);
}
//* TransmitFWPacket - Transmit a forwarded packet on a link.
//
// Called when we know we can send a packet. We fix up the header, and send it.
//
// Input: Packet - Packet to be sent.
// DataLength - Length of data.
//
// Returns: Nothing.
//
void
TransmitFWPacket(PNDIS_PACKET Packet, uint DataLength)
{
FWContext *FC = (FWContext *)Packet->ProtocolReserved;
PNDIS_BUFFER HBuffer, Buffer;
IP_STATUS Status;
PVOID VirtualAddress;
UINT BufLen;
// Fix up the packet. Remove the existing buffer chain, and put our header on
// the front.
// BUGBUG - Get NDIS fixed to make this portable.
#ifdef VXD
Buffer = Packet->Private.Head;
HBuffer = FC->fc_hndisbuff;
Packet->Private.Head = HBuffer;
Packet->Private.Tail = HBuffer;
HBuffer->Next = (PNDIS_BUFFER)NULL;
Packet->Private.TotalLength = sizeof(IPHeader);
Packet->Private.Count = 1;
Packet->Private.PhysicalCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(HBuffer->VirtualAddress,
sizeof(IPHeader));
#else // VXD
#ifdef NT
Buffer = Packet->Private.Head;
HBuffer = FC->fc_hndisbuff;
Packet->Private.Head = HBuffer;
Packet->Private.Tail = HBuffer;
NDIS_BUFFER_LINKAGE(HBuffer) = (PNDIS_BUFFER)NULL;
Packet->Private.TotalLength = sizeof(IPHeader);
Packet->Private.Count = 1;
NdisQueryBuffer(HBuffer, &VirtualAddress, &BufLen);
Packet->Private.PhysicalCount =
ADDRESS_AND_SIZE_TO_SPAN_PAGES(
VirtualAddress,
sizeof(IPHeader)
);
#else // NT
#error HELP! Need to make this code portable.
#endif // NT
#endif // VXD
// Figure out how to send it. If it's not a broadcast we'll either send it or
// have it fragmented. If it is a broadcast we'll let our send broadcast routine
// handle it.
if (FC->fc_dtype != DEST_BCAST) {
if ((DataLength + (uint)FC->fc_optlength) <= FC->fc_mtu)
Status = SendIPPacket(FC->fc_if, FC->fc_nexthop, Packet, Buffer,
FC->fc_hbuff, FC->fc_options, (uint)FC->fc_optlength);
else { // Need to fragment this.
BufferReference *BR = CTEAllocMem(sizeof(BufferReference));
if (BR == (BufferReference *)NULL) { // Couldn't get a BufferReference
FWSendComplete(Packet, Buffer);
return;
}
BR->br_buffer = Buffer;
BR->br_refcount = 0;
CTEInitLock(&BR->br_lock);
FC->fc_pc.pc_br = BR;
Status = IPFragment(FC->fc_if, FC->fc_mtu, FC->fc_nexthop, Packet,
FC->fc_hbuff, Buffer, DataLength, FC->fc_options,
(uint)FC->fc_optlength, (int *)NULL);
//
// Fragmentation needed with the DF flag set should have been
// handled in IPForward. We don't have the original header
// any longer, so silently drop the packet.
//
CTEAssert(Status != IP_PACKET_TOO_BIG);
}
} else
Status = SendIPBCast(FC->fc_srcnte, FC->fc_nexthop, Packet, FC->fc_hbuff,
Buffer, DataLength, FC->fc_options, (uint)FC->fc_optlength,
FC->fc_sos, &FC->fc_index);
if (Status != IP_PENDING)
FWSendComplete(Packet, Buffer);
}
//* SendFWPacket - Send a packet that needs to be forwarded.
//
// This routine is invoked when we actually get around to sending a packet.
// We look and see if we can give another queued send to the outgoing link,
// and if so we send on that link. Otherwise we put it on the outgoing queue
// and remove it later.
//
// Input: SrcNTE - Source NTE of packet.
// Packet - Packet to be send, containg all needed context info.
// Status - Status of transfer data.
// DataLength - Length in bytes of data to be send.
//
// Returns: Nothing.
//
void
SendFWPacket(PNDIS_PACKET Packet, NDIS_STATUS Status, uint DataLength)
{
FWContext *FC = (FWContext *)Packet->ProtocolReserved;
Interface *IF = FC->fc_if;
RouteSendQ *RSQ;
CTELockHandle Handle;
if (Status == NDIS_STATUS_SUCCESS) {
// Figure out which logical queue it belongs on, and if we don't already
// have too many things going there, send it. If we can't send it now we'll
// queue it for later.
if (IS_BCAST_DEST(FC->fc_dtype))
RSQ = BCastRSQ;
else
RSQ = &((RouteInterface *)IF)->ri_q;
CTEGetLock(&RSQ->rsq_lock, &Handle);
if (RSQ->rsq_pending < RSQ->rsq_maxpending && RSQ->rsq_qlength == 0) {
// We can send on this interface.
RSQ->rsq_pending++;
CTEFreeLock(&RSQ->rsq_lock, Handle);
TransmitFWPacket(Packet, DataLength);
} else { // Need to queue this packet for later.
FC->fc_datalength = DataLength;
FC->fc_q.fq_next = &RSQ->rsq_qh;
FC->fc_q.fq_prev = RSQ->rsq_qh.fq_prev;
RSQ->rsq_qh.fq_prev->fq_next = &FC->fc_q;
RSQ->rsq_qh.fq_prev = &FC->fc_q;
RSQ->rsq_qlength++;
CTEFreeLock(&RSQ->rsq_lock, Handle);
}
} else{
IPSInfo.ipsi_outdiscards++;
FreeFWPacket(Packet);
}
}
//* RemoveRandomFWPacket - Remove a random packet from the FW queue.
//
// Called when we run out of resources. We pick a random packet from the FW queue,
// free it, and return. The caller will hopefully then get it for his own use.
//
// Input: RSQ - Pointer to outgoing route send q..
//
// Returns: TRUE if we free a packet, false if we didn't.
//
uchar
RemoveRandomFWPacket(RouteSendQ *RSQ)
{
uint Now = (uint)CTESystemUpTime();
CTELockHandle Handle;
uint PacketCount;
PNDIS_PACKET FreedPacket;
FWQ *CurrentFWQ;
#ifdef DEBUG
FWQ *FirstFWQ;
#endif
#ifdef DEBUG
FirstFWQ = &RSQ->rsq_qh;
#endif
CTEGetLock(&RSQ->rsq_lock, &Handle);
if (RSQ->rsq_qlength) { // We have a least one in the list.
PacketCount = Now % (RSQ->rsq_qlength + 1);
if (PacketCount == RSQ->rsq_qlength) {
CTEFreeLock(&RSQ->rsq_lock, Handle);
return FALSE;
}
CurrentFWQ = RSQ->rsq_qh.fq_next;
while (PacketCount--) {
#ifdef DEBUG
if (CurrentFWQ == FirstFWQ)
DEBUGCHK;
#endif
CurrentFWQ = CurrentFWQ->fq_next;
}
// We've got the proper packet. Splice him out.
CurrentFWQ->fq_next->fq_prev = CurrentFWQ->fq_prev;
CurrentFWQ->fq_prev->fq_next = CurrentFWQ->fq_next;
RSQ->rsq_qlength--;
CTEFreeLock(&RSQ->rsq_lock, Handle);
FreedPacket = PACKET_FROM_FWQ(CurrentFWQ);
FreeFWPacket(FreedPacket);
IPSInfo.ipsi_outdiscards++;
return TRUE;
}
CTEFreeLock(&RSQ->rsq_lock, Handle);
return FALSE;
}
//* GetFWBuffer - Get a list of buffers for forwarding.
//
// This routine gets a list of buffers for forwarding, and puts the data into it. This
// may involve calling TransferData, or we may be able to copy directly into them
// ourselves.
//
// Input: SrcNTE - Pointer to NTE on which packet was received.
// Packet - Packet being forwarded, used for TD.
// Data - Pointer to data buffer being forwarded.
// DataLength - Length in bytes of Data.
// BufferLength - Length in bytes available in buffer pointer to by Data.
// Offset - Offset into original data from which to transfer.
// LContext1, LContext2 - Context values for the link layer.
//
// Returns: NDIS_STATUS of attempt to get buffer.
//
NDIS_STATUS
GetFWBuffer(NetTableEntry *SrcNTE, PNDIS_PACKET Packet, uchar *Data,
uint DataLength, uint BufferLength, uint Offset, NDIS_HANDLE LContext1,
uint LContext2)
{
CTELockHandle Handle;
uint BufNeeded, i;
PNDIS_BUFFER FirstBuffer, CurrentBuffer;
void *DestPtr;
Interface *SrcIF;
FWContext *FWC;
uint BufLen;
uint LastBufSize;
#ifdef DEBUG
uint TotalBufferSize;
PNDIS_BUFFER TempBuffer;
#endif
// Figure out how many buffers we need.
BufNeeded = DataLength / FW_BUF_SIZE;
LastBufSize = DataLength % FW_BUF_SIZE;
if (LastBufSize != 0)
BufNeeded++;
#ifdef DEBUG
if (!BufNeeded)
DEBUGCHK;
#endif
FWC = (FWContext *)Packet->ProtocolReserved;
// Now run down the buffer free list, getting the buffers we need. If we
// can't get enough the first time, we'll free a random packet from our
// pending list and try again.
for (;;) {
CTEGetLock(&FWBufFreeLock, &Handle);
FirstBuffer = FWBufFree;
CurrentBuffer = STRUCT_OF(NDIS_BUFFER, &FWBufFree, Next);
i = 0;
do {
CurrentBuffer = NDIS_BUFFER_LINKAGE(CurrentBuffer);
if (!CurrentBuffer)
break;
// Zap this buffer length to the full buffer size, since it may
// have been modified from a previous send.
NdisAdjustBufferLength(CurrentBuffer, FW_BUF_SIZE);
i++;
} while (i < BufNeeded);
if (i != BufNeeded) { // We ran out of buffers. Free a packet and try again.
RouteSendQ *RSQ;
if ((MaxFWBufferSize - CurrentFWBufferSize) <= FW_BUF_SIZE) {
CTEFreeLock(&FWBufFreeLock, Handle);
if (GrowFWBuffer()) {
continue;
}
} else
CTEFreeLock(&FWBufFreeLock, Handle);
if (!IS_BCAST_DEST(FWC->fc_dtype))
RSQ = &((RouteInterface *)FWC->fc_if)->ri_q;
else
RSQ = BCastRSQ;
if (!RemoveRandomFWPacket(RSQ)) {
if (IS_BCAST_DEST(FWC->fc_dtype))
return NDIS_STATUS_RESOURCES;
// Couldn't get one for a non-broadcast packet. If the qlen is
// 0 on the outgoing queue, we'll try other queues, on the
// presumption that traffic through some other interface is
// starving this one.
if (RSQ->rsq_qlength == 0) {
Interface *IF;
for (IF = IFList; IF != NULL; IF = IF->if_next) {
RSQ = &((RouteInterface *)IF)->ri_q;
if (RemoveRandomFWPacket(RSQ))
break;
}
if (IF == NULL)
return NDIS_STATUS_RESOURCES;
} else
return NDIS_STATUS_RESOURCES;
}
// Otherwise we'll fall through and try again, now that we have
// hopefully put some more on the free queue.
} else {
// We have as many as we need. Update the free list.
FWBufFree = NDIS_BUFFER_LINKAGE(CurrentBuffer);
CTEFreeLock(&FWBufFreeLock, Handle);
NDIS_BUFFER_LINKAGE(CurrentBuffer) = (PNDIS_BUFFER)NULL;
// If we have a non-full last buffer, adjust it's size.
if (LastBufSize != 0)
NdisAdjustBufferLength(CurrentBuffer, LastBufSize);
FWC->fc_buffhead = FirstBuffer;
FWC->fc_bufftail = CurrentBuffer;
break;
}
}
NdisChainBufferAtFront(Packet, FirstBuffer);
#ifdef DEBUG
// Sanity check the buffer chain and packet.
TempBuffer = FirstBuffer;
TotalBufferSize = 0;
while (TempBuffer != NULL) {
TotalBufferSize += NdisBufferLength(TempBuffer);
TempBuffer = NDIS_BUFFER_LINKAGE(TempBuffer);
}
CTEAssert(TotalBufferSize == DataLength);
NdisQueryPacket(Packet, NULL, NULL, NULL, &TotalBufferSize);
CTEAssert(TotalBufferSize == DataLength);
#endif
// First buffer points to the list of buffers we have. If we can copy the
// data here, do so, otherwise invoke the link's transfer data routine.
if ((DataLength <= BufferLength) && (SrcNTE->nte_flags & NTE_COPY)) {
while (DataLength) {
uint CopyLength;
#ifdef VXD
DestPtr = FirstBuffer->VirtualAddress;
#else
//
// BUGBUG: This is inefficient.
//
NdisQueryBuffer(FirstBuffer, &DestPtr, &BufLen);
#endif
CopyLength = MIN(DataLength, FW_BUF_SIZE);
CTEAssert(CopyLength == NdisBufferLength(FirstBuffer));
CTEMemCopy(DestPtr, Data, CopyLength);
Data += CopyLength;
DataLength -= CopyLength;
FirstBuffer = NDIS_BUFFER_LINKAGE(FirstBuffer);
}
return NDIS_STATUS_SUCCESS;
}
// We need to call transfer data for this.
SrcIF = SrcNTE->nte_if;
return (*(SrcIF->if_transfer))(SrcIF->if_lcontext, LContext1, LContext2,
Offset, DataLength, Packet, &DataLength);
}
//* GetFWPacket - Get a packet for forwarding.
//
// Called when we need to get a packet to forward a datagram.
//
// Entry: Packet - Pointer to where to return a packet.
// IF - Outgoing I/F for packet.
// DestType - Type of outgoing packet.
//
// Returns: Pointer to header buffer.
//
//
IPHeader *
GetFWPacket(PNDIS_PACKET *Packet, Interface *IF, uchar DestType)
{
CTELockHandle Handle;
PNDIS_PACKET NewPacket;
RouteSendQ *RSQ;
for (;;) {
CTEGetLock(&FWPacketFreeLock, &Handle);
if ((NewPacket = FWPacketFree) != (PNDIS_PACKET)NULL) {
FWContext *FWC;
FWC = (FWContext *)NewPacket->ProtocolReserved;
FWPacketFree = FWC->fc_pc.pc_common.pc_link;
FWC->fc_pc.pc_common.pc_flags |= PACKET_FLAG_IPHDR;
FWC->fc_pc.pc_br = NULL;
*Packet = NewPacket;
CTEFreeLock(&FWPacketFreeLock, Handle);
return FWC->fc_hbuff;
}
// If we couldn't get one, try to grow the list if we can.
if (MaxFWPackets > CurrentFWPackets) {
CTEFreeLock(&FWPacketFreeLock, Handle);
// We're allowed to grow, so try to.
if (GrowFWPackets()) {
continue; // If we grew it, try again.
}
} else
CTEFreeLock(&FWPacketFreeLock, Handle);
// Either we weren't allowed to grow the list, or we tried to but couldn't. Try yo
// get one that's on the queue already.
if (!IS_BCAST_DEST(DestType))
RSQ = &((RouteInterface *)IF)->ri_q;
else
RSQ = BCastRSQ;
if (!RemoveRandomFWPacket(RSQ))
break;
}
return (IPHeader *)NULL;
}
//** IPForward - Forward a packet.
//
// The routine called when we need to forward a packet. We check if we're supposed
// to act as a gateway, and if we are and the incoming packet is a bcast we check
// and see if we're supposed to forward broadcasts. Assuming we're supposed to
// forward it, we will process any options. If we find some, we do some validation
// to make sure everything is good. After that, we look up the next hop. If we can't
// find one, we'll issue an error. Then we get a packet and buffers, and send it.
//
// Input: SrcNTE - NTE for net on which we received this.
// Header - Pointer to received IPheader.
// HeaderLength - Length of header.
// Data - Pointer to data to be forwarded.
// BufferLength - Length in bytes available in the buffer.
// DestType - Type of destination.
//
// Returns: Nothing.
//
void
IPForward(NetTableEntry *SrcNTE, IPHeader UNALIGNED *Header, uint HeaderLength,
void *Data, uint BufferLength, NDIS_HANDLE LContext1, uint LContext2,
uchar DestType)
{
uchar *Options;
uchar OptLength;
OptIndex Index;
IPAddr DestAddr; // IP address we're routing towards.
uchar SendOnSource = FALSE;
IPAddr NextHop; // Next hop IP address.
PNDIS_PACKET Packet;
FWContext *FWC;
IPHeader *NewHeader; // New header.
NDIS_STATUS Status;
uint DataLength;
CTELockHandle TableHandle;
uchar ErrIndex;
IPAddr OutAddr; // Address of interface we're send out on.
Interface *IF; // Interface we're sending out on.
uint MTU;
if (ForwardPackets) {
DestAddr = Header->iph_dest;
// If it's a broadcast, see if we can forward it. We won't forward it if broadcast
// forwarding is turned off, or the destination if the local (all one's) broadcast,
// or it's a multicast (Class D address). We'll pass through subnet broadcasts in
// case there's a source route. This would be odd - maybe we should disable this?
if (IS_BCAST_DEST(DestType)) {
if (!ForwardBCast) {
if (DestType > DEST_REMOTE)
IPSInfo.ipsi_inaddrerrors++;
return;
}
if ((DestAddr == IP_LOCAL_BCST) ||
(DestAddr == IP_ZERO_BCST) ||
(DestType == DEST_SN_BCAST) ||
CLASSD_ADDR(DestAddr)) {
return;
}
} else
if (DestType == DEST_REMOTE) {
SrcNTE = BestNTEForIF(Header->iph_src, SrcNTE->nte_if);
if (SrcNTE == NULL) {
// Something bad happened.
return;
}
}
// If the TTL would expire, send a message.
if (Header->iph_ttl <= 1) {
IPSInfo.ipsi_inhdrerrors++;
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_TIME_EXCEED, TTL_IN_TRANSIT,0);
return;
}
DataLength = net_short(Header->iph_length) - HeaderLength;
Index.oi_srtype = NO_SR; // So we know we don't have a source route.
Index.oi_srindex = MAX_OPT_SIZE;
Index.oi_rrindex = MAX_OPT_SIZE;
Index.oi_tsindex = MAX_OPT_SIZE;
// Now check for options, and process any we find.
if (HeaderLength != sizeof(IPHeader)) {
IPOptInfo OptInfo;
OptInfo.ioi_options = (uchar *)(Header + 1);
OptInfo.ioi_optlength = HeaderLength - sizeof(IPHeader);
// Validate options, and set up indices.
if ((ErrIndex = ParseRcvdOptions(&OptInfo, &Index)) < MAX_OPT_SIZE) {
IPSInfo.ipsi_inhdrerrors++;
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_PARAM_PROBLEM,
PTR_VALID, ((ulong)ErrIndex + sizeof(IPHeader)));
return;
}
Options = CTEAllocMem(OptInfo.ioi_optlength);
if (!Options) {
IPSInfo.ipsi_outdiscards++;
return; // Couldn't get an
} // option buffer, return;
// Now copy into our buffer.
CTEMemCopy(Options, OptInfo.ioi_options, OptLength = OptInfo.ioi_optlength);
// See if we have a source routing option, and if so we may need to process it. If
// we have one, and the destination in the header is us, we need to update the
// route and the header.
if (Index.oi_srindex != MAX_OPT_SIZE) {
if (DestType >= DEST_REMOTE) { // Not for us.
if (Index.oi_srtype == IP_OPT_SSRR) {
// This packet is strict source routed, but we're not the destination!
// We can't continue from here - perhaps we should send an ICMP, but
// I'm not sure which one it would be.
CTEFreeMem(Options);
IPSInfo.ipsi_inaddrerrors++;
return;
}
Index.oi_srindex = MAX_OPT_SIZE; // Don't need to update this.
} else { // This came here, we need to update the destination address.
uchar *SROpt = Options + Index.oi_srindex;
uchar Pointer;
Pointer = SROpt[IP_OPT_PTR] - 1; // Index starts from one.
// Get the next hop address, and see if it's a broadcast.
DestAddr = *(IPAddr UNALIGNED *)&SROpt[Pointer];
DestType = GetAddrType(DestAddr); // Find address type.
if (DestType == DEST_INVALID) {
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_DEST_UNREACH, SR_FAILED, 0);
IPSInfo.ipsi_inhdrerrors++;
CTEFreeMem(Options);
return;
}
// If we came through here, any sort of broadcast needs to be sent out
// the way it came, so update that flag.
SendOnSource = TRUE;
}
}
} else { // No options.
Options = (uchar *)NULL;
OptLength = 0;
}
IPSInfo.ipsi_forwdatagrams++;
// We've processed the options. Now look up the next hop. If we can't
// find one, send back an error.
IF = LookupNextHopWithBuffer(DestAddr, SrcNTE->nte_addr, &NextHop, &MTU,
Header->iph_protocol, (uchar *)Data, BufferLength);
if (IF == NULL) {
// Couldn't find an outgoing route.
IPSInfo.ipsi_outnoroutes++;
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_DEST_UNREACH,
HOST_UNREACH, 0);
if (Options)
CTEFreeMem(Options);
return;
}
//
// If the DF flag is set, make sure the packet doesn't need
// fragmentation. If this is the case, send an ICMP error
// now while we still have the original IP header. The ICMP
// message includes the MTU so the source host can perform
// Path MTU discovery.
//
if ( (Header->iph_offset & IP_DF_FLAG) &&
((DataLength + (uint)OptLength) > MTU)
)
{
CTEAssert((MTU + sizeof(IPHeader)) >= 68);
CTEAssert((MTU + sizeof(IPHeader)) <= 0xFFFF);
IPSInfo.ipsi_fragfails++;
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_DEST_UNREACH,
FRAG_NEEDED, net_long((ulong)(MTU + sizeof(IPHeader)))
);
if (Options)
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
return;
}
// See if we need to filter this packet. If we do, call the filter routine
// to see if it's OK to forward it.
if (ForwardFilterPtr != NULL) {
FORWARD_ACTION Action;
Action = (*ForwardFilterPtr)(Header, Data, BufferLength,
SrcNTE->nte_if->if_filtercontext, IF->if_filtercontext);
if (Action != FORWARD) {
IPSInfo.ipsi_outdiscards++;
if (Options)
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
return;
}
}
// If we have a strict source route and the next hop is not the one
// specified, send back an error.
if (Index.oi_srtype == IP_OPT_SSRR) {
if (DestAddr != NextHop) {
IPSInfo.ipsi_outnoroutes++;
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_DEST_UNREACH,
SR_FAILED, 0);
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
return;
}
}
// Update the options, if we can and we need to.
if ((DestType != DEST_BCAST) && Options != NULL) {
NetTableEntry *OutNTE;
// Need to find a valid source address for the outgoing interface.
CTEGetLock(&RouteTableLock, &TableHandle);
OutNTE = BestNTEForIF(DestAddr, IF);
if (OutNTE == NULL) {
// No NTE for this IF. Something's wrong, just bail out.
CTEFreeLock(&RouteTableLock, TableHandle);
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
return;
} else {
OutAddr = OutNTE->nte_addr;
CTEFreeLock(&RouteTableLock, TableHandle);
}
ErrIndex = UpdateOptions(Options, &Index,
(IP_LOOPBACK(OutAddr) ? DestAddr : OutAddr));
if (ErrIndex != MAX_OPT_SIZE) {
IPSInfo.ipsi_inhdrerrors++;
SendICMPErr(OutAddr, Header, ICMP_PARAM_PROBLEM, PTR_VALID,
((ulong)ErrIndex + sizeof(IPHeader)));
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
return;
}
}
// Send a redirect, if we need to. We'll send a redirect if the packet
// is going out on the interface it came in on and the next hop address
// is on the same subnet as the NTE we received it on, and if there
// are no source route options. We also need to make sure that the
// source of the datagram is on the I/F we received it on, so we don't
// send a redirect to another gateway.
// SendICMPErr will check and not send a redirect if this is a broadcast.
if ((SrcNTE->nte_if == IF) &&
IP_ADDR_EQUAL(SrcNTE->nte_addr & SrcNTE->nte_mask,
NextHop & SrcNTE->nte_mask) &&
IP_ADDR_EQUAL(SrcNTE->nte_addr & SrcNTE->nte_mask,
Header->iph_src & SrcNTE->nte_mask))
{
if (Index.oi_srindex == MAX_OPT_SIZE)
{
#ifdef REDIRECT_DEBUG
#define PR_IP_ADDR(x) \
((x)&0x000000ff),(((x)&0x0000ff00)>>8),(((x)&0x00ff0000)>>16),(((x)&0xff000000)>>24)
DbgPrint("IP: Sending Redirect. IF = %x SRC_NTE = %x SrcNteIF = %x\n",
IF,SrcNTE,SrcNTE->nte_if);
DbgPrint("IP: SrcNteAddr = %d.%d.%d.%d Mask = %d.%d.%d.%d\n",
PR_IP_ADDR(SrcNTE->nte_addr), PR_IP_ADDR(SrcNTE->nte_mask));
DbgPrint("IP: NextHop = %d.%d.%d.%d Header Src = %d.%d.%d.%d, Dst = %d.%d.%d.%d\n",
PR_IP_ADDR(NextHop),
PR_IP_ADDR(Header->iph_src),
PR_IP_ADDR(Header->iph_dest));
#endif
SendICMPErr(SrcNTE->nte_addr, Header, ICMP_REDIRECT,
REDIRECT_HOST, NextHop);
}
}
// We have the next hop. Now get a forwarding packet.
if ((NewHeader = GetFWPacket(&Packet, IF, DestType)) !=
(IPHeader *)NULL) {
// Got the header. Fill it in.
NewHeader->iph_verlen = Header->iph_verlen;
NewHeader->iph_tos = Header->iph_tos;
NewHeader->iph_length = Header->iph_length;
NewHeader->iph_id = Header->iph_id;
NewHeader->iph_offset = Header->iph_offset;
NewHeader->iph_protocol = Header->iph_protocol;
NewHeader->iph_src = Header->iph_src;
NewHeader->iph_dest = DestAddr;
NewHeader->iph_ttl = Header->iph_ttl - 1;
NewHeader->iph_xsum = 0;
// Save the packet forwarding context info.
FWC = (FWContext *)Packet->ProtocolReserved;
FWC->fc_options = Options;
FWC->fc_optlength = OptLength;
FWC->fc_if = IF;
FWC->fc_mtu = MTU;
FWC->fc_srcnte = SrcNTE;
FWC->fc_nexthop = NextHop;
FWC->fc_sos = SendOnSource;
FWC->fc_dtype = DestType;
FWC->fc_index = Index;
// Now that we have a packet, go ahead and transfer data the
// data in if we need to.
Status = GetFWBuffer(SrcNTE, Packet, Data, DataLength, BufferLength,
HeaderLength, LContext1, LContext2);
// If the status is pending, don't do anything now. Otherwise,
// if the status is success send the packet.
if (Status != NDIS_STATUS_PENDING)
if (Status == NDIS_STATUS_SUCCESS) {
SendFWPacket(Packet, Status, DataLength);
} else {
// Some sort of failure. Free the packet.
IPSInfo.ipsi_outdiscards++;
FreeFWPacket(Packet);
}
} else { // Couldn't get a packet, so drop this.
IPSInfo.ipsi_outdiscards++;
if (Options)
CTEFreeMem(Options);
#ifdef _PNP_POWER
DerefIF(IF);
#endif
}
} else { // Forward called, but forwarding
// turned off.
if (DestType != DEST_BCAST && DestType != DEST_SN_BCAST) {
// No need to go through here for strictly broadcast packets,
// although we want to bump the counters for remote bcast stuff.
IPSInfo.ipsi_inaddrerrors++;
if (!IS_BCAST_DEST(DestType)) {
if (DestType == DEST_LOCAL) // Called when local, must be SR.
SendICMPErr(SrcNTE->nte_addr, Header,
ICMP_DEST_UNREACH, SR_FAILED, 0);
}
}
}
}
//* AddNTERoutes - Add the routes for an NTE.
//
// Called during initalization or during DHCP address assignment to add
// routes. We add routes for the address of the NTE, including routes
// to the subnet and the address itself.
//
// Input: NTE - NTE for which to add routes.
//
// Returns: TRUE if they were all added, FALSE if not.
//
uint
AddNTERoutes(NetTableEntry *NTE)
{
IPMask Mask, SNMask;
Interface *IF;
CTELockHandle Handle;
IPAddr AllSNBCast;
IP_STATUS Status;
// First, add the route to the address itself. This is a route through
// the loopback interface.
if (AddRoute(NTE->nte_addr, HOST_MASK, IPADDR_LOCAL, LoopNTE->nte_if,
LOOPBACK_MSS, 1, IRE_PROTO_LOCAL, ATYPE_OVERRIDE, NULL) != IP_SUCCESS)
return FALSE;
Mask = IPNetMask(NTE->nte_addr);
IF = NTE->nte_if;
// Now add the route for the all-subnet's broadcast, if one doesn't already
// exist. There is special case code to handle this in SendIPBCast, so the
// exact interface we add this on doesn't really matter.
CTEGetLock(&RouteTableLock, &Handle);
AllSNBCast = (NTE->nte_addr & Mask) | (IF->if_bcast & ~Mask);
if (LookupRTE(AllSNBCast, NULL_IP_ADDR, HOST_ROUTE_PRI) == NULL) {
Status = LockedAddRoute(AllSNBCast, HOST_MASK, IPADDR_LOCAL, IF,
NTE->nte_mss, 1, IRE_PROTO_LOCAL, ATYPE_PERM, NULL);
} else
Status = IP_SUCCESS;
CTEFreeLock(&RouteTableLock, Handle);
if (Status != IP_SUCCESS)
return FALSE;
// If we're doing IGMP, add the route to the multicast address.
if (IGMPLevel != 0) {
if (AddRoute(CLASSD_MASK, CLASSD_MASK, IPADDR_LOCAL, NTE->nte_if,
NTE->nte_mss, 1, IRE_PROTO_LOCAL, ATYPE_PERM, NULL) != IP_SUCCESS)
return FALSE;
}
if(NTE->nte_mask != HOST_MASK)
{
// And finally the route to the subnet.
SNMask = NTE->nte_mask;
if (AddRoute(NTE->nte_addr & SNMask, SNMask, IPADDR_LOCAL, NTE->nte_if,
NTE->nte_mss, 1, IRE_PROTO_LOCAL, ATYPE_PERM, NULL) != IP_SUCCESS)
return FALSE;
}
return TRUE;
}
#ifndef CHICAGO
#pragma BEGIN_INIT
#endif
uint BCastMinMTU = 0xffff;
//* InitNTERouting - do per NTE route initialization.
//
// Called when we need to initialize per-NTE routing. For the specified NTE,
// call AddNTERoutes to add a route for a net bcast, subnet bcast, and local
// attached subnet. The net bcast entry is sort of a filler - net and
// global bcasts are always handled specially. For this reason we specify
// the FirstInterface when adding the route. Subnet bcasts are assumed to
// only go out on one interface, so the actual interface to be used is
// specifed. If two interfaces are on the same subnet the last interface is
// the one that will be used.
//
// Input: NTE - NTE for which routing is to be initialized.
// NumGWs - Number of default gateways to add.
// GWList - List of default gateways.
//
// Returns: TRUE if we succeed, FALSE if we don't.
//
uint
InitNTERouting(NetTableEntry *NTE, uint NumGWs, IPAddr *GWList)
{
uint i;
Interface *IF;
CTERefillMem();
if (NTE != LoopNTE) {
BCastMinMTU = MIN(BCastMinMTU, NTE->nte_mss);
IF = NTE->nte_if;
AddRoute(IF->if_bcast, HOST_MASK, IPADDR_LOCAL, FirstIF,
BCastMinMTU, 1, IRE_PROTO_LOCAL, ATYPE_OVERRIDE, NULL);// Route for local
// bcast.
if (NTE->nte_flags & NTE_VALID) {
if (!AddNTERoutes(NTE))
return FALSE;
// Now add the default routes that are present on this net. We
// don't check for errors here, but we should probably
// log an error.
for (i = 0; i < NumGWs;i++) {
IPAddr GWAddr;
GWAddr = net_long(GWList[i]);
if (IP_ADDR_EQUAL(GWAddr, NTE->nte_addr)) {
AddRoute(NULL_IP_ADDR, DEFAULT_MASK,
IPADDR_LOCAL, NTE->nte_if, NTE->nte_mss, 1,
IRE_PROTO_LOCAL, ATYPE_OVERRIDE, NULL);
} else
AddRoute(NULL_IP_ADDR, DEFAULT_MASK,
net_long(GWList[i]), NTE->nte_if, NTE->nte_mss, 1,
IRE_PROTO_LOCAL, ATYPE_OVERRIDE, NULL);
}
}
}
return TRUE;
}
#ifdef CHICAGO
#pragma BEGIN_INIT
#endif
//* InitRouting - Initialize our routing table.
//
// Called during initialization to initialize the routing table.
//
// Entry: Nothing.
//
// Returns: True if we succeeded, False if we didn't.
//
int
InitRouting(IPConfigInfo *ci)
{
int i;
CTERefillMem();
CTEInitLock(&RouteTableLock);
DefGWConfigured = 0;
DefGWActive = 0;
CTEMemSet(&DummyInterface, 0, sizeof(DummyInterface));
DummyInterface.ri_if.if_xmit = DummyXmit;
DummyInterface.ri_if.if_transfer = DummyXfer;
DummyInterface.ri_if.if_close = DummyClose;
DummyInterface.ri_if.if_invalidate = DummyInvalidate;
DummyInterface.ri_if.if_qinfo = DummyQInfo;
DummyInterface.ri_if.if_setinfo = DummySetInfo;
DummyInterface.ri_if.if_getelist = DummyGetEList;
DummyInterface.ri_if.if_addaddr = DummyAddAddr;
DummyInterface.ri_if.if_deladdr = DummyDelAddr;
DummyInterface.ri_if.if_bcast = IP_LOCAL_BCST;
DummyInterface.ri_if.if_speed = 10000000;
DummyInterface.ri_if.if_mtu = 1500;
DummyInterface.ri_if.if_index = INVALID_IF_INDEX;
for (i = 0; i < ROUTE_TABLE_SIZE; i++)
RouteTable[i] = (RouteTableEntry *)NULL;
// We've created at least one net. We need to add routing table entries for
// the global broadcast address, as well as for subnet and net broadcasts,
// and routing entries for the local subnet. We alse need to add a loopback
// route for the loopback net. Below, we'll add a host route for ourselves
// through the loopback net.
AddRoute(LOOPBACK_ADDR & CLASSA_MASK, CLASSA_MASK, IPADDR_LOCAL,
LoopNTE->nte_if, LOOPBACK_MSS, 1, IRE_PROTO_LOCAL, ATYPE_PERM, NULL);
// Route for loopback.
RouterConfigured = (uchar)ci->ici_gateway;
CTEInitTimer(&IPRouteTimer);
CTEStartTimer(&IPRouteTimer, IP_ROUTE_TIMEOUT, IPRouteTimeout, NULL);
return TRUE;
}
//* InitGateway - Initialize our gateway functionality.
//
// Called during init. time to initialize our gateway functionality. If we're
// not connfigured as a router, we do nothing. If we are, we allocate the
// resources we need and do other router initialization.
//
// Input: ci - Config info.
//
// Returns: TRUE if we succeed, FALSE if don't.
//
uint
InitGateway(IPConfigInfo *ci)
{
uint FWBufSize, FWPackets;
uint FWBufCount;
NDIS_STATUS Status;
NDIS_HANDLE BufferPool, FWBufferPool, PacketPool;
IPHeader *HeaderPtr = NULL;
uchar *FWBuffer = NULL;
PNDIS_BUFFER Buffer;
PNDIS_PACKET Packet;
RouteInterface *RtIF;
NetTableEntry *NTE;
uint i;
// If we're going to be a router, allocate and initialize the resources we
// need for that.
BCastRSQ = NULL;
if (RouterConfigured) {
CTERefillMem();
RtPI = CTEAllocMem(sizeof(ProtInfo));
if (RtPI == (ProtInfo *)NULL)
goto failure;
RtPI->pi_xmitdone = FWSendComplete;
CTEInitLock(&FWPacketFreeLock);
CTEInitLock(&FWBufFreeLock);
MaxFWBufferSize = ci->ici_maxfwbufsize;
MaxFWPackets = ci->ici_maxfwpackets;
FWBufSize = MIN(ci->ici_fwbufsize, MaxFWBufferSize);
FWPackets = MIN(ci->ici_fwpackets, MaxFWPackets);
for (NTE = NetTableList; NTE != NULL; NTE = NTE->nte_next) {
RtIF = (RouteInterface *)NTE->nte_if;
RtIF->ri_q.rsq_qh.fq_next = &RtIF->ri_q.rsq_qh;
RtIF->ri_q.rsq_qh.fq_prev = &RtIF->ri_q.rsq_qh;
RtIF->ri_q.rsq_running = FALSE;
RtIF->ri_q.rsq_pending = 0;
RtIF->ri_q.rsq_qlength = 0;
CTEInitLock(&RtIF->ri_q.rsq_lock);
}
BCastRSQ = CTEAllocMem(sizeof(RouteSendQ));
if (BCastRSQ == (RouteSendQ *)NULL)
goto failure;
BCastRSQ->rsq_qh.fq_next = &BCastRSQ->rsq_qh;
BCastRSQ->rsq_qh.fq_prev = &BCastRSQ->rsq_qh;
BCastRSQ->rsq_pending = 0;
BCastRSQ->rsq_maxpending = DEFAULT_MAX_PENDING;
BCastRSQ->rsq_qlength = 0;
BCastRSQ->rsq_running = FALSE;
CTEInitLock(&BCastRSQ->rsq_lock);
RtIF = (RouteInterface *)&LoopInterface;
RtIF->ri_q.rsq_maxpending = DEFAULT_MAX_PENDING;
// Round the specified size down to a multiple of our FW buf size.
CTERefillMem();
FWBufCount = FWBufSize / FW_BUF_SIZE;
FWBufSize = FWBufCount * FW_BUF_SIZE;
// Allocate the buffers, packets, and memory for our header buffers.
HeaderPtr = CTEAllocMem(FWPackets * sizeof(IPHeader));
if (HeaderPtr == (IPHeader *)NULL)
goto failure;
NdisAllocateBufferPool(&Status, &BufferPool, FWPackets);
if (Status != NDIS_STATUS_SUCCESS) {
goto failure; // Couldn't be a router, fail.
}
NdisAllocatePacketPool(&Status, &PacketPool, FWPackets, sizeof(FWContext));
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreeBufferPool(BufferPool);
goto failure;
}
// Allocate resources for our the buffer pool.
CTERefillMem();
FWBuffer = CTEAllocMem(FWBufSize);
if (FWBuffer == NULL) { // Couldn't get buffer space.
NdisFreePacketPool(PacketPool);
NdisFreeBufferPool(BufferPool);
goto failure;
}
NdisAllocateBufferPool(&Status, &FWBufferPool, FWBufCount);
if (Status != NDIS_STATUS_SUCCESS) {
NdisFreePacketPool(PacketPool);
NdisFreeBufferPool(BufferPool);
goto failure;
}
// Everythings allocated. Put it all together and stick them on the
// free list.
for (i = 0; i < FWPackets; i++) {
FWContext *FWC;
NdisAllocateBuffer(&Status, &Buffer, BufferPool, HeaderPtr,
sizeof(IPHeader));
if (Status != NDIS_STATUS_SUCCESS)
DEBUGCHK;
NdisAllocatePacket(&Status, &Packet, PacketPool);
if (Status != NDIS_STATUS_SUCCESS)
DEBUGCHK;
CTEMemSet(Packet->ProtocolReserved, 0, sizeof(FWContext));
FWC = (FWContext *)Packet->ProtocolReserved;
FWC->fc_hndisbuff = Buffer;
FWC->fc_hbuff = HeaderPtr;
FWC->fc_pc.pc_common.pc_flags = PACKET_FLAG_FW;
FWC->fc_pc.pc_common.pc_owner = PACKET_OWNER_IP;
FWC->fc_pc.pc_pi = RtPI;
FWC->fc_pc.pc_context = Packet;
FreeFWPacket(Packet);
HeaderPtr++;
}
for (i = 0; i < FWBufCount; i++) {
NdisAllocateBuffer(&Status, &Buffer, FWBufferPool, FWBuffer,
FW_BUF_SIZE);
if (Status != NDIS_STATUS_SUCCESS)
DEBUGCHK;
Buffer->Next = FWBufFree; // BUGBUG portability
FWBufFree = Buffer;
FWBuffer += FW_BUF_SIZE;
}
CurrentFWPackets = FWPackets;
CurrentFWBufferSize = FWBufSize;
#if 0
ForwardBCast = (uchar)ci->ici_fwbcast;
#else
ForwardBCast = FALSE;
#endif
ForwardPackets = TRUE;
}
return TRUE;
failure:
if (RtPI != NULL)
CTEFreeMem(RtPI);
if (BCastRSQ != NULL)
CTEFreeMem(BCastRSQ);
if (HeaderPtr != NULL)
CTEFreeMem(HeaderPtr);
if (FWBuffer != NULL)
CTEFreeMem(FWBuffer);
ForwardBCast = FALSE;
ForwardPackets = FALSE;
RouterConfigured = FALSE;
return FALSE;
}
#pragma END_INIT
