receive.c File Reference

#include "precomp.h"

Include dependency graph for receive.c:

Go to the source code of this file.

Functions
PIPDATAGRAM_HOLE	CreateHoleDescriptor (ULONG First, ULONG Last)
VOID	FreeIPDR (PIPDATAGRAM_REASSEMBLY IPDR)
VOID	RemoveIPDR (PIPDATAGRAM_REASSEMBLY IPDR)
PIPDATAGRAM_REASSEMBLY	GetReassemblyInfo (PIP_PACKET IPPacket)
BOOLEAN	ReassembleDatagram (PIP_PACKET IPPacket, PIPDATAGRAM_REASSEMBLY IPDR)
static VOID	Cleanup (PKSPIN_LOCK Lock, KIRQL OldIrql, PIPDATAGRAM_REASSEMBLY IPDR)
VOID	ProcessFragment (PIP_INTERFACE IF, PIP_PACKET IPPacket)
VOID	IPFreeReassemblyList (VOID)
VOID	IPDatagramReassemblyTimeout (VOID)
VOID	IPv4Receive (PIP_INTERFACE IF, PIP_PACKET IPPacket)
VOID	IPReceive (PIP_INTERFACE IF, PIP_PACKET IPPacket)

Variables
LIST_ENTRY	ReassemblyListHead
KSPIN_LOCK	ReassemblyListLock
NPAGED_LOOKASIDE_LIST	IPDRList
NPAGED_LOOKASIDE_LIST	IPFragmentList
NPAGED_LOOKASIDE_LIST	IPHoleList

Function Documentation

Cleanup()

static VOID Cleanup ( PKSPIN_LOCK  Lock, KIRQL  OldIrql, PIPDATAGRAM_REASSEMBLY  IPDR  )

inlinestatic

Definition at line 250 of file receive.c.

{
  TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 
  TcpipReleaseSpinLock(Lock, OldIrql);
  RemoveIPDR(IPDR);
  FreeIPDR(IPDR);
}

CreateHoleDescriptor()

PIPDATAGRAM_HOLE CreateHoleDescriptor	(	ULONG	First,
		ULONG	Last
	)

Definition at line 21 of file receive.c.

{
    PIPDATAGRAM_HOLE Hole;
 
    TI_DbgPrint(DEBUG_IP, ("Called. First (%d)  Last (%d).\n", First, Last));
 
    Hole = ExAllocateFromNPagedLookasideList(&IPHoleList);
    if (!Hole) {
        TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        return NULL;
    }
 
    Hole->First = First;
    Hole->Last  = Last;
 
    TI_DbgPrint(DEBUG_IP, ("Returning hole descriptor at (0x%X).\n", Hole));
 
    return Hole;
}

Referenced by ProcessFragment().

FreeIPDR()

VOID FreeIPDR

(

PIPDATAGRAM_REASSEMBLY

IPDR

)

Definition at line 53 of file receive.c.

{
  PLIST_ENTRY CurrentEntry;
  PLIST_ENTRY NextEntry;
  PIPDATAGRAM_HOLE CurrentH;
  PIP_FRAGMENT CurrentF;
 
  TI_DbgPrint(DEBUG_IP, ("Freeing IP datagram reassembly descriptor (0x%X).\n", IPDR));
 
  /* Free all descriptors */
  CurrentEntry = IPDR->HoleListHead.Flink;
  while (CurrentEntry != &IPDR->HoleListHead) {
    NextEntry = CurrentEntry->Flink;
      CurrentH = CONTAINING_RECORD(CurrentEntry, IPDATAGRAM_HOLE, ListEntry);
    /* Unlink it from the list */
    RemoveEntryList(CurrentEntry);
 
    TI_DbgPrint(DEBUG_IP, ("Freeing hole descriptor at (0x%X).\n", CurrentH));
 
    /* And free the hole descriptor */
    ExFreeToNPagedLookasideList(&IPHoleList, CurrentH);
 
    CurrentEntry = NextEntry;
  }
 
  /* Free all fragments */
  CurrentEntry = IPDR->FragmentListHead.Flink;
  while (CurrentEntry != &IPDR->FragmentListHead) {
    NextEntry = CurrentEntry->Flink;
      CurrentF = CONTAINING_RECORD(CurrentEntry, IP_FRAGMENT, ListEntry);
    /* Unlink it from the list */
    RemoveEntryList(CurrentEntry);
 
    TI_DbgPrint(DEBUG_IP, ("Freeing fragment packet at (0x%X).\n", CurrentF->Packet));
 
    /* Free the fragment data buffer */
    if (CurrentF->ReturnPacket)
    {
        NdisReturnPackets(&CurrentF->Packet, 1);
    }
    else
    {
        FreeNdisPacket(CurrentF->Packet);
    }
 
    TI_DbgPrint(DEBUG_IP, ("Freeing fragment at (0x%X).\n", CurrentF));
 
    /* And free the fragment descriptor */
    ExFreeToNPagedLookasideList(&IPFragmentList, CurrentF);
    CurrentEntry = NextEntry;
  }
 
  if (IPDR->IPv4Header)
  {
      TI_DbgPrint(DEBUG_IP, ("Freeing IPDR header at (0x%X).\n", IPDR->IPv4Header));
      ExFreePoolWithTag(IPDR->IPv4Header, PACKET_BUFFER_TAG);
  }
 
  TI_DbgPrint(DEBUG_IP, ("Freeing IPDR data at (0x%X).\n", IPDR));
 
  ExFreeToNPagedLookasideList(&IPDRList, IPDR);
}

Referenced by Cleanup(), IPDatagramReassemblyTimeout(), IPFreeReassemblyList(), and ProcessFragment().

GetReassemblyInfo()

PIPDATAGRAM_REASSEMBLY GetReassemblyInfo

(

PIP_PACKET

IPPacket

)

Definition at line 141 of file receive.c.

{
  KIRQL OldIrql;
  PLIST_ENTRY CurrentEntry;
  PIPDATAGRAM_REASSEMBLY Current;
  PIPv4_HEADER Header = (PIPv4_HEADER)IPPacket->Header;
 
  TI_DbgPrint(DEBUG_IP, ("Searching for IPDR for IP packet at (0x%X).\n", IPPacket));
 
  TcpipAcquireSpinLock(&ReassemblyListLock, &OldIrql);
 
  /* FIXME: Assume IPv4 */
 
  CurrentEntry = ReassemblyListHead.Flink;
  while (CurrentEntry != &ReassemblyListHead) {
      Current = CONTAINING_RECORD(CurrentEntry, IPDATAGRAM_REASSEMBLY, ListEntry);
    if (AddrIsEqual(&IPPacket->SrcAddr, &Current->SrcAddr) &&
      (Header->Id == Current->Id) &&
      (Header->Protocol == Current->Protocol) &&
      (AddrIsEqual(&IPPacket->DstAddr, &Current->DstAddr))) {
      TcpipReleaseSpinLock(&ReassemblyListLock, OldIrql);
 
      return Current;
    }
    CurrentEntry = CurrentEntry->Flink;
  }
 
  TcpipReleaseSpinLock(&ReassemblyListLock, OldIrql);
 
  return NULL;
}

Referenced by ProcessFragment().

IPDatagramReassemblyTimeout()

VOID IPDatagramReassemblyTimeout

(

VOID

)

Definition at line 515 of file receive.c.

{
    PLIST_ENTRY CurrentEntry, NextEntry;
    PIPDATAGRAM_REASSEMBLY CurrentIPDR;
 
    TcpipAcquireSpinLockAtDpcLevel(&ReassemblyListLock);
 
    CurrentEntry = ReassemblyListHead.Flink;
    while (CurrentEntry != &ReassemblyListHead)
    {
       NextEntry = CurrentEntry->Flink;
       CurrentIPDR = CONTAINING_RECORD(CurrentEntry, IPDATAGRAM_REASSEMBLY, ListEntry);
 
       TcpipAcquireSpinLockAtDpcLevel(&CurrentIPDR->Lock);
 
       if (++CurrentIPDR->TimeoutCount == MAX_TIMEOUT_COUNT)
       {
           TcpipReleaseSpinLockFromDpcLevel(&CurrentIPDR->Lock);
           RemoveEntryList(CurrentEntry);
           FreeIPDR(CurrentIPDR);
       }
       else
       {
           ASSERT(CurrentIPDR->TimeoutCount < MAX_TIMEOUT_COUNT);
           TcpipReleaseSpinLockFromDpcLevel(&CurrentIPDR->Lock);
       }
 
       CurrentEntry = NextEntry;
    }
 
    TcpipReleaseSpinLockFromDpcLevel(&ReassemblyListLock);
}

Referenced by IPTimeoutDpcFn().

IPFreeReassemblyList()

VOID IPFreeReassemblyList

(

VOID

)

Definition at line 485 of file receive.c.

{
  KIRQL OldIrql;
  PLIST_ENTRY CurrentEntry, NextEntry;
  PIPDATAGRAM_REASSEMBLY Current;
 
  TcpipAcquireSpinLock(&ReassemblyListLock, &OldIrql);
 
  CurrentEntry = ReassemblyListHead.Flink;
  while (CurrentEntry != &ReassemblyListHead) {
    NextEntry = CurrentEntry->Flink;
    Current = CONTAINING_RECORD(CurrentEntry, IPDATAGRAM_REASSEMBLY, ListEntry);
 
    /* Unlink it from the list */
    RemoveEntryList(CurrentEntry);
 
    /* And free the descriptor */
    FreeIPDR(Current);
 
    CurrentEntry = NextEntry;
  }
 
  TcpipReleaseSpinLock(&ReassemblyListLock, OldIrql);
}

Referenced by IPShutdown().

IPReceive()

VOID IPReceive	(	PIP_INTERFACE	IF,
		PIP_PACKET	IPPacket
	)

Definition at line 638 of file receive.c.

{
    UCHAR FirstByte;
    UINT Version, BytesCopied;
 
    /* Read in the first IP header byte for version information */
    BytesCopied = CopyPacketToBuffer((PCHAR)&FirstByte,
                                     IPPacket->NdisPacket,
                                     IPPacket->Position,
                                     sizeof(UCHAR));
    if (BytesCopied != sizeof(UCHAR))
    {
        TI_DbgPrint(MIN_TRACE, ("Failed to copy in first byte\n"));
        IPPacket->Free(IPPacket);
        return;
    }
 
    /* Check that IP header has a supported version */
    Version = (FirstByte >> 4);
 
    switch (Version) {
        case 4:
            IPPacket->Type = IP_ADDRESS_V4;
            IPv4Receive(IF, IPPacket);
            break;
        case 6:
            IPPacket->Type = IP_ADDRESS_V6;
            TI_DbgPrint(MAX_TRACE, ("Datagram of type IPv6 discarded.\n"));
            break;
        default:
            TI_DbgPrint(MIN_TRACE, ("Datagram has an unsupported IP version %d.\n", Version));
            break;
    }
 
    IPPacket->Free(IPPacket);
}

Referenced by LanReceiveWorker(), LoopPassiveWorker(), and main().

IPv4Receive()

VOID IPv4Receive	(	PIP_INTERFACE	IF,
		PIP_PACKET	IPPacket
	)

Definition at line 555 of file receive.c.

{
    UCHAR FirstByte;
    ULONG BytesCopied;
 
    TI_DbgPrint(DEBUG_IP, ("Received IPv4 datagram.\n"));
 
    /* Read in the first IP header byte for size information */
    BytesCopied = CopyPacketToBuffer((PCHAR)&FirstByte,
                                     IPPacket->NdisPacket,
                                     IPPacket->Position,
                                     sizeof(UCHAR));
    if (BytesCopied != sizeof(UCHAR))
    {
        TI_DbgPrint(MIN_TRACE, ("Failed to copy in first byte\n"));
        /* Discard packet */
        return;
    }
 
    IPPacket->HeaderSize = (FirstByte & 0x0F) << 2;
    TI_DbgPrint(DEBUG_IP, ("IPPacket->HeaderSize = %d\n", IPPacket->HeaderSize));
 
    if (IPPacket->HeaderSize > IPv4_MAX_HEADER_SIZE) {
        TI_DbgPrint(MIN_TRACE, ("Datagram received with incorrect header size (%d).\n",
          IPPacket->HeaderSize));
        /* Discard packet */
        return;
    }
 
    /* This is freed by IPPacket->Free() */
    IPPacket->Header = ExAllocatePoolWithTag(NonPagedPool,
                                             IPPacket->HeaderSize,
                                             PACKET_BUFFER_TAG);
    if (!IPPacket->Header)
    {
        TI_DbgPrint(MIN_TRACE, ("No resources to allocate header\n"));
        /* Discard packet */
        return;
    }
 
    IPPacket->MappedHeader = FALSE;
 
    BytesCopied = CopyPacketToBuffer((PCHAR)IPPacket->Header,
                                     IPPacket->NdisPacket,
                                     IPPacket->Position,
                                     IPPacket->HeaderSize);
    if (BytesCopied != IPPacket->HeaderSize)
    {
        TI_DbgPrint(MIN_TRACE, ("Failed to copy in header\n"));
        /* Discard packet */
        return;
    }
 
    /* Checksum IPv4 header */
    if (!IPv4CorrectChecksum(IPPacket->Header, IPPacket->HeaderSize)) {
        TI_DbgPrint(MIN_TRACE, ("Datagram received with bad checksum. Checksum field (0x%X)\n",
          WN2H(((PIPv4_HEADER)IPPacket->Header)->Checksum)));
        /* Discard packet */
        return;
    }
 
    IPPacket->TotalSize = WN2H(((PIPv4_HEADER)IPPacket->Header)->TotalLength);
 
    AddrInitIPv4(&IPPacket->SrcAddr, ((PIPv4_HEADER)IPPacket->Header)->SrcAddr);
    AddrInitIPv4(&IPPacket->DstAddr, ((PIPv4_HEADER)IPPacket->Header)->DstAddr);
 
    TI_DbgPrint(MID_TRACE,("IPPacket->Position = %d\n",
                           IPPacket->Position));
 
    /* FIXME: Possibly forward packets with multicast addresses */
 
    /* FIXME: Should we allow packets to be received on the wrong interface? */
    /* XXX Find out if this packet is destined for us */
    ProcessFragment(IF, IPPacket);
}

Referenced by IPReceive().

ProcessFragment()

VOID ProcessFragment	(	PIP_INTERFACE	IF,
		PIP_PACKET	IPPacket
	)

Definition at line 271 of file receive.c.

{
  KIRQL OldIrql;
  PIPDATAGRAM_REASSEMBLY IPDR;
  PLIST_ENTRY CurrentEntry;
  PIPDATAGRAM_HOLE Hole, NewHole;
  USHORT FragFirst;
  USHORT FragLast;
  BOOLEAN MoreFragments;
  PIPv4_HEADER IPv4Header;
  IP_PACKET Datagram;
  PIP_FRAGMENT Fragment;
  BOOLEAN Success;
 
  /* FIXME: Assume IPv4 */
 
  IPv4Header = (PIPv4_HEADER)IPPacket->Header;
 
  /* Check if we already have an reassembly structure for this datagram */
  IPDR = GetReassemblyInfo(IPPacket);
  if (IPDR) {
    TI_DbgPrint(DEBUG_IP, ("Continueing assembly.\n"));
    /* We have a reassembly structure */
    TcpipAcquireSpinLock(&IPDR->Lock, &OldIrql);
 
    /* Reset the timeout since we received a fragment */
    IPDR->TimeoutCount = 0;
  } else {
    TI_DbgPrint(DEBUG_IP, ("Starting new assembly.\n"));
 
    /* We don't have a reassembly structure, create one */
    IPDR = ExAllocateFromNPagedLookasideList(&IPDRList);
    if (!IPDR)
      /* We don't have the resources to process this packet, discard it */
      return;
 
    /* Create a descriptor spanning from zero to infinity.
       Actually, we use a value slightly greater than the
       maximum number of octets an IP datagram can contain */
    Hole = CreateHoleDescriptor(0, 65536);
    if (!Hole) {
      /* We don't have the resources to process this packet, discard it */
      ExFreeToNPagedLookasideList(&IPDRList, IPDR);
      return;
    }
    AddrInitIPv4(&IPDR->SrcAddr, IPv4Header->SrcAddr);
    AddrInitIPv4(&IPDR->DstAddr, IPv4Header->DstAddr);
    IPDR->Id         = IPv4Header->Id;
    IPDR->Protocol   = IPv4Header->Protocol;
    IPDR->TimeoutCount = 0;
    InitializeListHead(&IPDR->FragmentListHead);
    InitializeListHead(&IPDR->HoleListHead);
    InsertTailList(&IPDR->HoleListHead, &Hole->ListEntry);
 
    TcpipInitializeSpinLock(&IPDR->Lock);
 
    TcpipAcquireSpinLock(&IPDR->Lock, &OldIrql);
 
    /* Update the reassembly list */
    TcpipInterlockedInsertTailList(
    &ReassemblyListHead,
    &IPDR->ListEntry,
    &ReassemblyListLock);
  }
 
  FragFirst     = (WN2H(IPv4Header->FlagsFragOfs) & IPv4_FRAGOFS_MASK) << 3;
  FragLast      = FragFirst + WN2H(IPv4Header->TotalLength);
  MoreFragments = (WN2H(IPv4Header->FlagsFragOfs) & IPv4_MF_MASK) > 0;
 
  CurrentEntry = IPDR->HoleListHead.Flink;
  for (;;) {
    if (CurrentEntry == &IPDR->HoleListHead)
        break;
 
    Hole = CONTAINING_RECORD(CurrentEntry, IPDATAGRAM_HOLE, ListEntry);
 
    TI_DbgPrint(DEBUG_IP, ("Comparing Fragment (%d,%d) to Hole (%d,%d).\n",
      FragFirst, FragLast, Hole->First, Hole->Last));
 
    if ((FragFirst > Hole->Last) || (FragLast < Hole->First)) {
      TI_DbgPrint(MID_TRACE, ("No overlap.\n"));
      /* The fragment does not overlap with the hole, try next
         descriptor in the list */
 
      CurrentEntry = CurrentEntry->Flink;
      continue;
    }
 
    /* The fragment overlap with the hole, unlink the descriptor */
    RemoveEntryList(CurrentEntry);
 
    if (FragFirst > Hole->First) {
      NewHole = CreateHoleDescriptor(Hole->First, FragFirst - 1);
      if (!NewHole) {
        /* We don't have the resources to process this packet, discard it */
        ExFreeToNPagedLookasideList(&IPHoleList, Hole);
        Cleanup(&IPDR->Lock, OldIrql, IPDR);
        return;
      }
 
      /* Put the new descriptor in the list */
      InsertTailList(&IPDR->HoleListHead, &NewHole->ListEntry);
    }
 
    if ((FragLast < Hole->Last) && MoreFragments) {
      NewHole = CreateHoleDescriptor(FragLast + 1, Hole->Last);
      if (!NewHole) {
        /* We don't have the resources to process this packet, discard it */
        ExFreeToNPagedLookasideList(&IPHoleList, Hole);
        Cleanup(&IPDR->Lock, OldIrql, IPDR);
        return;
      }
 
      /* Put the new hole descriptor in the list */
      InsertTailList(&IPDR->HoleListHead, &NewHole->ListEntry);
    }
 
    ExFreeToNPagedLookasideList(&IPHoleList, Hole);
 
    /* If this is the first fragment, save the IP header */
    if (FragFirst == 0) {
        IPDR->IPv4Header = ExAllocatePoolWithTag(NonPagedPool,
                                                 IPPacket->HeaderSize,
                                                 PACKET_BUFFER_TAG);
        if (!IPDR->IPv4Header)
        {
            Cleanup(&IPDR->Lock, OldIrql, IPDR);
            return;
        }
 
        RtlCopyMemory(IPDR->IPv4Header, IPPacket->Header, IPPacket->HeaderSize);
        IPDR->HeaderSize = IPPacket->HeaderSize;
 
        TI_DbgPrint(DEBUG_IP, ("First fragment found. Header buffer is at (0x%X). "
                               "Header size is (%d).\n", &IPDR->IPv4Header, IPPacket->HeaderSize));
 
    }
 
    /* Create a buffer, copy the data into it and put it
       in the fragment list */
 
    Fragment = ExAllocateFromNPagedLookasideList(&IPFragmentList);
    if (!Fragment) {
      /* We don't have the resources to process this packet, discard it */
      Cleanup(&IPDR->Lock, OldIrql, IPDR);
      return;
    }
 
    TI_DbgPrint(DEBUG_IP, ("Fragment descriptor allocated at (0x%X).\n", Fragment));
 
    Fragment->Size = IPPacket->TotalSize - IPPacket->HeaderSize;
    Fragment->Packet = IPPacket->NdisPacket;
    Fragment->ReturnPacket = IPPacket->ReturnPacket;
    Fragment->PacketOffset = IPPacket->Position + IPPacket->HeaderSize;
    Fragment->Offset = FragFirst;
 
    /* Disassociate the NDIS packet so it isn't freed upon return from IPReceive() */
    IPPacket->NdisPacket = NULL;
 
    /* If this is the last fragment, compute and save the datagram data size */
    if (!MoreFragments)
      IPDR->DataSize = FragFirst + Fragment->Size;
 
    /* Put the fragment in the list */
    InsertTailList(&IPDR->FragmentListHead, &Fragment->ListEntry);
    break;
  }
 
  TI_DbgPrint(DEBUG_IP, ("Done searching for hole descriptor.\n"));
 
  if (IsListEmpty(&IPDR->HoleListHead)) {
    /* Hole list is empty which means a complete datagram can be assembled.
       Assemble the datagram and pass it to an upper layer protocol */
 
    TI_DbgPrint(DEBUG_IP, ("Complete datagram received.\n"));
 
    RemoveIPDR(IPDR);
    TcpipReleaseSpinLock(&IPDR->Lock, OldIrql);
 
    /* FIXME: Assumes IPv4 */
    IPInitializePacket(&Datagram, IP_ADDRESS_V4);
 
    Success = ReassembleDatagram(&Datagram, IPDR);
 
    FreeIPDR(IPDR);
 
    if (!Success)
      /* Not enough free resources, discard the packet */
      return;
 
    DISPLAY_IP_PACKET(&Datagram);
 
    /* Give the packet to the protocol dispatcher */
    IPDispatchProtocol(IF, &Datagram);
 
    /* We're done with this datagram */
    TI_DbgPrint(MAX_TRACE, ("Freeing datagram at (0x%X).\n", Datagram));
    Datagram.Free(&Datagram);
  } else
    TcpipReleaseSpinLock(&IPDR->Lock, OldIrql);
}

Referenced by IPv4Receive().

ReassembleDatagram()

BOOLEAN ReassembleDatagram	(	PIP_PACKET	IPPacket,
		PIPDATAGRAM_REASSEMBLY	IPDR
	)

Definition at line 185 of file receive.c.

{
  PLIST_ENTRY CurrentEntry;
  PIP_FRAGMENT Fragment;
  PCHAR Data;
 
  PAGED_CODE();
 
  TI_DbgPrint(DEBUG_IP, ("Reassembling datagram from IPDR at (0x%X).\n", IPDR));
  TI_DbgPrint(DEBUG_IP, ("IPDR->HeaderSize = %d\n", IPDR->HeaderSize));
  TI_DbgPrint(DEBUG_IP, ("IPDR->DataSize = %d\n", IPDR->DataSize));
 
  IPPacket->TotalSize  = IPDR->HeaderSize + IPDR->DataSize;
  IPPacket->HeaderSize = IPDR->HeaderSize;
 
  RtlCopyMemory(&IPPacket->SrcAddr, &IPDR->SrcAddr, sizeof(IP_ADDRESS));
  RtlCopyMemory(&IPPacket->DstAddr, &IPDR->DstAddr, sizeof(IP_ADDRESS));
 
  /* Allocate space for full IP datagram */
  IPPacket->Header = ExAllocatePoolWithTag(NonPagedPool, IPPacket->TotalSize, PACKET_BUFFER_TAG);
  if (!IPPacket->Header) {
    TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
    (*IPPacket->Free)(IPPacket);
    return FALSE;
  }
  IPPacket->MappedHeader = FALSE;
 
  /* Copy the header into the buffer */
  RtlCopyMemory(IPPacket->Header, IPDR->IPv4Header, IPDR->HeaderSize);
 
  Data = (PVOID)((ULONG_PTR)IPPacket->Header + IPDR->HeaderSize);
  IPPacket->Data = Data;
 
  /* Copy data from all fragments into buffer */
  CurrentEntry = IPDR->FragmentListHead.Flink;
  while (CurrentEntry != &IPDR->FragmentListHead) {
    Fragment = CONTAINING_RECORD(CurrentEntry, IP_FRAGMENT, ListEntry);
 
    /* Copy fragment data into datagram buffer */
    CopyPacketToBuffer(Data + Fragment->Offset,
                       Fragment->Packet,
                       Fragment->PacketOffset,
                       Fragment->Size);
 
    CurrentEntry = CurrentEntry->Flink;
  }
 
  return TRUE;
}

Referenced by ProcessFragment().

RemoveIPDR()

VOID RemoveIPDR

(

PIPDATAGRAM_REASSEMBLY

IPDR

)

Definition at line 123 of file receive.c.

{
  KIRQL OldIrql;
 
  TI_DbgPrint(DEBUG_IP, ("Removing IPDR at (0x%X).\n", IPDR));
 
  TcpipAcquireSpinLock(&ReassemblyListLock, &OldIrql);
  RemoveEntryList(&IPDR->ListEntry);
  TcpipReleaseSpinLock(&ReassemblyListLock, OldIrql);
}

Referenced by Cleanup(), and ProcessFragment().

Variable Documentation

IPDRList

NPAGED_LOOKASIDE_LIST IPDRList

Definition at line 17 of file receive.c.

Referenced by FreeIPDR(), IPShutdown(), IPStartup(), and ProcessFragment().

IPFragmentList

NPAGED_LOOKASIDE_LIST IPFragmentList

Definition at line 18 of file receive.c.

Referenced by FreeIPDR(), IPShutdown(), IPStartup(), and ProcessFragment().

IPHoleList

NPAGED_LOOKASIDE_LIST IPHoleList

Definition at line 19 of file receive.c.

Referenced by CreateHoleDescriptor(), FreeIPDR(), IPShutdown(), IPStartup(), and ProcessFragment().

ReassemblyListHead

LIST_ENTRY ReassemblyListHead

Definition at line 15 of file receive.c.

Referenced by GetReassemblyInfo(), IPDatagramReassemblyTimeout(), IPFreeReassemblyList(), IPStartup(), and ProcessFragment().

ReassemblyListLock

KSPIN_LOCK ReassemblyListLock

Definition at line 16 of file receive.c.

Referenced by GetReassemblyInfo(), IPDatagramReassemblyTimeout(), IPFreeReassemblyList(), IPStartup(), ProcessFragment(), and RemoveIPDR().