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

//** INFO.C - Routines for querying and setting IP information.
//
//  This file contains the code for dealing with Query/Set information
//  calls.
//

#include    "oscfg.h"
#include    "ndis.h"
#include    "cxport.h"
#include    "ip.h"
#include    "ipdef.h"
#include    "info.h"
#include    "tdi.h"
#include    "tdiinfo.h"
#include    "llinfo.h"
#include    "tdistat.h"
#include	"iproute.h"
#include	"igmp.h"
#include	"ipfilter.h"
#include	"iprtdef.h"
	
extern Interface		*IFList;
extern NetTableEntry	*NetTableList;
extern uint				LoopIndex;			// Index of loopback I/F.
extern uint				DefaultTTL;
extern uint				NumIF;
extern uint				NumNTE;
extern RouteInterface	DummyInterface;		// Dummy interface.

EXTERNAL_LOCK(RouteTableLock)

extern uint             RTEReadNext(void *Context, void *Buffer);
extern uint             RTValidateContext(void *Context, uint *Valid);
extern uint             RTReadNext(void *Context, void *Buffer);

uint	IPInstance;
uint	ICMPInstance;

//* CopyToNdis - Copy a flat buffer to an NDIS_BUFFER chain.
//
//  A utility function to copy a flat buffer to an NDIS buffer chain. We
//  assume that the NDIS_BUFFER chain is big enough to hold the copy amount;
//  in a debug build we'll  debugcheck if this isn't true. We return a pointer
//  to the buffer where we stopped copying, and an offset into that buffer.
//  This is useful for copying in pieces into the chain.
//
//  Input:  DestBuf     - Destination NDIS_BUFFER chain.
//          SrcBuf      - Src flat buffer.
//          Size        - Size in bytes to copy.
//          StartOffset - Pointer to start of offset into first buffer in
//                          chain. Filled in on return with the offset to
//                          copy into next.
//
//  Returns: Pointer to next buffer in chain to copy into.
//
PNDIS_BUFFER
CopyToNdis(PNDIS_BUFFER DestBuf, uchar *SrcBuf, uint Size,
    uint *StartOffset)
{
    uint        CopySize;
    uchar       *DestPtr;
    uint        DestSize;
    uint        Offset = *StartOffset;
    uchar      *VirtualAddress;
    uint        Length;

    CTEAssert(DestBuf != NULL);
    CTEAssert(SrcBuf != NULL);

    NdisQueryBuffer(DestBuf, &VirtualAddress, &Length);
    CTEAssert(Length >= Offset);
    DestPtr = VirtualAddress + Offset;
    DestSize = Length - Offset;

    for (;;) {
        CopySize = MIN(Size, DestSize);
        CTEMemCopy(DestPtr, SrcBuf, CopySize);

        DestPtr += CopySize;
        SrcBuf += CopySize;

        if ((Size -= CopySize) == 0)
            break;

        if ((DestSize -= CopySize) == 0) {
            DestBuf = NDIS_BUFFER_LINKAGE(DestBuf);
            CTEAssert(DestBuf != NULL);
            NdisQueryBuffer(DestBuf, &VirtualAddress, &Length);
            DestPtr = VirtualAddress;
            DestSize = Length;
        }
    }

    *StartOffset = DestPtr - VirtualAddress;

    return DestBuf;

}


//* IPQueryInfo - IP query information handler.
//
//  Called by the upper layer when it wants to query information about us.
//  We take in an ID, a buffer and length, and a context value, and return
//  whatever information we can.
//
//  Input:  ID          - Pointer to ID structure.
//          Buffer      - Pointer to buffer chain.
//          Size        - Pointer to size in bytes of buffer. On return, filled
//                          in with bytes read.
//          Context     - Pointer to context value.
//
//  Returns: TDI_STATUS of attempt to read information.
//
long
IPQueryInfo(TDIObjectID *ID, PNDIS_BUFFER Buffer, uint *Size, void *Context)
{
    uint            BufferSize = *Size;
    uint            BytesCopied = 0;
    uint            Offset = 0;
    TDI_STATUS      Status;
    ushort          NTEContext;
    uchar           InfoBuff[sizeof(IPRouteEntry)];
    IPAddrEntry     *AddrEntry;
    NetTableEntry   *CurrentNTE;
    uint            Valid, DataLeft;
    CTELockHandle   Handle;
    Interface       *LowerIF;
    IPInterfaceInfo *IIIPtr;
    uint            LLID = 0;
	uint			Entity;
	uint			Instance;
    IPAddr          IFAddr;

	
	Entity = ID->toi_entity.tei_entity;
	Instance = ID->toi_entity.tei_instance;

	// See if it's something we might handle.

	if (Entity != CL_NL_ENTITY && Entity != ER_ENTITY) {
		// We need to pass this down to the lower layer. Loop through until
		// we find one that takes it. If noone does, error out.
		for (LowerIF = IFList; LowerIF != NULL; LowerIF = LowerIF->if_next) {
			Status = (*LowerIF->if_qinfo)(LowerIF->if_lcontext, ID, Buffer,
				Size, Context);
			if (Status != TDI_INVALID_REQUEST)
				return Status;
		}
		// If we get here, noone took it. Return an error.
		return TDI_INVALID_REQUEST;

	}
	
	if ((Entity == CL_NL_ENTITY && Instance != IPInstance) ||
		Instance != ICMPInstance)
		return TDI_INVALID_REQUEST;

	// The request is for us.
	*Size = 0;					// Set to 0 in case of an error.

	// Make sure it's something we support.
	if (ID->toi_class == INFO_CLASS_GENERIC) {
		if (ID->toi_type == INFO_TYPE_PROVIDER && ID->toi_id == ENTITY_TYPE_ID) {
			// He's trying to see what type we are.
			if (BufferSize >= sizeof(uint)) {
				*(uint *)&InfoBuff[0] = (Entity == CL_NL_ENTITY) ? CL_NL_IP :
					ER_ICMP;
				(void)CopyToNdis(Buffer, InfoBuff, sizeof(uint), &Offset);
				return TDI_SUCCESS;
			} else
				return TDI_BUFFER_TOO_SMALL;
		}
		return TDI_INVALID_PARAMETER;	
	} else
		if (ID->toi_class != INFO_CLASS_PROTOCOL ||
			ID->toi_type != INFO_TYPE_PROVIDER)
			return TDI_INVALID_PARAMETER;

	// If it's ICMP, just copy the statistics.
	if (Entity == ER_ENTITY) {

		// It is ICMP. Make sure the ID is valid.
		if (ID->toi_id != ICMP_MIB_STATS_ID)
			return TDI_INVALID_PARAMETER;

        // He wants the stats. Copy what we can.
        if (BufferSize < sizeof(ICMPSNMPInfo))
            return TDI_BUFFER_TOO_SMALL;

        Buffer = CopyToNdis(Buffer, (uchar *)&ICMPInStats, sizeof(ICMPStats),
            &Offset);
        (void)CopyToNdis(Buffer, (uchar *)&ICMPOutStats, sizeof(ICMPStats),
            &Offset);
		
		*Size = sizeof(ICMPSNMPInfo);
        return TDI_SUCCESS;
    }

    // It's not ICMP. We need to figure out what it is, and take the
    // appropriate action.

	switch (ID->toi_id) {
		
		case IP_MIB_STATS_ID:
			if (BufferSize < sizeof(IPSNMPInfo))
				return TDI_BUFFER_TOO_SMALL;
			IPSInfo.ipsi_numif = NumIF;
			IPSInfo.ipsi_numaddr = NumNTE;
            IPSInfo.ipsi_defaultttl = DefaultTTL;
            IPSInfo.ipsi_forwarding = ForwardPackets ? IP_FORWARDING :
                                                       IP_NOT_FORWARDING;
			CopyToNdis(Buffer, (uchar *)&IPSInfo, sizeof(IPSNMPInfo), &Offset);
			BytesCopied = sizeof(IPSNMPInfo);
			Status = TDI_SUCCESS;
			break;
		case IP_MIB_ADDRTABLE_ENTRY_ID:
			// He wants to read the address table. Figure out where we're
			// starting from, and if it's valid begin copying from there.
			NTEContext = *(ushort *)Context;
			CurrentNTE = NetTableList;
			
			if (NTEContext != 0) {
				for (;CurrentNTE != NULL; CurrentNTE = CurrentNTE->nte_next)
					if (CurrentNTE->nte_context == NTEContext)
						break;
				if (CurrentNTE == NULL)
					return TDI_INVALID_PARAMETER;
			}

			AddrEntry = (IPAddrEntry *)InfoBuff;
			for (; CurrentNTE != NULL; CurrentNTE = CurrentNTE->nte_next) {
				if ((int)(BufferSize - BytesCopied) >= (int)sizeof(IPAddrEntry)) {
					// We have room to copy it. Build the entry, and copy
					// it.
					if (CurrentNTE->nte_flags & NTE_ACTIVE) {
						if (CurrentNTE->nte_flags & NTE_VALID) {
							AddrEntry->iae_addr = CurrentNTE->nte_addr;
							AddrEntry->iae_mask = CurrentNTE->nte_mask;
						} else {
							AddrEntry->iae_addr = NULL_IP_ADDR;
							AddrEntry->iae_mask = NULL_IP_ADDR;
						}

						AddrEntry->iae_index = CurrentNTE->nte_if->if_index;
						AddrEntry->iae_bcastaddr =
							*(int *)&(CurrentNTE->nte_if->if_bcast) & 1;
						AddrEntry->iae_reasmsize = 0xffff;
						AddrEntry->iae_context = CurrentNTE->nte_context;
						Buffer = CopyToNdis(Buffer, (uchar *)AddrEntry,
							sizeof(IPAddrEntry), &Offset);
						BytesCopied += sizeof(IPAddrEntry);
					}
				} else
					break;
			}
			
			if (CurrentNTE == NULL)
				Status = TDI_SUCCESS;
			else {
				Status = TDI_BUFFER_OVERFLOW;
				**(ushort **)&Context = CurrentNTE->nte_context;
			}
				
			break;
		case IP_MIB_RTTABLE_ENTRY_ID:
			// Make sure we have a valid context.
			CTEGetLock(&RouteTableLock, &Handle);
			DataLeft = RTValidateContext(Context, &Valid);

            // If the context is valid, we'll continue trying to read.
            if (!Valid) {
                CTEFreeLock(&RouteTableLock, Handle);
                return TDI_INVALID_PARAMETER;
            }

            while (DataLeft)  {
                // The invariant here is that there is data in the table to
                // read. We may or may not have room for it. So DataLeft
                // is TRUE, and BufferSize - BytesCopied is the room left
                // in the buffer.
                if ((int)(BufferSize - BytesCopied) >= (int)sizeof(IPRouteEntry)) {
                    DataLeft = RTReadNext(Context, InfoBuff);
                    BytesCopied += sizeof(IPRouteEntry);
                    Buffer = CopyToNdis(Buffer, InfoBuff, sizeof(IPRouteEntry),
                        &Offset);
                } else
                    break;

            }

			CTEFreeLock(&RouteTableLock, Handle);
			Status = (!DataLeft ? TDI_SUCCESS : TDI_BUFFER_OVERFLOW);
			break;
        case IP_INTFC_INFO_ID:

            IFAddr = *(IPAddr *)Context;
            // Loop through the NTE table, looking for a match.
            for (CurrentNTE = NetTableList; CurrentNTE != NULL; CurrentNTE = CurrentNTE->nte_next) {
                if ((CurrentNTE->nte_flags & NTE_VALID) &&
                    IP_ADDR_EQUAL(CurrentNTE->nte_addr, IFAddr))
                    break;
            }
            if (CurrentNTE == NULL) {
                Status = TDI_INVALID_PARAMETER;
                break;
            }

            if (BufferSize < offsetof(IPInterfaceInfo, iii_addr)) {
                Status = TDI_BUFFER_TOO_SMALL;
                break;
            }

            // We have the NTE. Get the interface, fill in a structure,
            // and we're done.
            LowerIF = CurrentNTE->nte_if;
            IIIPtr = (IPInterfaceInfo *)InfoBuff;
            IIIPtr->iii_flags = LowerIF->if_flags & IF_FLAGS_P2P ?
               IP_INTFC_FLAG_P2P : 0;
            IIIPtr->iii_mtu = LowerIF->if_mtu;
            IIIPtr->iii_speed = LowerIF->if_speed;
            IIIPtr->iii_addrlength = LowerIF->if_addrlen;
            BytesCopied = offsetof(IPInterfaceInfo, iii_addr);
            if (BufferSize >= (offsetof(IPInterfaceInfo, iii_addr) +
                LowerIF->if_addrlen)) {
                Status = TDI_SUCCESS;
                Buffer = CopyToNdis(Buffer, InfoBuff,
                    offsetof(IPInterfaceInfo, iii_addr), &Offset);
                CopyToNdis(Buffer, LowerIF->if_addr, LowerIF->if_addrlen,
                    &Offset);
                BytesCopied += LowerIF->if_addrlen;
             } else {
                Status = TDI_BUFFER_TOO_SMALL;
             }
             break;

		default:
			return TDI_INVALID_PARAMETER;
			break;
	}

    *Size = BytesCopied;
    return Status;
}

//*	IPSetInfo - IP set information handler.
//
//	Called by the upper layer when it wants to set an object, which could
//	be a route table entry, an ARP table entry, or something else.
//
//	Input:	ID			- Pointer to ID structure.
//			Buffer		- Pointer to buffer containing element to set..
//			Size		- Pointer to size in bytes of buffer.
//
//	Returns: TDI_STATUS of attempt to read information.
//
long
IPSetInfo(TDIObjectID *ID, void *Buffer, uint Size)
{
	uint			Entity;
	uint			Instance;
	Interface		*LowerIF;
	Interface		*OutIF;
	uint			MTU;
	IPRouteEntry	*IRE;
	NetTableEntry	*OutNTE, *LocalNTE;
	IP_STATUS		Status;
	IPAddr			FirstHop, Dest, NextHop;

	Entity = ID->toi_entity.tei_entity;
	Instance = ID->toi_entity.tei_instance;

	// If it's not for us, pass it down.
	if (Entity != CL_NL_ENTITY) {
		// We need to pass this down to the lower layer. Loop through until
		// we find one that takes it. If noone does, error out.
		for (LowerIF = IFList; LowerIF != NULL; LowerIF = LowerIF->if_next) {
			Status = (*LowerIF->if_setinfo)(LowerIF->if_lcontext, ID, Buffer,
				Size);
			if (Status != TDI_INVALID_REQUEST)
				return Status;
		}
		// If we get here, noone took it. Return an error.
		return TDI_INVALID_REQUEST;
	}
	
	if (Instance != IPInstance)
		return TDI_INVALID_REQUEST;

	// We're identified as the entity. Make sure the ID is correct.
	if (ID->toi_id == IP_MIB_RTTABLE_ENTRY_ID) {
		NetTableEntry			*TempNTE;
		
		// This is an attempt to set a route table entry. Make sure the
		// size if correct.
		if (Size < sizeof(IPRouteEntry))
			return TDI_INVALID_PARAMETER;

		IRE = (IPRouteEntry *)Buffer;

		OutNTE = NULL;
		LocalNTE = NULL;

		Dest = IRE->ire_dest;
		NextHop = IRE->ire_nexthop;

		// Make sure that the nexthop is sensible. We don't allow nexthops
		// to be broadcast or invalid or loopback addresses.
		if (IP_ADDR_EQUAL(NextHop, NULL_IP_ADDR) || IP_LOOPBACK(NextHop) ||
			CLASSD_ADDR(NextHop) || CLASSE_ADDR(NextHop))
			return TDI_INVALID_PARAMETER;

		// Also make sure that the destination we're routing to is sensible.
		// Don't allow routes to be added to Class D or E or loopback
		// addresses.
		if (IP_LOOPBACK(Dest) || CLASSD_ADDR(Dest) || CLASSE_ADDR(Dest))
			return TDI_INVALID_PARAMETER;

		if (IRE->ire_index == LoopIndex)
			return TDI_INVALID_PARAMETER;

		if (IRE->ire_index  != INVALID_IF_INDEX) {

			// First thing to do is to find the outgoing NTE for specified
			// interface, and also make sure that it matches the destination
			// if the destination is one of my addresses.
			for (TempNTE = NetTableList; TempNTE != NULL;
				TempNTE = TempNTE->nte_next) {
				if (OutNTE == NULL && IRE->ire_index == TempNTE->nte_if->if_index)
					OutNTE = TempNTE;
				if (IP_ADDR_EQUAL(NextHop, TempNTE->nte_addr) &&
					(TempNTE->nte_flags & NTE_VALID))
					LocalNTE = TempNTE;
	
				// Don't let a route be set through a broadcast address.
				if (IsBCastOnNTE(NextHop, TempNTE) != DEST_LOCAL)
					return TDI_INVALID_PARAMETER;
				
				// Don't let a route to a broadcast address be added or deleted.
				if (IsBCastOnNTE(Dest, TempNTE) != DEST_LOCAL)
					return TDI_INVALID_PARAMETER;
			}
	
			// At this point OutNTE points to the outgoing NTE, and LocalNTE
			// points to the NTE for the local address, if this is a direct route.
			// Make sure they point to the same interface, and that the type is
			// reasonable.
			if (OutNTE == NULL)
				return TDI_INVALID_PARAMETER;
	
			if (LocalNTE != NULL) {
				// He's routing straight out a local interface. The interface for
				// the local address must match the interface passed in, and the
				// type must be DIRECT (if we're adding) or INVALID (if we're
				// deleting).
				if (LocalNTE->nte_if->if_index != IRE->ire_index)
					return TDI_INVALID_PARAMETER;
	
				if (IRE->ire_type != IRE_TYPE_DIRECT &&
					IRE->ire_type != IRE_TYPE_INVALID)
					return TDI_INVALID_PARAMETER;
				
				OutNTE = LocalNTE;
			}
	
	
			// Figure out what the first hop should be. If he's routing straight
			// through a local interface, or the next hop is equal to the
			// destination, then the first hop is IPADDR_LOCAL. Otherwise it's the
			// address of the gateway.
			if (LocalNTE != NULL)
				FirstHop = IPADDR_LOCAL;
			else
				if (IP_ADDR_EQUAL(Dest, NextHop))
					FirstHop = IPADDR_LOCAL;
				else
					FirstHop = NextHop;

		    MTU = OutNTE->nte_mss;
			OutIF = OutNTE->nte_if;

		} else {
			OutIF = (Interface *)&DummyInterface;
			MTU = DummyInterface.ri_if.if_mtu - sizeof(IPHeader);
			if (IP_ADDR_EQUAL(Dest, NextHop))
				FirstHop = IPADDR_LOCAL;
			else
				FirstHop = NextHop;
		}

		// We've done the validation. See if he's adding or deleting a route.
		if (IRE->ire_type != IRE_TYPE_INVALID) {
			// He's adding a route.
			Status = AddRoute(Dest, IRE->ire_mask, FirstHop, OutIF,
				MTU, IRE->ire_metric1, IRE->ire_proto,
				ATYPE_OVERRIDE, IRE->ire_context);

		} else {
			// He's deleting a route.
			Status = DeleteRoute(Dest, IRE->ire_mask, FirstHop, OutIF);
		}
		
		if (Status == IP_SUCCESS)
			return TDI_SUCCESS;
		else
			if (Status == IP_NO_RESOURCES)
				return TDI_NO_RESOURCES;
			else
				return TDI_INVALID_PARAMETER;
					
	} else {
		if (ID->toi_id == IP_MIB_STATS_ID) {
			IPSNMPInfo		*Info = (IPSNMPInfo *)Buffer;
			
			// Setting information about TTL and/or routing.
			if (Info->ipsi_defaultttl > 255 || (!RouterConfigured &&
				Info->ipsi_forwarding == IP_FORWARDING)) {
				return TDI_INVALID_PARAMETER;
			}
			
			DefaultTTL = Info->ipsi_defaultttl;
			ForwardPackets = Info->ipsi_forwarding == IP_FORWARDING ? TRUE :
				FALSE;
			
			return TDI_SUCCESS;
		}
		return TDI_INVALID_PARAMETER;
	}
	
}
#ifndef CHICAGO
#pragma BEGIN_INIT
#endif

//*	IPGetEList - Get the entity list.
//
//	Called at init time to get an entity list. We fill our stuff in, and
//	then call the interfaces below us to allow them to do the same.
//
//	Input:	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.
//
long
IPGetEList(TDIEntityID *EList, uint *Count)
{
	uint		ECount;
	uint		MyIPBase;
	uint		MyERBase;
	int			Status;
	uint		i;
	Interface	*LowerIF;
	TDIEntityID *EntityList;

	ECount = *Count;
	EntityList = EList;

	// Walk down the list, looking for existing CL_NL or ER entities, and
	// adjust our base instance accordingly.

	MyIPBase = 0;
	MyERBase = 0;
	for (i = 0; i < ECount; i++, EntityList++) {
		if (EntityList->tei_entity == CL_NL_ENTITY)
			MyIPBase = MAX(MyIPBase, EntityList->tei_instance + 1);
		else
			if (EntityList->tei_entity == ER_ENTITY)
				MyERBase = MAX(MyERBase, EntityList->tei_instance + 1);
	}
	
	// At this point we've figure out our base instance. Save for later use.
	IPInstance = MyIPBase;
	ICMPInstance = MyERBase;

	// EntityList points to the start of where we want to begin filling in.
	// Make sure we have enough room. We need one for the ICMP instance,
	// and one for the CL_NL instance.

	if ((ECount + 2) > MAX_TDI_ENTITIES)
		return TDI_REQ_ABORTED;

	// Now fill it in.
	EntityList->tei_entity = CL_NL_ENTITY;
	EntityList->tei_instance = IPInstance;
	EntityList++;
	EntityList->tei_entity = ER_ENTITY;
	EntityList->tei_instance = ICMPInstance;
	*Count += 2;

	// Loop through the interfaces, querying each of them.
	for (LowerIF = IFList; LowerIF != NULL; LowerIF = LowerIF->if_next) {
		Status = (*LowerIF->if_getelist)(LowerIF->if_lcontext, EList, Count);
		if (!Status)
			return TDI_BUFFER_TOO_SMALL;
	}
	
	return TDI_SUCCESS;
}
			
#ifndef CHICAGO
#pragma END_INIT
#endif