702 lines
21 KiB
C
702 lines
21 KiB
C
|
/********************************************************************/
|
||
|
|
/** Microsoft LAN Manager **/
|
||
|
|
/** Copyright(c) Microsoft Corp., 1990-2000 **/
|
||
|
|
/********************************************************************/
|
||
|
|
/* :ts=4 */
|
||
|
|
|
||
|
|
//*** iploop.c - IP loopback routines.
|
||
|
|
//
|
||
|
|
// This file contains all the routines related to loopback
|
||
|
|
|
||
|
|
#include "precomp.h"
|
||
|
|
#include "iprtdef.h"
|
||
|
|
#include "iproute.h"
|
||
|
|
#include "tcpipbuf.h"
|
||
|
|
|
||
|
|
#define LOOP_LOOKAHEAD MAX_HDR_SIZE + 8
|
||
|
|
|
||
|
|
extern int NumNTE;
|
||
|
|
extern int NumActiveNTE;
|
||
|
|
|
||
|
|
extern Interface *IFList;
|
||
|
|
extern uint NumIF;
|
||
|
|
|
||
|
|
extern BOOLEAN CopyToNdisSafe(PNDIS_BUFFER DestBuf, PNDIS_BUFFER * ppNextBuf,
|
||
|
|
uchar * SrcBuf, uint Size, uint * StartOffset);
|
||
|
|
|
||
|
|
CACHE_LINE_KSPIN_LOCK LoopLock;
|
||
|
|
PNDIS_PACKET LoopXmitHead = (PNDIS_PACKET) NULL;
|
||
|
|
PNDIS_PACKET LoopXmitTail = (PNDIS_PACKET) NULL;
|
||
|
|
CTEEvent LoopXmitEvent;
|
||
|
|
RouteInterface LoopInterface; // Loopback interface.
|
||
|
|
uint LoopXmitRtnRunning = 0;
|
||
|
|
|
||
|
|
int LoopGetEList(void *Context, TDIEntityID *EntityList, uint *Count);
|
||
|
|
NetTableEntry *InitLoopback(IPConfigInfo * ConfigInfo);
|
||
|
|
|
||
|
|
#ifdef ALLOC_PRAGMA
|
||
|
|
#pragma alloc_text(PAGE, LoopGetEList)
|
||
|
|
#pragma alloc_text(INIT, InitLoopback)
|
||
|
|
#endif // ALLOC_PRAGMA
|
||
|
|
|
||
|
|
uint LoopIndex; // Index of loop I/F.
|
||
|
|
uint LoopInstance = INVALID_ENTITY_INSTANCE; // I/F instance of loopback I/F.
|
||
|
|
NetTableEntry *LoopNTE; // Pointer to loopback NTE.
|
||
|
|
IFEntry LoopIFE; // Loopback IF Entry.
|
||
|
|
uchar LoopName[] = "MS TCP Loopback interface";
|
||
|
|
uint LoopEntityType = IF_MIB;
|
||
|
|
|
||
|
|
//* LoopXmitRtn - Loopback xmit event routine.
|
||
|
|
//
|
||
|
|
// This is the delayed event routine called for a loopback transmit.
|
||
|
|
//
|
||
|
|
// Entry: Event - Pointer to event structure.
|
||
|
|
// Context - Pointer to loopback NTE
|
||
|
|
//
|
||
|
|
// Returns: Nothing.
|
||
|
|
//
|
||
|
|
void
|
||
|
|
LoopXmitRtn(CTEEvent *Event, void *Context)
|
||
|
|
{
|
||
|
|
PNDIS_PACKET Packet; // Pointer to packet being transmitted
|
||
|
|
CTELockHandle Handle;
|
||
|
|
PNDIS_BUFFER Buffer; // Current NDIS buffer being processed.
|
||
|
|
uint TotalLength; // Total length of send.
|
||
|
|
uint LookaheadLength; // Bytes in lookahead.
|
||
|
|
uint Copied; // Bytes copied so far.
|
||
|
|
uchar *CopyPtr; // Pointer to buffer being copied into.
|
||
|
|
uchar *SrcPtr; // Pointer to buffer being copied from.
|
||
|
|
uint SrcLength; // Length of src buffer.
|
||
|
|
uchar LookaheadBuffer[LOOP_LOOKAHEAD];
|
||
|
|
uchar Rcvd = FALSE;
|
||
|
|
#if !MILLEN
|
||
|
|
KIRQL OldIrql;
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Raise IRQL so we can acquire locks at DPC level in the receive code.
|
||
|
|
// On Windows ME, this is NOT done since receive indications are in the
|
||
|
|
// context of a global event rather than DPC (in fact due to TDI client
|
||
|
|
// restrictions, TCP/IP can't indicate up at DPC, so care must be taken).
|
||
|
|
//
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#if !MILLEN
|
||
|
|
KeEnterCriticalRegion();
|
||
|
|
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
CTEGetLockAtDPC(&LoopLock.Lock, &Handle);
|
||
|
|
|
||
|
|
if (LoopXmitRtnRunning) {
|
||
|
|
CTEFreeLockFromDPC(&LoopLock.Lock, Handle);
|
||
|
|
#if !MILLEN
|
||
|
|
KeLowerIrql(OldIrql);
|
||
|
|
KeLeaveCriticalRegion();
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
LoopXmitRtnRunning = 1;
|
||
|
|
|
||
|
|
for (;;) {
|
||
|
|
Packet = LoopXmitHead; // Get the next packet from the list.
|
||
|
|
|
||
|
|
if (Packet != (PNDIS_PACKET) NULL) {
|
||
|
|
LoopXmitHead = *(PNDIS_PACKET *) Packet->MacReserved;
|
||
|
|
LoopIFE.if_outqlen--;
|
||
|
|
CTEFreeLockFromDPC(&LoopLock.Lock, Handle);
|
||
|
|
} else { // Nothing left to do.
|
||
|
|
|
||
|
|
LoopXmitRtnRunning = 0;
|
||
|
|
CTEFreeLockFromDPC(&LoopLock.Lock, Handle);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// See if the interface is up. If it's not, we can't deliver it.
|
||
|
|
if (LoopIFE.if_adminstatus == IF_STATUS_UP) {
|
||
|
|
NdisQueryPacket(Packet, NULL, NULL, &Buffer, &TotalLength);
|
||
|
|
LoopIFE.if_outoctets += TotalLength;
|
||
|
|
LoopIFE.if_inoctets += TotalLength;
|
||
|
|
|
||
|
|
LookaheadLength = MIN(LOOP_LOOKAHEAD, TotalLength);
|
||
|
|
Copied = 0;
|
||
|
|
CopyPtr = LookaheadBuffer;
|
||
|
|
while (Copied < LookaheadLength) {
|
||
|
|
uint ThisCopy; // Bytes to copy this time.
|
||
|
|
|
||
|
|
ASSERT(Buffer);
|
||
|
|
TcpipQueryBuffer(Buffer, &SrcPtr, &SrcLength, NormalPagePriority);
|
||
|
|
|
||
|
|
if (SrcPtr == NULL) {
|
||
|
|
IPSendComplete(Context, Packet, NDIS_STATUS_RESOURCES);
|
||
|
|
CTEGetLockAtDPC(&LoopLock.Lock, &Handle);
|
||
|
|
LoopXmitRtnRunning = 0;
|
||
|
|
LoopIFE.if_indiscards++;
|
||
|
|
CTEFreeLockFromDPC(&LoopLock.Lock, Handle);
|
||
|
|
#if !MILLEN
|
||
|
|
KeLowerIrql(OldIrql);
|
||
|
|
KeLeaveCriticalRegion();
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ThisCopy = MIN(SrcLength, LookaheadLength - Copied);
|
||
|
|
RtlCopyMemory(CopyPtr, SrcPtr, ThisCopy);
|
||
|
|
Copied += ThisCopy;
|
||
|
|
CopyPtr += ThisCopy;
|
||
|
|
NdisGetNextBuffer(Buffer, &Buffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
Rcvd = TRUE;
|
||
|
|
LoopIFE.if_inucastpkts++;
|
||
|
|
|
||
|
|
// Call the RcvPacket Handler
|
||
|
|
|
||
|
|
IPRcvPacket(Context, LookaheadBuffer, LookaheadLength, TotalLength,
|
||
|
|
(NDIS_HANDLE) Packet, 0, FALSE, 0, NULL, (PINT) Packet,
|
||
|
|
NULL);
|
||
|
|
} else {
|
||
|
|
LoopIFE.if_indiscards++;
|
||
|
|
}
|
||
|
|
|
||
|
|
IPSendComplete(Context, Packet, NDIS_STATUS_SUCCESS);
|
||
|
|
|
||
|
|
#if !MILLEN
|
||
|
|
//
|
||
|
|
// Give other threads a chance to run.
|
||
|
|
// Block special k mode APC delivery
|
||
|
|
// so that thread will not be blocked
|
||
|
|
// in a completion routine
|
||
|
|
//
|
||
|
|
|
||
|
|
|
||
|
|
KeLowerIrql(OldIrql);
|
||
|
|
|
||
|
|
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
CTEGetLockAtDPC(&LoopLock.Lock, &Handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Rcvd) {
|
||
|
|
IPRcvComplete();
|
||
|
|
}
|
||
|
|
#if !MILLEN
|
||
|
|
KeLowerIrql(OldIrql);
|
||
|
|
KeLeaveCriticalRegion();
|
||
|
|
#endif // !MILLEN
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//** LoopXmit - Transmit a loopback packet.
|
||
|
|
//
|
||
|
|
// This is the routine called when we need to transmit a packet to ourselves.
|
||
|
|
// We put the packet on our loopback list, and schedule an event to deal
|
||
|
|
// with it.
|
||
|
|
//
|
||
|
|
// Entry: Context - Pointer to the loopback NTE.
|
||
|
|
// 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
|
||
|
|
__stdcall
|
||
|
|
LoopXmit(void *Context, PNDIS_PACKET *PacketArray, uint NoPackets,
|
||
|
|
IPAddr Dest, RouteCacheEntry * RCE, void *LinkCtxt)
|
||
|
|
{
|
||
|
|
PNDIS_PACKET *PacketPtr;
|
||
|
|
CTELockHandle Handle;
|
||
|
|
PNDIS_PACKET Packet = *PacketArray;
|
||
|
|
|
||
|
|
ASSERT(NoPackets == 1);
|
||
|
|
|
||
|
|
LoopIFE.if_outucastpkts++;
|
||
|
|
|
||
|
|
if (LoopIFE.if_adminstatus == IF_STATUS_UP) {
|
||
|
|
PacketPtr = (PNDIS_PACKET *) Packet->MacReserved;
|
||
|
|
*PacketPtr = (PNDIS_PACKET) NULL;
|
||
|
|
|
||
|
|
CTEGetLock(&LoopLock.Lock, &Handle);
|
||
|
|
if (LoopXmitHead == (PNDIS_PACKET) NULL) { // Xmit. Q is empty
|
||
|
|
|
||
|
|
LoopXmitHead = Packet;
|
||
|
|
} else { // Xmit. Q is not empty
|
||
|
|
|
||
|
|
PacketPtr = (PNDIS_PACKET *) LoopXmitTail->MacReserved;
|
||
|
|
*PacketPtr = Packet;
|
||
|
|
}
|
||
|
|
LoopXmitTail = Packet;
|
||
|
|
LoopIFE.if_outqlen++;
|
||
|
|
if (!LoopXmitRtnRunning) {
|
||
|
|
CTEScheduleDelayedEvent(&LoopXmitEvent, Context);
|
||
|
|
}
|
||
|
|
CTEFreeLock(&LoopLock.Lock, Handle);
|
||
|
|
return NDIS_STATUS_PENDING;
|
||
|
|
} else {
|
||
|
|
LoopIFE.if_outdiscards++;
|
||
|
|
return NDIS_STATUS_SUCCESS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopXfer - Loopback transfer data routine.
|
||
|
|
//
|
||
|
|
// Called when we need to transfer data for the loopback net. The input
|
||
|
|
// TDContext is the original packet.
|
||
|
|
//
|
||
|
|
// Entry: Context - Pointer to loopback NTE.
|
||
|
|
// 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
|
||
|
|
__stdcall
|
||
|
|
LoopXfer(void *Context, NDIS_HANDLE TDContext, uint Dummy, uint Offset,
|
||
|
|
uint BytesToCopy, PNDIS_PACKET DestPacket, uint *BytesCopied)
|
||
|
|
{
|
||
|
|
PNDIS_BUFFER SrcBuffer; // Current buffer we're copying from.
|
||
|
|
PNDIS_PACKET SrcPacket = (PNDIS_PACKET) TDContext;
|
||
|
|
uchar *SrcPtr; // Where we're copying from.
|
||
|
|
uint SrcLength; // Length of current src buffer.
|
||
|
|
PNDIS_BUFFER DestBuffer; // Buffer we're copying to.
|
||
|
|
uchar *DestPtr; // Where we're copying to.
|
||
|
|
uint DestLength; // Length of current dest. buffer.
|
||
|
|
uint Copied; // Length we've copied so far.
|
||
|
|
NDIS_STATUS Status;
|
||
|
|
|
||
|
|
// First, skip over Offset bytes in the packet.
|
||
|
|
NdisQueryPacket(SrcPacket, NULL, NULL, &SrcBuffer, NULL);
|
||
|
|
|
||
|
|
ASSERT(SrcBuffer);
|
||
|
|
TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength, NormalPagePriority);
|
||
|
|
|
||
|
|
if (SrcPtr == NULL) {
|
||
|
|
return NDIS_STATUS_RESOURCES;
|
||
|
|
}
|
||
|
|
while (Offset >= SrcLength) {
|
||
|
|
Offset -= SrcLength;
|
||
|
|
NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
|
||
|
|
ASSERT(SrcBuffer);
|
||
|
|
TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength, NormalPagePriority);
|
||
|
|
|
||
|
|
if (SrcPtr == NULL) {
|
||
|
|
return NDIS_STATUS_RESOURCES;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Update Src pointer and length.
|
||
|
|
SrcPtr += Offset;
|
||
|
|
SrcLength -= Offset;
|
||
|
|
|
||
|
|
// Set up the destination pointers and lengths.
|
||
|
|
NdisQueryPacket(DestPacket, NULL, NULL, &DestBuffer, NULL);
|
||
|
|
TcpipQueryBuffer(DestBuffer, &DestPtr, &DestLength, NormalPagePriority);
|
||
|
|
|
||
|
|
if (DestPtr == NULL) {
|
||
|
|
return NDIS_STATUS_RESOURCES;
|
||
|
|
}
|
||
|
|
Copied = 0;
|
||
|
|
Status = NDIS_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
while (BytesToCopy) {
|
||
|
|
uint ThisCopy; // What we're copying this time.
|
||
|
|
|
||
|
|
ThisCopy = MIN(SrcLength, DestLength);
|
||
|
|
RtlCopyMemory(DestPtr, SrcPtr, ThisCopy);
|
||
|
|
Copied += ThisCopy;
|
||
|
|
DestPtr += ThisCopy;
|
||
|
|
SrcPtr += ThisCopy;
|
||
|
|
BytesToCopy -= ThisCopy;
|
||
|
|
SrcLength -= ThisCopy;
|
||
|
|
DestLength -= ThisCopy;
|
||
|
|
if (!SrcLength) { // We've exhausted the source buffer.
|
||
|
|
|
||
|
|
NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
|
||
|
|
if (!SrcBuffer) {
|
||
|
|
ASSERT(0 == BytesToCopy);
|
||
|
|
break; // Copy is done.
|
||
|
|
}
|
||
|
|
|
||
|
|
TcpipQueryBuffer(SrcBuffer, &SrcPtr, &SrcLength,
|
||
|
|
NormalPagePriority);
|
||
|
|
if (SrcPtr == NULL && BytesToCopy) {
|
||
|
|
Status = NDIS_STATUS_RESOURCES;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!DestLength) { // We've exhausted the destination buffer.
|
||
|
|
|
||
|
|
NdisGetNextBuffer(DestBuffer, &DestBuffer);
|
||
|
|
if (!DestBuffer) {
|
||
|
|
ASSERT(0 == BytesToCopy);
|
||
|
|
break; // Copy is done.
|
||
|
|
}
|
||
|
|
|
||
|
|
TcpipQueryBuffer(DestBuffer, &DestPtr, &DestLength,
|
||
|
|
NormalPagePriority);
|
||
|
|
|
||
|
|
if (DestPtr == NULL && BytesToCopy) {
|
||
|
|
Status = NDIS_STATUS_RESOURCES;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Status == NDIS_STATUS_SUCCESS) {
|
||
|
|
*BytesCopied = Copied;
|
||
|
|
}
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopClose - Loopback close routine.
|
||
|
|
//
|
||
|
|
// This is the loopback close routine. It does nothing but return.
|
||
|
|
//
|
||
|
|
// Entry: Context - Unused.
|
||
|
|
//
|
||
|
|
// Returns: Nothing.
|
||
|
|
//
|
||
|
|
void
|
||
|
|
__stdcall
|
||
|
|
LoopClose(void *Context)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopInvalidate - Invalidate an RCE.
|
||
|
|
//
|
||
|
|
// The loopback invalidate RCE routine. It also does nothing.
|
||
|
|
//
|
||
|
|
// Entry: Context - Unused.
|
||
|
|
// RCE - Pointer to RCE to be invalidated.
|
||
|
|
//
|
||
|
|
// Returns: Nothing.
|
||
|
|
//
|
||
|
|
void
|
||
|
|
__stdcall
|
||
|
|
LoopInvalidate(void *Context, RouteCacheEntry * RCE)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopQInfo - Loopback query information handler.
|
||
|
|
//
|
||
|
|
// Called when the upper layer wants to query information about the loopback
|
||
|
|
// interface.
|
||
|
|
//
|
||
|
|
// 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
|
||
|
|
__stdcall
|
||
|
|
LoopQInfo(void *IFContext, TDIObjectID * ID, PNDIS_BUFFER Buffer, uint * Size,
|
||
|
|
void *Context)
|
||
|
|
{
|
||
|
|
uint Offset = 0;
|
||
|
|
uint BufferSize = *Size;
|
||
|
|
uint Entity;
|
||
|
|
uint Instance;
|
||
|
|
BOOLEAN fStatus;
|
||
|
|
|
||
|
|
Entity = ID->toi_entity.tei_entity;
|
||
|
|
Instance = ID->toi_entity.tei_instance;
|
||
|
|
|
||
|
|
// First, make sure it's possibly an ID we can handle.
|
||
|
|
if (Entity != IF_ENTITY || Instance != LoopInstance) {
|
||
|
|
return TDI_INVALID_REQUEST;
|
||
|
|
}
|
||
|
|
*Size = 0; // In case of an error.
|
||
|
|
|
||
|
|
if (ID->toi_type != INFO_TYPE_PROVIDER)
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
if (ID->toi_class == INFO_CLASS_GENERIC) {
|
||
|
|
if (ID->toi_id == ENTITY_TYPE_ID) {
|
||
|
|
// He's trying to see what type we are.
|
||
|
|
if (BufferSize >= sizeof(uint)) {
|
||
|
|
fStatus = CopyToNdisSafe(Buffer, NULL,
|
||
|
|
(uchar *) &LoopEntityType,
|
||
|
|
sizeof(uint), &Offset);
|
||
|
|
|
||
|
|
if (fStatus == FALSE) {
|
||
|
|
return (TDI_NO_RESOURCES);
|
||
|
|
}
|
||
|
|
return TDI_SUCCESS;
|
||
|
|
} else
|
||
|
|
return TDI_BUFFER_TOO_SMALL;
|
||
|
|
}
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
} else if (ID->toi_class != INFO_CLASS_PROTOCOL)
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
// If he's asking for MIB statistics, then return them, otherwise fail
|
||
|
|
// the request.
|
||
|
|
|
||
|
|
if (ID->toi_id == IF_MIB_STATS_ID) {
|
||
|
|
|
||
|
|
// He's asking for statistics. Make sure his buffer is at least big
|
||
|
|
// enough to hold the fixed part.
|
||
|
|
|
||
|
|
if (BufferSize < IFE_FIXED_SIZE) {
|
||
|
|
return TDI_BUFFER_TOO_SMALL;
|
||
|
|
}
|
||
|
|
// He's got enough to hold the fixed part. Copy our IFE structure
|
||
|
|
// into his buffer.
|
||
|
|
fStatus = CopyToNdisSafe(Buffer, &Buffer, (uchar *) & LoopIFE,
|
||
|
|
IFE_FIXED_SIZE, &Offset);
|
||
|
|
|
||
|
|
if (fStatus == TRUE) {
|
||
|
|
// See if he has room for the descriptor string.
|
||
|
|
if (BufferSize >= (IFE_FIXED_SIZE + sizeof(LoopName))) {
|
||
|
|
// He has room. Copy it.
|
||
|
|
fStatus = CopyToNdisSafe(Buffer, NULL, LoopName,
|
||
|
|
sizeof(LoopName), &Offset);
|
||
|
|
|
||
|
|
if (fStatus == TRUE) {
|
||
|
|
*Size = IFE_FIXED_SIZE + sizeof(LoopName);
|
||
|
|
return TDI_SUCCESS;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Not enough room to copy the desc. string.
|
||
|
|
*Size = IFE_FIXED_SIZE;
|
||
|
|
return TDI_BUFFER_OVERFLOW;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return TDI_NO_RESOURCES;
|
||
|
|
|
||
|
|
}
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopSetInfo - Loopback set information handler.
|
||
|
|
//
|
||
|
|
// The loopback set information handler. We support setting of an I/F admin
|
||
|
|
// status.
|
||
|
|
//
|
||
|
|
// Input: Context - Pointer to I/F to set on.
|
||
|
|
// ID - The object ID
|
||
|
|
// Buffer - Pointer to buffer containing value to set.
|
||
|
|
// Size - Size in bytes of Buffer.
|
||
|
|
//
|
||
|
|
// Returns: Status of attempt to set information.
|
||
|
|
//
|
||
|
|
int
|
||
|
|
__stdcall
|
||
|
|
LoopSetInfo(void *Context, TDIObjectID *ID, void *Buffer, uint Size)
|
||
|
|
{
|
||
|
|
IFEntry *IFE = (IFEntry *) Buffer;
|
||
|
|
uint Entity, Instance, Status;
|
||
|
|
|
||
|
|
Entity = ID->toi_entity.tei_entity;
|
||
|
|
Instance = ID->toi_entity.tei_instance;
|
||
|
|
|
||
|
|
// First, make sure it's possibly an ID we can handle.
|
||
|
|
if (Entity != IF_ENTITY || Instance != LoopInstance) {
|
||
|
|
return TDI_INVALID_REQUEST;
|
||
|
|
}
|
||
|
|
if (ID->toi_class != INFO_CLASS_PROTOCOL ||
|
||
|
|
ID->toi_type != INFO_TYPE_PROVIDER) {
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
}
|
||
|
|
// It's for the I/F level, see if it's for the statistics.
|
||
|
|
if (ID->toi_id == IF_MIB_STATS_ID) {
|
||
|
|
// It's for the stats. Make sure it's a valid size.
|
||
|
|
if (Size >= IFE_FIXED_SIZE) {
|
||
|
|
// It's a valid size. See what he wants to do.
|
||
|
|
Status = IFE->if_adminstatus;
|
||
|
|
if (Status == IF_STATUS_UP || Status == IF_STATUS_DOWN)
|
||
|
|
LoopIFE.if_adminstatus = Status;
|
||
|
|
else if (Status != IF_STATUS_TESTING)
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
return TDI_SUCCESS;
|
||
|
|
|
||
|
|
} else
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
}
|
||
|
|
return TDI_INVALID_PARAMETER;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopAddAddr - Dummy loopback add address routine.
|
||
|
|
//
|
||
|
|
// Called at init time when we need to initialize ourselves.
|
||
|
|
//
|
||
|
|
uint
|
||
|
|
__stdcall
|
||
|
|
LoopAddAddr(void *Context, uint Type, IPAddr Address, IPMask Mask, void *Context2)
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//* LoopDelAddr - Dummy loopback del address routine.
|
||
|
|
//
|
||
|
|
// Called at init time when we need to initialize ourselves.
|
||
|
|
//
|
||
|
|
uint
|
||
|
|
__stdcall
|
||
|
|
LoopDelAddr(void *Context, uint Type, IPAddr Address, IPMask Mask)
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
#pragma BEGIN_INIT
|
||
|
|
|
||
|
|
extern int InitNTE(NetTableEntry *);
|
||
|
|
extern int InitInterface(NetTableEntry *);
|
||
|
|
|
||
|
|
//* LoopGetEList - Get the entity list.
|
||
|
|
//
|
||
|
|
// Called at init time to get an entity list. We fill our stuff in and return.
|
||
|
|
//
|
||
|
|
// 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
|
||
|
|
__stdcall
|
||
|
|
LoopGetEList(void *Context, TDIEntityID *EntityList, uint *Count)
|
||
|
|
{
|
||
|
|
uint MyIFBase;
|
||
|
|
uint i;
|
||
|
|
TDIEntityID *IFEntity;
|
||
|
|
|
||
|
|
// Walk down the list, looking for existing IF entities, and
|
||
|
|
// adjust our base instance accordingly.
|
||
|
|
|
||
|
|
MyIFBase = 0;
|
||
|
|
IFEntity = NULL;
|
||
|
|
for (i = 0; i < *Count; i++, EntityList++) {
|
||
|
|
if (EntityList->tei_entity == IF_ENTITY)
|
||
|
|
// if we are already on the list remember our entity item
|
||
|
|
// o/w find an instance # for us.
|
||
|
|
if (EntityList->tei_instance == LoopInstance &&
|
||
|
|
EntityList->tei_instance != INVALID_ENTITY_INSTANCE) {
|
||
|
|
IFEntity = EntityList;
|
||
|
|
break;
|
||
|
|
} else {
|
||
|
|
MyIFBase = MAX(MyIFBase, EntityList->tei_instance + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (IFEntity == NULL) {
|
||
|
|
// we are not on the list.
|
||
|
|
// make sure we have the room for it.
|
||
|
|
if (*Count >= MAX_TDI_ENTITIES) {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
LoopInstance = MyIFBase;
|
||
|
|
|
||
|
|
// Now fill it in.
|
||
|
|
EntityList->tei_entity = IF_ENTITY;
|
||
|
|
EntityList->tei_instance = MyIFBase;
|
||
|
|
(*Count)++;
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//** InitLoopback - Initialize the loopback NTE.
|
||
|
|
//
|
||
|
|
// This function initialized the loopback NTE. We set up the the MSS and
|
||
|
|
// pointer to the various pseudo-link routines, then call InitNTE and return.
|
||
|
|
//
|
||
|
|
// Entry: ConfigInfo - Pointer to config. info structure.
|
||
|
|
//
|
||
|
|
// Returns: TRUE if we initialized, FALSE if we didn't.
|
||
|
|
//
|
||
|
|
NetTableEntry *
|
||
|
|
InitLoopback(IPConfigInfo * ConfigInfo)
|
||
|
|
{
|
||
|
|
LLIPBindInfo ARPInfo;
|
||
|
|
|
||
|
|
LoopNTE = CTEAllocMem(sizeof(NetTableEntry));
|
||
|
|
if (LoopNTE == NULL)
|
||
|
|
return LoopNTE;
|
||
|
|
|
||
|
|
RtlZeroMemory(LoopNTE, sizeof(NetTableEntry));
|
||
|
|
RtlZeroMemory(&LoopInterface, sizeof(RouteInterface));
|
||
|
|
|
||
|
|
LoopNTE->nte_addr = LOOPBACK_ADDR;
|
||
|
|
LoopNTE->nte_mask = CLASSA_MASK;
|
||
|
|
LoopNTE->nte_icmpseq = 1;
|
||
|
|
LoopNTE->nte_flags = NTE_VALID | NTE_ACTIVE | NTE_PRIMARY;
|
||
|
|
|
||
|
|
CTEInitLock(&LoopNTE->nte_lock);
|
||
|
|
CTEInitLock(&LoopInterface.ri_if.if_lock);
|
||
|
|
LoopNTE->nte_mss = LOOPBACK_MSS;
|
||
|
|
LoopNTE->nte_if = (Interface *) & LoopInterface;
|
||
|
|
LoopInterface.ri_if.if_lcontext = LoopNTE;
|
||
|
|
LoopInterface.ri_if.if_xmit = LoopXmit;
|
||
|
|
LoopInterface.ri_if.if_transfer = LoopXfer;
|
||
|
|
LoopInterface.ri_if.if_close = LoopClose;
|
||
|
|
LoopInterface.ri_if.if_invalidate = LoopInvalidate;
|
||
|
|
LoopInterface.ri_if.if_qinfo = LoopQInfo;
|
||
|
|
LoopInterface.ri_if.if_setinfo = LoopSetInfo;
|
||
|
|
LoopInterface.ri_if.if_getelist = LoopGetEList;
|
||
|
|
LoopInterface.ri_if.if_addaddr = LoopAddAddr;
|
||
|
|
LoopInterface.ri_if.if_deladdr = LoopDelAddr;
|
||
|
|
LoopInterface.ri_if.if_bcast = IP_LOCAL_BCST;
|
||
|
|
LoopInterface.ri_if.if_speed = 10000000;
|
||
|
|
LoopInterface.ri_if.if_mtu = LOOPBACK_MSS;
|
||
|
|
LoopInterface.ri_if.if_llipflags = LIP_COPY_FLAG;
|
||
|
|
LOCKED_REFERENCE_IF(&LoopInterface.ri_if);
|
||
|
|
|
||
|
|
LoopInterface.ri_if.if_order = MAXLONG;
|
||
|
|
|
||
|
|
ARPInfo.lip_mss = LOOPBACK_MSS + sizeof(IPHeader);
|
||
|
|
ARPInfo.lip_index = LoopIndex;
|
||
|
|
ARPInfo.lip_close = LoopClose;
|
||
|
|
ARPInfo.lip_addaddr = LoopAddAddr;
|
||
|
|
ARPInfo.lip_deladdr = LoopDelAddr;
|
||
|
|
ARPInfo.lip_flags = LIP_COPY_FLAG;
|
||
|
|
LoopIndex = NumIF + 1;
|
||
|
|
LoopInterface.ri_if.if_index = LoopIndex;
|
||
|
|
CTEInitEvent(&LoopXmitEvent, LoopXmitRtn);
|
||
|
|
CTEInitLock(&LoopLock.Lock);
|
||
|
|
LoopIFE.if_index = LoopIndex;
|
||
|
|
LoopIFE.if_type = IF_TYPE_SOFTWARE_LOOPBACK;
|
||
|
|
|
||
|
|
LoopIFE.if_mtu = ARPInfo.lip_mss;
|
||
|
|
LoopIFE.if_speed = 10000000;
|
||
|
|
LoopIFE.if_adminstatus = IF_STATUS_UP;
|
||
|
|
LoopIFE.if_operstatus = IF_OPER_STATUS_OPERATIONAL;
|
||
|
|
LoopIFE.if_lastchange = GetTimeTicks();
|
||
|
|
LoopIFE.if_descrlen = sizeof(LoopName);
|
||
|
|
|
||
|
|
IFList = (Interface *) & LoopInterface;
|
||
|
|
NumIF++;
|
||
|
|
|
||
|
|
NumNTE++;
|
||
|
|
|
||
|
|
if (!InitInterface(LoopNTE))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
if (!InitNTE(LoopNTE))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
NumActiveNTE++;
|
||
|
|
return LoopNTE;
|
||
|
|
}
|
||
|
|
|
||
|
|
#pragma END_INIT
|