able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tcpip/driver/ipv4/info.c

1675 lines
56 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990-2000 Microsoft Corporation
Module Name:
info.c - Routines for querying and setting IP information.
Abstract:
This file contains the code for dealing with Query/Set information calls.
Author:
[Environment:]
kernel mode only
[Notes:]
optional-notes
Revision History:
--*/
#include "precomp.h"
#include "info.h"
#include "iproute.h"
#include "igmp.h"
#include "iprtdef.h"
#include "arpdef.h"
#include "ntddndis.h"
#include "tcpipbuf.h"
extern NDIS_HANDLE BufferPool;
extern Interface *IFList;
extern NetTableEntry **NewNetTableList; // hash table for NTEs
extern uint NET_TABLE_SIZE;
extern uint LoopIndex; // Index of loopback I/F.
extern uint DefaultTTL;
extern uint NumIF;
extern uint NumNTE;
extern uint NumActiveNTE;
extern RouteInterface DummyInterface; // Dummy interface.
extern NetTableEntry *LoopNTE; // Pointer to loopback NTE
extern uint RTEReadNext(void *Context, void *Buffer);
extern uint RTValidateContext(void *Context, uint * Valid);
extern uint RTReadNext(void *Context, void *Buffer);
extern uint RTRead(void *Context, void *Buffer);
extern void IPInitOptions(IPOptInfo *);
uint IPInstance = INVALID_ENTITY_INSTANCE;
uint ICMPInstance = INVALID_ENTITY_INSTANCE;
TDIEntityID* IPEntityList = NULL;
uint IPEntityCount = 0;
#if FFP_SUPPORT
FFPDriverStats GlobalStatsInfoPrev = {0}; // Stats from the previous request
FFPDriverStats GlobalStatsInfoCurr = {0}; // Stats from the current request
#endif // if FFP_SUPPORT
#define MIB_IPADDR_PRIMARY 1
//* CopyToNdisSafe - 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.
// pNextBuf - Pointer to next buffer in chain to copy into.
// 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: TRUE - Successfully copied flat buffer into NDIS_BUFFER chain.
// FALSE - Failed to copy entire flat buffer.
//
BOOLEAN
CopyToNdisSafe(PNDIS_BUFFER DestBuf, PNDIS_BUFFER * ppNextBuf,
uchar * SrcBuf, uint Size, uint * StartOffset)
{
uint CopySize;
uchar *DestPtr;
uint DestSize;
uint Offset = *StartOffset;
uchar *VirtualAddress;
uint Length;
ASSERT(DestBuf != NULL);
ASSERT(SrcBuf != NULL);
TcpipQueryBuffer(DestBuf, &VirtualAddress, &Length, NormalPagePriority);
if (VirtualAddress == NULL) {
return (FALSE);
}
ASSERT(Length >= Offset);
DestPtr = VirtualAddress + Offset;
DestSize = Length - Offset;
for (;;) {
CopySize = MIN(Size, DestSize);
RtlCopyMemory(DestPtr, SrcBuf, CopySize);
DestPtr += CopySize;
SrcBuf += CopySize;
if ((Size -= CopySize) == 0)
break;
if ((DestSize -= CopySize) == 0) {
DestBuf = NDIS_BUFFER_LINKAGE(DestBuf);
ASSERT(DestBuf != NULL);
TcpipQueryBuffer(DestBuf, &VirtualAddress, &Length, NormalPagePriority);
if (VirtualAddress == NULL) {
return FALSE;
}
DestPtr = VirtualAddress;
DestSize = Length;
}
}
*StartOffset = (uint) (DestPtr - VirtualAddress);
if (ppNextBuf) {
*ppNextBuf = DestBuf;
}
return TRUE;
}
// this structure is used in IPQueryInfo for IP_MIB_ADDRTABLE_ENTRY_ID
typedef struct _INFO_LIST {
struct _INFO_LIST *info_next;
NetTableEntry *info_nte;
} INFO_LIST, *PINFO_LIST;
//* FreeInfoList - Free INFO_LIST used in IPQueryInfo for IP_MIB_ADDRTABLE_ENTRY_ID
//
// Input: Temp - List to be freed
//
// Returns: Nothing.
//
void
FreeInfoList(PINFO_LIST Temp)
{
PINFO_LIST NextTemp;
PINFO_LIST CurrTemp = Temp;
while (CurrTemp) {
NextTemp = CurrTemp->info_next;
CTEFreeMem(CurrTemp);
CurrTemp = NextTemp;
}
}
//* 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;
uint i;
uint bucket;
NetTableEntry *NetTableList;
CTELockHandle TableHandle;
IPInternalPerCpuStats SumCpuStats;
BOOLEAN fStatus;
DEBUGMSG(DBG_TRACE && DBG_QUERYINFO,
(DTEXT("+IPQueryInfo(%x, %x, %x, %x)\n"), ID, Buffer, Size, Context));
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.
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LowerIF = IFList;
while (LowerIF) {
if (LowerIF->if_refcount == 0) {
// this interface is about to get deleted
// fail the request
// we can also skip this interface
LowerIF = LowerIF->if_next;
continue;
}
LOCKED_REFERENCE_IF(LowerIF);
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
// we have freed the routetablelock here
// but since we have a refcount on LowerIF, LowerIF can't go away
Status = (*LowerIF->if_qinfo) (LowerIF->if_lcontext, ID, Buffer,
Size, Context);
if (Status != TDI_INVALID_REQUEST) {
DerefIF(LowerIF);
return Status;
}
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LockedDerefIF(LowerIF);
// LowerIF->if_next can't be freed at this point.
LowerIF = LowerIF->if_next;
}
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
// 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;
fStatus = CopyToNdisSafe(Buffer, NULL, InfoBuff, sizeof(uint), &Offset);
if (fStatus == FALSE) {
return TDI_NO_RESOURCES;
}
*Size = sizeof(uint);
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;
fStatus = CopyToNdisSafe(Buffer, &Buffer, (uchar *) & ICMPInStats, sizeof(ICMPStats), &Offset);
if (fStatus == TRUE) {
fStatus = CopyToNdisSafe(Buffer, NULL, (uchar *) & ICMPOutStats, sizeof(ICMPStats),
&Offset);
if (fStatus == TRUE) {
*Size = sizeof(ICMPSNMPInfo);
return TDI_SUCCESS;
}
}
return (TDI_NO_RESOURCES);
}
// 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 = NumActiveNTE;
IPSInfo.ipsi_defaultttl = DefaultTTL;
IPSInfo.ipsi_forwarding = ForwardPackets ? IP_FORWARDING :
IP_NOT_FORWARDING;
#if FFP_SUPPORT
//
// Tweak SNMP information to include information from FFP'ed packets
//
// Keep a copy of the prev stats for use
RtlCopyMemory(&GlobalStatsInfoPrev, &GlobalStatsInfoCurr, sizeof(FFPDriverStats));
// Get the stats by querying the driver
IPStatsFromFFPCaches(&GlobalStatsInfoCurr);
// These counts missed packets fast fwded from last time a query was made
IPPerCpuStats[0].ics_inreceives +=
GlobalStatsInfoCurr.PacketsForwarded - GlobalStatsInfoPrev.PacketsForwarded;
IPSInfo.ipsi_forwdatagrams +=
GlobalStatsInfoCurr.PacketsForwarded - GlobalStatsInfoPrev.PacketsForwarded;
// These counts missed all packets dropped from last time a query was made
IPPerCpuStats[0].ics_inreceives +=
GlobalStatsInfoCurr.PacketsDiscarded - GlobalStatsInfoPrev.PacketsDiscarded;
IPSInfo.ipsi_outdiscards +=
GlobalStatsInfoCurr.PacketsDiscarded - GlobalStatsInfoPrev.PacketsDiscarded;
#endif // if FFP_SUPPORT
#if !MILLEN
IPSGetTotalCounts(&SumCpuStats);
IPSInfo.ipsi_inreceives = SumCpuStats.ics_inreceives;
IPSInfo.ipsi_indelivers = SumCpuStats.ics_indelivers;
#endif
fStatus = CopyToNdisSafe(Buffer, NULL, (uchar *) & IPSInfo, sizeof(IPSNMPInfo), &Offset);
if (fStatus == TRUE) {
BytesCopied = sizeof(IPSNMPInfo);
Status = TDI_SUCCESS;
} else {
Status = TDI_NO_RESOURCES;
}
break;
case IP_MIB_ADDRTABLE_ENTRY_ID:
{
PINFO_LIST PrimaryList, NonDynamicList, DynamicList, UniList;
PINFO_LIST LastPrimaryEle, LastNonDynamicEle, LastDynamicEle, LastUniEle;
PINFO_LIST SavedTempInfo = NULL;
PINFO_LIST tempInfo;
PINFO_LIST FinalList, LastFinalListEle;
PINFO_LIST CurrentNTEInfo;
// 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;
// Build 3 lists: Primary, nondynamic nonprimary and dynamic
PrimaryList = NULL;
NonDynamicList = NULL;
DynamicList = NULL;
UniList = NULL;
LastPrimaryEle = NULL;
LastNonDynamicEle = NULL;
LastDynamicEle = NULL;
LastUniEle = NULL;
for (i = 0; i < NET_TABLE_SIZE; i++) {
for (CurrentNTE = NewNetTableList[i];
CurrentNTE != NULL;
CurrentNTE = CurrentNTE->nte_next) {
if ((CurrentNTE->nte_flags & NTE_VALID) &&
CurrentNTE->nte_if->if_flags & IF_FLAGS_UNI) {
// allocate the block to store the info
tempInfo = CTEAllocMemN(sizeof(INFO_LIST), '1ICT');
if (!tempInfo) {
// free all the lists
FreeInfoList(PrimaryList);
FreeInfoList(NonDynamicList);
FreeInfoList(DynamicList);
FreeInfoList(UniList);
return TDI_NO_RESOURCES;
}
if (UniList == NULL) {
// this is the last element in this list
LastUniEle = tempInfo;
}
tempInfo->info_nte = CurrentNTE;
tempInfo->info_next = UniList;
UniList = tempInfo;
} else if (CurrentNTE->nte_flags & NTE_PRIMARY) {
// allocate the block to store the info
tempInfo = CTEAllocMemN(sizeof(INFO_LIST), '1ICT');
if (!tempInfo) {
// free all the lists
FreeInfoList(PrimaryList);
FreeInfoList(NonDynamicList);
FreeInfoList(DynamicList);
FreeInfoList(UniList);
return TDI_NO_RESOURCES;
}
if (PrimaryList == NULL) {
// this is the last element in this list
LastPrimaryEle = tempInfo;
}
tempInfo->info_nte = CurrentNTE;
tempInfo->info_next = PrimaryList;
PrimaryList = tempInfo;
} else if (CurrentNTE->nte_flags & NTE_DYNAMIC) {
// allocate the block to store the info
tempInfo = CTEAllocMemN(sizeof(INFO_LIST), '1ICT');
if (!tempInfo) {
// free all the lists
FreeInfoList(PrimaryList);
FreeInfoList(NonDynamicList);
FreeInfoList(DynamicList);
FreeInfoList(UniList);
return TDI_NO_RESOURCES;
}
if (DynamicList == NULL) {
// this is the last element in this list
LastDynamicEle = tempInfo;
}
tempInfo->info_nte = CurrentNTE;
tempInfo->info_next = DynamicList;
DynamicList = tempInfo;
} else {
INFO_LIST** nextInfo;
// Non primary non Dynamic list
// allocate the block to store the info
tempInfo = CTEAllocMemN(sizeof(INFO_LIST), '1ICT');
if (!tempInfo) {
// free all the lists
FreeInfoList(PrimaryList);
FreeInfoList(NonDynamicList);
FreeInfoList(DynamicList);
FreeInfoList(UniList);
return TDI_NO_RESOURCES;
}
// Even though we are reading from a hash-table,
// we need to preserve the ordering of entries
// as given on the entries' interfaces' 'if_ntelist'.
// Attempt to find the entry for this NTE's predecessor
// and, if found, place this entry before that.
// This builds the list in reverse order, and ensures
// that an entry whose predecessor is not on the list
// will appear last.
for (nextInfo = &NonDynamicList;
(*nextInfo) &&
(*nextInfo)->info_nte->nte_ifnext != CurrentNTE;
nextInfo = &(*nextInfo)->info_next) { }
tempInfo->info_nte = CurrentNTE;
tempInfo->info_next = *nextInfo;
*nextInfo = tempInfo;
if (!tempInfo->info_next)
LastNonDynamicEle = tempInfo;
}
if (NTEContext != 0) {
if (CurrentNTE->nte_context == NTEContext) {
SavedTempInfo = tempInfo;
}
}
} // for (CurrentNTE ...
} // for (i= ...
// at this point we have 4 lists and we have to merge 4 lists
// order should be Uni -> Dynamic -> NonDynamic -> Primary
FinalList = NULL;
LastFinalListEle = NULL;
if (UniList) {
if (FinalList == NULL) {
FinalList = UniList;
LastFinalListEle = LastUniEle;
} else {
LastFinalListEle->info_next = UniList;
LastFinalListEle = LastUniEle;
}
}
if (DynamicList) {
if (FinalList == NULL) {
FinalList = DynamicList;
LastFinalListEle = LastDynamicEle;
} else {
LastFinalListEle->info_next = DynamicList;
LastFinalListEle = LastDynamicEle;
}
}
if (NonDynamicList) {
if (FinalList == NULL) {
FinalList = NonDynamicList;
LastFinalListEle = LastNonDynamicEle;
} else {
LastFinalListEle->info_next = NonDynamicList;
LastFinalListEle = LastNonDynamicEle;
}
}
if (PrimaryList) {
if (FinalList == NULL) {
FinalList = PrimaryList;
LastFinalListEle = LastPrimaryEle;
} else {
LastFinalListEle->info_next = PrimaryList;
LastFinalListEle = LastPrimaryEle;
}
}
#if MILLEN
#if DBG
if (DBG_INFO && DBG_VERBOSE && DBG_QUERYINFO) {
DEBUGMSG(1,
(DTEXT("IP_MIB_ADDRTABLE_ENTRY_ID: List before reverse:\n")));
CurrentNTEInfo = FinalList;
while (CurrentNTEInfo) {
DEBUGMSG(1, (DTEXT(" InfoList: %x NTE\n"), CurrentNTEInfo, CurrentNTEInfo->info_nte));
CurrentNTEInfo = CurrentNTEInfo->info_next;
}
}
#endif
// Now guess what Win9X requires us to...reverse the list. It
// expects that the primary is at the start of the list.
{
PINFO_LIST pCurrInfo, pPrevInfo, pNextInfo;
pCurrInfo = FinalList;
pPrevInfo = NULL;
// Exchange final pointers.
FinalList = LastFinalListEle;
LastFinalListEle = pCurrInfo;
while (pCurrInfo) {
pNextInfo = pCurrInfo->info_next;
pCurrInfo->info_next = pPrevInfo;
pPrevInfo = pCurrInfo;
pCurrInfo = pNextInfo;
}
}
#if DBG
if (DBG_INFO && DBG_VERBOSE && DBG_QUERYINFO) {
DEBUGMSG(1,
(DTEXT("IP_MIB_ADDRTABLE_ENTRY_ID: List after reverse:\n")));
CurrentNTEInfo = FinalList;
while (CurrentNTEInfo) {
DEBUGMSG(1, (DTEXT(" InfoList: %x NTE\n"), CurrentNTEInfo, CurrentNTEInfo->info_nte));
CurrentNTEInfo = CurrentNTEInfo->info_next;
}
}
#endif
#endif // MILLEN
// we have at least loopback NTE
ASSERT(FinalList != NULL);
// At this point we have the whole list and also if the user specified NTEContext
// we have the pointer saved in SavedTempInfo
if (SavedTempInfo) {
CurrentNTEInfo = SavedTempInfo;
} else {
CurrentNTEInfo = FinalList;
}
AddrEntry = (IPAddrEntry *) InfoBuff;
fStatus = TRUE;
for (; CurrentNTEInfo != NULL; CurrentNTEInfo = CurrentNTEInfo->info_next) {
// NetTableEntry *CurrentNTE = CurrentNTEInfo->info_nte;
CurrentNTE = CurrentNTEInfo->info_nte;
if (CurrentNTE->nte_flags & NTE_ACTIVE) {
if ((int)(BufferSize - BytesCopied) >= (int)sizeof(IPAddrEntry)) {
// We have room to copy it. Build the entry, and copy
// it.
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;
}
if (!(CurrentNTE->nte_flags & NTE_IF_DELETING)) {
AddrEntry->iae_index = CurrentNTE->nte_if->if_index;
AddrEntry->iae_bcastaddr =
*(int *)&(CurrentNTE->nte_if->if_bcast) & 1;
} else {
AddrEntry->iae_index = INVALID_IF_INDEX;
AddrEntry->iae_bcastaddr = 0;
}
AddrEntry->iae_reasmsize = 0xffff;
AddrEntry->iae_context = CurrentNTE->nte_context;
// LSB will have primary bit set if this is PRIMARY NTE
ASSERT((NTE_PRIMARY >> 2) == MIB_IPADDR_PRIMARY);
AddrEntry->iae_pad = CurrentNTE->nte_flags >> 2;
fStatus = CopyToNdisSafe(Buffer, &Buffer, (uchar *) AddrEntry,
sizeof(IPAddrEntry), &Offset);
if (fStatus == FALSE) {
break;
}
BytesCopied += sizeof(IPAddrEntry);
} else
break;
}
}
if (fStatus == FALSE) {
Status = TDI_NO_RESOURCES;
} else if (CurrentNTEInfo == NULL) {
Status = TDI_SUCCESS;
} else {
Status = TDI_BUFFER_OVERFLOW;
**(ushort **) & Context = CurrentNTE->nte_context;
}
// free the list
FreeInfoList(FinalList);
break;
}
case IP_MIB_RTTABLE_ENTRY_ID:
// Make sure we have a valid context.
CTEGetLock(&RouteTableLock.Lock, &Handle);
DataLeft = RTValidateContext(Context, &Valid);
// If the context is valid, we'll continue trying to read.
if (!Valid) {
CTEFreeLock(&RouteTableLock.Lock, Handle);
return TDI_INVALID_PARAMETER;
}
fStatus = TRUE;
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);
fStatus = CopyToNdisSafe(Buffer, &Buffer, InfoBuff, sizeof(IPRouteEntry),
&Offset);
if (fStatus == FALSE) {
break;
}
} else
break;
}
CTEFreeLock(&RouteTableLock.Lock, Handle);
if (fStatus == FALSE) {
Status = TDI_NO_RESOURCES;
} else {
Status = (!DataLeft ? TDI_SUCCESS : TDI_BUFFER_OVERFLOW);
}
break;
case IP_MIB_SINGLE_RT_ENTRY_ID:
{
CTEGetLock(&RouteTableLock.Lock, &Handle);
if ((int)(BufferSize >= (int)sizeof(IPRouteEntry))) {
Status = RTRead(Context, InfoBuff);
fStatus = CopyToNdisSafe(Buffer, &Buffer, InfoBuff, sizeof(IPRouteEntry),
&Offset);
if (fStatus == FALSE) {
Status = TDI_NO_RESOURCES;
} else {
//Status = TDI_SUCCESS;
BytesCopied = sizeof(IPRouteEntry);
}
} else {
Status = TDI_BUFFER_OVERFLOW;
}
CTEFreeLock(&RouteTableLock.Lock, Handle);
}
break;
case IP_INTFC_INFO_ID:
IFAddr = *(IPAddr *) Context;
// Loop through the NTE table, looking for a match.
NetTableList = NewNetTableList[NET_TABLE_HASH(IFAddr)];
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 = 0;
if (LowerIF->if_flags & IF_FLAGS_P2P) {
IIIPtr->iii_flags |= IP_INTFC_FLAG_P2P;
}
if (LowerIF->if_flags & IF_FLAGS_P2MP) {
IIIPtr->iii_flags |= IP_INTFC_FLAG_P2MP;
}
if (LowerIF->if_flags & IF_FLAGS_UNI) {
IIIPtr->iii_flags |= IP_INTFC_FLAG_UNIDIRECTIONAL;
}
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_NO_RESOURCES;
fStatus = CopyToNdisSafe(Buffer, &Buffer, InfoBuff,
offsetof(IPInterfaceInfo, iii_addr), &Offset);
if (fStatus == TRUE) {
if (LowerIF->if_addr) {
fStatus = CopyToNdisSafe(Buffer, NULL,
LowerIF->if_addr, LowerIF->if_addrlen, &Offset);
if (fStatus == TRUE) {
Status = TDI_SUCCESS;
BytesCopied += LowerIF->if_addrlen;
}
} else {
Status = TDI_SUCCESS;
}
}
} else {
Status = TDI_BUFFER_TOO_SMALL;
}
break;
case IP_GET_BEST_SOURCE: {
IPAddr Dest = * (IPAddr *) Context;
IPAddr Source;
RouteCacheEntry *RCE;
ushort MSS;
uchar Type;
IPOptInfo OptInfo;
if (BufferSize < sizeof Source) {
Status = TDI_BUFFER_TOO_SMALL;
break;
}
IPInitOptions(&OptInfo);
Source = OpenRCE(Dest, NULL_IP_ADDR, &RCE, &Type, &MSS, &OptInfo);
if (!IP_ADDR_EQUAL(Source, NULL_IP_ADDR))
CloseRCE(RCE);
fStatus = CopyToNdisSafe(Buffer, &Buffer,
(uchar *)&Source, sizeof Source, &Offset);
if (fStatus == FALSE) {
Status = TDI_NO_RESOURCES;
} else {
Status = TDI_SUCCESS;
BytesCopied = sizeof Source;
}
break;
}
default:
return TDI_INVALID_PARAMETER;
break;
}
*Size = BytesCopied;
return Status;
}
//* IPSetNdisRequest - IP set ndis request handler.
//
// Called by the upper layer when it wants to set the general packet filter for
// the corr. arp interface
//
// Input: IPAddr - Addr of addrobject to set on
// NDIS_OID - Packet Filter
// On - Set_if, clear_if or clear_card
// IfIndex - IfIndex if IPAddr not given
//
// Returns: Matched if index or 0 if failure
//
ulong
IPSetNdisRequest(IPAddr Addr, NDIS_OID OID, uint On, uint IfIndex)
{
Interface *IF = NULL;
NetTableEntry *NTE;
int Status;
uint i;
CTELockHandle Handle;
uint Index;
// set the interface to promiscuous mcast mode
// scan s.t. match numbered interface with Addr or unnumbered interface
// with IfIndex
// can optimize it by taking special case for unnumbered interface
CTEGetLock(&RouteTableLock.Lock, &Handle);
for (i = 0; i < NET_TABLE_SIZE; i++) {
NetTableEntry *NetTableList = NewNetTableList[i];
for (NTE = NetTableList; NTE != NULL; NTE = NTE->nte_next) {
if (NTE != LoopNTE && (NTE->nte_flags & NTE_VALID) &&
(IP_ADDR_EQUAL(NTE->nte_addr, Addr) ||
NTE->nte_if->if_index == IfIndex)) {
// Found one. Save it and break out.
IF = NTE->nte_if;
break;
}
}
if (IF) {
Index = IF->if_index;
break;
}
}
if (IF) {
if (!IF->if_setndisrequest) {
CTEFreeLock(&RouteTableLock.Lock, Handle);
return 0;
}
if (On != CLEAR_CARD) { // just clear the option on the card
IF->if_promiscuousmode = (uchar)On;
}
LOCKED_REFERENCE_IF(IF);
CTEFreeLock(&RouteTableLock.Lock, Handle);
Status = (*(IF->if_setndisrequest)) (IF->if_lcontext, OID, On);
DerefIF(IF);
if (Status != NDIS_STATUS_SUCCESS) {
return 0;
}
} else {
CTEFreeLock(&RouteTableLock.Lock, Handle);
return 0;
}
return Index;
}
//* IPAbsorbRtrAlert - IP absorb rtr alert packet handler.
//
// Called by the upper layer when it wants to set the general packet filter for
// the corr. arp interface
//
// Input: IPAddr - Addr of addrobject to set on
// Protocol - if 0 turn of the option
// IfIndex - IfIndex if IPAddr not given
//
// Returns: Matched if index or 0 if failure
//
ulong
IPAbsorbRtrAlert(IPAddr Addr, uchar Protocol, uint IfIndex)
{
Interface *IF = NULL;
NetTableEntry *NTE;
int Status;
uint i;
CTELockHandle Handle;
uint Index;
// can optimize it by taking special case for unnumbered interface
CTEGetLock(&RouteTableLock.Lock, &Handle);
for (i = 0; i < NET_TABLE_SIZE; i++) {
NetTableEntry *NetTableList = NewNetTableList[i];
for (NTE = NetTableList; NTE != NULL; NTE = NTE->nte_next) {
if (NTE != LoopNTE && (NTE->nte_flags & NTE_VALID) &&
(IP_ADDR_EQUAL(NTE->nte_addr, Addr) ||
NTE->nte_if->if_index == IfIndex)) {
// Found one. Save it and break out.
IF = NTE->nte_if;
break;
}
}
if (IF) {
Index = IF->if_index;
break;
}
}
if (IF) {
// we are keeping this property per interface so if there are 2 NTEs
// on that interface its
// set/unset on the interface
// will decide later whether want to keep it per NTE also.
IF->if_absorbfwdpkts = Protocol;
CTEFreeLock(&RouteTableLock.Lock, Handle);
return Index;
}
CTEFreeLock(&RouteTableLock.Lock, Handle);
return 0;
}
NTSTATUS
SetIFPromiscuous(ULONG Index, UCHAR Type, UCHAR Add)
{
Interface *pIf;
BOOLEAN bFound = FALSE;
UINT On;
CTELockHandle Handle;
CTEGetLock(&RouteTableLock.Lock, &Handle);
//
// Walk the interface to find the one with the given index
//
for (pIf = IFList; pIf != NULL; pIf = pIf->if_next) {
if ((pIf->if_refcount != 0) && (pIf->if_index == Index)) {
bFound = TRUE;
break;
}
}
if (!bFound) {
CTEFreeLock(&RouteTableLock.Lock, Handle);
return STATUS_OBJECT_NAME_NOT_FOUND;
} else {
LOCKED_REFERENCE_IF(pIf);
CTEFreeLock(&RouteTableLock.Lock, Handle);
}
if (pIf->if_setndisrequest == NULL) {
DerefIF(pIf);
return STATUS_NOT_SUPPORTED;
}
if (Add == 0) {
On = 0;
} else {
if (Add == 1) {
On = 1;
} else {
DerefIF(pIf);
return STATUS_INVALID_PARAMETER;
}
}
if (Type == PROMISCUOUS_MCAST) {
NTSTATUS status;
status = (*(pIf->if_setndisrequest)) (pIf->if_lcontext,
NDIS_PACKET_TYPE_ALL_MULTICAST,
On);
DerefIF(pIf);
return status;
}
if (Type == PROMISCUOUS_BCAST) {
NTSTATUS status;
status = (*(pIf->if_setndisrequest)) (pIf->if_lcontext,
NDIS_PACKET_TYPE_PROMISCUOUS,
On);
DerefIF(pIf);
return status;
}
DerefIF(pIf);
return STATUS_INVALID_PARAMETER;
}
//* 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;
uint i;
CTELockHandle TableHandle;
uint Flags;
uchar Dtype;
DEBUGMSG(DBG_TRACE && DBG_SETINFO,
(DTEXT("+IPSetInfo(%x, %x, %d)\n"), ID, Buffer, Size));
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.
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LowerIF = IFList;
while (LowerIF) {
if (LowerIF->if_refcount == 0) {
// this interface is about to get deleted
// fail the request
break;
}
LOCKED_REFERENCE_IF(LowerIF);
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
// we have freed the routetablelock here
// but since we have a refcount on LowerIF, LowerIF can't go away
Status = (*LowerIF->if_setinfo) (LowerIF->if_lcontext, ID, Buffer,
Size);
if (Status != TDI_INVALID_REQUEST) {
DEBUGMSG(DBG_ERROR && DBG_SETINFO,
(DTEXT("IPSetInfo: if_setinfo failure %x\n"), Status));
DerefIF(LowerIF);
return Status;
}
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LockedDerefIF(LowerIF);
// LowerIF->if_next can't be freed at this point.
LowerIF = LowerIF->if_next;
}
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
// 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.
Flags = RT_EXCLUDE_LOCAL;
if (ID->toi_id == IP_MIB_RTTABLE_ENTRY_ID_EX) {
Flags |= RT_NO_NOTIFY;
ID->toi_id = IP_MIB_RTTABLE_ENTRY_ID;
}
if (ID->toi_id == IP_MIB_RTTABLE_ENTRY_ID) {
NetTableEntry *TempNTE;
DEBUGMSG(DBG_INFO && DBG_SETINFO,
(DTEXT("IPSetInfo: IP_MIB_RTTABLE_ENTRY_ID - set route table entry.\n")));
// This is an attempt to set a route table entry. Make sure the
// size if correct.
if (Size < sizeof(IPRouteEntry)) {
DEBUGMSG(DBG_ERROR,
(DTEXT("IPSetInfo RTTABLE: Buffer too small %d (IPRouteEntry = %d)\n"),
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_LOOPBACK(NextHop) || CLASSD_ADDR(NextHop) ||
CLASSE_ADDR(NextHop)) {
DEBUGMSG(DBG_ERROR,
(DTEXT("IPSetInfo RTTABLE: Invalid next hop %x\n"), 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 E or loopback addresses
if (IP_LOOPBACK(Dest) || CLASSE_ADDR(Dest))
return TDI_INVALID_PARAMETER;
if (IRE->ire_index == LoopIndex) {
DEBUGMSG(DBG_ERROR,
(DTEXT("IPSetInfo RTTABLE: index == LoopIndex!! Invalid!\n")));
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 (i = 0; i < NET_TABLE_SIZE; i++) {
NetTableEntry *NetTableList = NewNetTableList[i];
for (TempNTE = NetTableList; TempNTE != NULL;
TempNTE = TempNTE->nte_next) {
if ((OutNTE == NULL) && (TempNTE->nte_flags & NTE_VALID) && (IRE->ire_index == TempNTE->nte_if->if_index))
OutNTE = TempNTE;
if (!IP_ADDR_EQUAL(NextHop, NULL_IP_ADDR) &&
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) {
DEBUGMSG(DBG_ERROR,
(DTEXT("IPSetInfo RTTABLE: Bcast address. Invalid NextHop!\n")));
return TDI_INVALID_PARAMETER;
}
// Don't let a route to a broadcast address be added or deleted.
Dtype = IsBCastOnNTE(Dest, TempNTE);
if ((Dtype != DEST_LOCAL) && (Dtype != DEST_MCAST)) {
DEBUGMSG(DBG_ERROR,
(DTEXT("IPSetInfo RTTABLE: Bcast address. Invalid Dest!\n")));
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).
// LocalNTE is valid at this point
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) || IP_ADDR_EQUAL(NextHop, NULL_IP_ADDR))
FirstHop = IPADDR_LOCAL;
else if (IP_ADDR_EQUAL(Dest, NextHop))
FirstHop = IPADDR_LOCAL;
else
FirstHop = NextHop;
MTU = OutNTE->nte_mss;
// Take RouteTableLock
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
if ((OutNTE->nte_flags & NTE_VALID) && OutNTE->nte_if->if_refcount) {
// ref the IF
OutIF = OutNTE->nte_if;
if (IP_ADDR_EQUAL(NextHop, NULL_IP_ADDR)) {
if (!(OutIF->if_flags & IF_FLAGS_P2P)) {
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
return TDI_INVALID_PARAMETER;
}
}
LOCKED_REFERENCE_IF(OutIF);
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
} else {
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
return TDI_INVALID_PARAMETER;
}
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.
uint AType = ATYPE_OVERRIDE;
DEBUGMSG(DBG_INFO && DBG_SETINFO,
(DTEXT("IPSetInfo RTTABLE: Calling AddRoute addr %x mask %x\n"),
Dest, IRE->ire_mask));
Status = AddRoute(Dest, IRE->ire_mask, FirstHop, OutIF,
MTU, IRE->ire_metric1, IRE->ire_proto,
AType, IRE->ire_context, Flags);
DEBUGMSG(Status != IP_SUCCESS && DBG_ERROR && DBG_SETINFO,
(DTEXT("IPSetInfo: AddRoute failure %x\n"), Status));
} else {
DEBUGMSG(DBG_INFO && DBG_SETINFO,
(DTEXT("IPSetInfo RTTABLE: Calling DeleteRoute addr %x mask %x\n"),
Dest, IRE->ire_mask));
// He's deleting a route.
Status = DeleteRoute(Dest, IRE->ire_mask, FirstHop, OutIF, Flags);
DEBUGMSG(Status != IP_SUCCESS && DBG_ERROR && DBG_SETINFO,
(DTEXT("IPSetInfo: DeleteRoute failure %x\n"), Status));
}
if (IRE->ire_index != INVALID_IF_INDEX) {
ASSERT(OutIF != (Interface *) & DummyInterface);
DerefIF(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;
}
}
#pragma BEGIN_INIT
//* 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;
TDIEntityID *IPEntity, *EREntity;
CTELockHandle TableHandle;
EntityList = EList;
// Walk down the list, looking for existing CL_NL or ER entities, and
// adjust our base instance accordingly.
// if we are already on the list then do nothing.
// if we are going away, mark our entry invalid.
MyIPBase = 0;
MyERBase = 0;
IPEntity = NULL;
EREntity = NULL;
for (i = 0; i < *Count; i++, EntityList++) {
if (EntityList->tei_entity == CL_NL_ENTITY &&
EntityList->tei_entity != INVALID_ENTITY_INSTANCE) {
// if we are already on the list remember our entity item
// o/w find an instance # for us.
if (EntityList->tei_instance == IPInstance) {
IPEntity = EntityList;
} else {
MyIPBase = MAX(MyIPBase, EntityList->tei_instance + 1);
}
} else {
if (EntityList->tei_entity == ER_ENTITY &&
EntityList->tei_entity != INVALID_ENTITY_INSTANCE)
// if we are already on the list remember our entity item
// o/w find an instance # for us.
if (EntityList->tei_instance == ICMPInstance) {
EREntity = EntityList;
} else {
MyERBase = MAX(MyERBase, EntityList->tei_instance + 1);
}
}
if (IPEntity && EREntity) {
break;
}
}
if (!IPEntity) {
// we are not on the list.
// insert ourself iff we are not going away.
// make sure we have the room for it.
if (*Count >= MAX_TDI_ENTITIES) {
return TDI_REQ_ABORTED;
}
IPInstance = MyIPBase;
IPEntity = &EList[*Count];
IPEntity->tei_entity = CL_NL_ENTITY;
IPEntity->tei_instance = MyIPBase;
(*Count)++;
}
if (!EREntity) {
// we are not on the list.
// insert ourself iff we are not going away.
// make sure we have the room for it.
if (*Count >= MAX_TDI_ENTITIES) {
return TDI_REQ_ABORTED;
}
ICMPInstance = MyERBase;
EREntity = &EList[*Count];
EREntity->tei_entity = ER_ENTITY;
EREntity->tei_instance = MyERBase;
(*Count)++;
}
// Loop through the interfaces, querying each of them.
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LowerIF = IFList;
while (LowerIF) {
if (LowerIF->if_refcount == 0) {
LowerIF = LowerIF->if_next;
continue;
}
LOCKED_REFERENCE_IF(LowerIF);
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
Status = (*LowerIF->if_getelist) (LowerIF->if_lcontext, EList, Count);
if (!Status) {
DerefIF(LowerIF);
return TDI_BUFFER_TOO_SMALL;
}
CTEGetLock(&RouteTableLock.Lock, &TableHandle);
LockedDerefIF(LowerIF);
// LowerIF->if_next can't be freed at this point.
LowerIF = LowerIF->if_next;
}
// Finally, cache the entries that are now on the list.
// Note that our cache is covered by 'RouteTableLock'.
if (!IPEntityList) {
IPEntityList = CTEAllocMem(sizeof(TDIEntityID) * MAX_TDI_ENTITIES);
}
if (IPEntityList) {
RtlZeroMemory(IPEntityList, sizeof(IPEntityList));
if (IPEntityCount = *Count) {
RtlCopyMemory(IPEntityList, EList, IPEntityCount * sizeof(*EList));
}
}
CTEFreeLock(&RouteTableLock.Lock, TableHandle);
return TDI_SUCCESS;
}
#pragma END_INIT
//* IPWakeupPattern - add or remove IP wakeup pattern.
//
// Entry: InterfaceConext - ip interface context for which the pattern is to be added/removed
// PtrnDesc - Pattern Descriptor
// AddPattern - TRUE - add, FALSE - remove
// Returns: Nothing.
//
NTSTATUS
IPWakeupPattern(uint InterfaceContext, PNET_PM_WAKEUP_PATTERN_DESC PtrnDesc,
BOOLEAN AddPattern)
{
Interface *IF;
CTELockHandle Handle;
NTSTATUS status;
CTEGetLock(&RouteTableLock.Lock, &Handle);
for (IF = IFList; IF != NULL; IF = IF->if_next) {
if ((IF->if_refcount != 0) && (IF->if_index == InterfaceContext)) {
break;
}
}
if (IF == (Interface *) NULL) {
CTEFreeLock(&RouteTableLock.Lock, Handle);
return STATUS_INVALID_HANDLE;
} else {
LOCKED_REFERENCE_IF(IF);
CTEFreeLock(&RouteTableLock.Lock, Handle);
}
if (NULL == IF->if_dowakeupptrn) {
DerefIF(IF);
return STATUS_NOT_SUPPORTED;
}
status = (*(IF->if_dowakeupptrn)) (IF->if_lcontext, PtrnDesc, ARP_ETYPE_IP, AddPattern);
DerefIF(IF);
return status;
}
NTSTATUS
IPGetCapability(uint InterfaceContext, PULONG pBuf, uint cap)
{
Interface *IF;
CTELockHandle Handle;
NTSTATUS status;
status = STATUS_SUCCESS;
CTEGetLock(&RouteTableLock.Lock, &Handle);
for (IF = IFList; IF != NULL; IF = IF->if_next) {
if ((IF->if_refcount != 0) && (IF->if_index == InterfaceContext)) {
break;
}
}
if (IF != (Interface *) NULL) {
if (cap == IF_WOL_CAP) {
*pBuf = IF->if_pnpcap;
} else if (cap == IF_OFFLOAD_CAP) {
*pBuf = IF->if_OffloadFlags;
} else {
status = STATUS_INVALID_PARAMETER;
}
} else {
status = STATUS_INVALID_PARAMETER;
}
CTEFreeLock(&RouteTableLock.Lock, Handle);
return status;
}
//* IPGetInterfaceFriendlyName - get human-readable name for an interface.
//
// Called to retrieve the unique descriptive name for an interface. This name
// is provided by the interface's ARP module, and is used by IP to identify
// the interface in event logs.
//
// Input: InterfaceContext - IP interface context identifying the interface
// friendly name is required
// Name - on output, contains the friendly-name.
// Size - contains the length of the buffer at 'Name'.
//
// Returns: TDI_STATUS of query-attempt.
long
IPGetInterfaceFriendlyName(uint InterfaceContext, PWCHAR Name, uint Size)
{
PNDIS_BUFFER Buffer;
uint BufferSize;
CTELockHandle Handle;
uint i;
TDIObjectID ID;
Interface *IF;
TDI_STATUS Status;
// Attempt to retrieve the interface whose name is required,
// and if successful issue a query-info request to get its friendly name.
CTEGetLock(&RouteTableLock.Lock, &Handle);
for (IF = IFList; IF != NULL; IF = IF->if_next) {
if (IF->if_refcount != 0 && IF->if_index == InterfaceContext) {
break;
}
}
if (IF != (Interface *) NULL) {
// Construct a TDI query to obtain the interface's friendly name.
// Unfortunately, this operation is complicated by the fact that
// we don't have the exact entity-instance for the lower-layer entity.
// Therefore, we go through our whole cache of entity-instances,
// until we find one which is acceptable to the lower-layer entity.
ID.toi_class = INFO_CLASS_PROTOCOL;
ID.toi_type = INFO_TYPE_PROVIDER;
ID.toi_id = IF_FRIENDLY_NAME_ID;
ID.toi_entity.tei_entity = IF_ENTITY;
NdisAllocateBuffer(&Status, &Buffer, BufferPool, Name, Size);
if (Status == NDIS_STATUS_SUCCESS) {
LOCKED_REFERENCE_IF(IF);
for (i = 0; i < IPEntityCount; i++) {
if (IPEntityList[i].tei_entity != IF_ENTITY)
continue;
ID.toi_entity.tei_instance = IPEntityList[i].tei_instance;
CTEFreeLock(&RouteTableLock.Lock, Handle);
BufferSize = Size;
Status = (*IF->if_qinfo)(IF->if_lcontext, &ID, Buffer,
&BufferSize, NULL);
CTEGetLock(&RouteTableLock.Lock, &Handle);
if (Status != TDI_INVALID_REQUEST)
break;
// We just released the route-table lock in order to query
// the lower-layer entity, and that means that the entity-list
// may have changed. Handle that case by just making sure
// that the entity we just queried is in the same location;
// if not, we'll need to find it and continue from there.
// If it's gone, give up.
if (i < IPEntityCount &&
IPEntityList[i].tei_instance !=
ID.toi_entity.tei_instance) {
for (i = 0; i < IPEntityCount; i++) {
if (IPEntityList[i].tei_instance ==
ID.toi_entity.tei_instance) {
break;
}
}
}
}
LockedDerefIF(IF);
NdisFreeBuffer(Buffer);
} else
Status = TDI_NO_RESOURCES;
} else
Status = TDI_INVALID_PARAMETER;
CTEFreeLock(&RouteTableLock.Lock, Handle);
return Status;
}
#if MILLEN
//
// Support for VIP!!! For legacy support in VIP, we need to be able to convert
// the index into the if_pnpcontext. This will be exported from tcpip.sys
// to be accessed directly by VIP.
//
//* IPGetPNPCtxt
//
// Entry: index - ip interface index
// PNPCtxt - pointer to pnpcontext
//
NTSTATUS
IPGetPNPCtxt(uint index, uint *PNPCtxt)
{
Interface *IF;
for (IF = IFList; IF != NULL; IF = IF->if_next) {
if (IF->if_index == index) {
break;
}
}
if ( IF == (Interface *)NULL ) {
return STATUS_UNSUCCESSFUL;
}
*PNPCtxt = (uint)IF->if_pnpcontext;
return STATUS_SUCCESS;
}
//* IPGetPNPCap - add or remove IP wakeup pattern.
//
// Entry: InterfaceConext - ip interface context for which the wol capability needs to be returned
// flags - pointer to capability flags
//
NTSTATUS
IPGetPNPCap(uchar *Context, uint *flags)
{
Interface *IF;
for (IF = IFList; IF != NULL; IF = IF->if_next) {
if (IF->if_pnpcontext == Context) {
break;
}
}
if ( IF == (Interface *)NULL ) {
return STATUS_UNSUCCESSFUL;
}
*flags = IF->if_pnpcap;
return STATUS_SUCCESS;
}
#endif // MILLEN
Reference in a new issue Copy permalink