windows-xp/Source/XPSP1/NT/net/tcpip/driver/ipv4/iploop.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