/** @file
The internal functions and routines to transmit the IP6 packet.
Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "Ip6Impl.h"
UINT32 mIp6Id;
/**
Output all the available source addresses to a list entry head SourceList. The
number of source addresses are also returned.
@param[in] IpSb Points to an IP6 service binding instance.
@param[out] SourceList The list entry head of all source addresses.
It is the caller's responsibility to free the
resources.
@param[out] SourceCount The number of source addresses.
@retval EFI_SUCCESS The source addresses were copied to a list entry head
SourceList.
@retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
**/
EFI_STATUS
Ip6CandidateSource (
IN IP6_SERVICE *IpSb,
OUT LIST_ENTRY *SourceList,
OUT UINT32 *SourceCount
)
{
IP6_INTERFACE *IpIf;
LIST_ENTRY *Entry;
LIST_ENTRY *Entry2;
IP6_ADDRESS_INFO *AddrInfo;
IP6_ADDRESS_INFO *Copy;
*SourceCount = 0;
if (IpSb->LinkLocalOk) {
Copy = AllocatePool (sizeof (IP6_ADDRESS_INFO));
if (Copy == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Copy->Signature = IP6_ADDR_INFO_SIGNATURE;
IP6_COPY_ADDRESS (&Copy->Address, &IpSb->LinkLocalAddr);
Copy->IsAnycast = FALSE;
Copy->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH;
Copy->ValidLifetime = (UINT32) IP6_INFINIT_LIFETIME;
Copy->PreferredLifetime = (UINT32) IP6_INFINIT_LIFETIME;
InsertTailList (SourceList, &Copy->Link);
(*SourceCount)++;
}
NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {
AddrInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
if (AddrInfo->IsAnycast) {
//
// Never use an anycast address.
//
continue;
}
Copy = AllocateCopyPool (sizeof (IP6_ADDRESS_INFO), AddrInfo);
if (Copy == NULL) {
return EFI_OUT_OF_RESOURCES;
}
InsertTailList (SourceList, &Copy->Link);
(*SourceCount)++;
}
}
return EFI_SUCCESS;
}
/**
Calculate how many bits are the same between two IPv6 addresses.
@param[in] AddressA Points to an IPv6 address.
@param[in] AddressB Points to another IPv6 address.
@return The common bits of the AddressA and AddressB.
**/
UINT8
Ip6CommonPrefixLen (
IN EFI_IPv6_ADDRESS *AddressA,
IN EFI_IPv6_ADDRESS *AddressB
)
{
UINT8 Count;
UINT8 Index;
UINT8 ByteA;
UINT8 ByteB;
UINT8 NumBits;
Count = 0;
Index = 0;
while (Index < 16) {
ByteA = AddressA->Addr[Index];
ByteB = AddressB->Addr[Index];
if (ByteA == ByteB) {
Count += 8;
Index++;
continue;
}
//
// Check how many bits are common between the two bytes.
//
NumBits = 8;
ByteA = (UINT8) (ByteA ^ ByteB);
while (ByteA != 0) {
NumBits--;
ByteA = (UINT8) (ByteA >> 1);
}
return (UINT8) (Count + NumBits);
}
return Count;
}
/**
Output all the available source addresses to a list entry head SourceList. The
number of source addresses are also returned.
@param[in] IpSb Points to a IP6 service binding instance.
@param[in] Destination The IPv6 destination address.
@param[out] Source The selected IPv6 source address according to
the Destination.
@retval EFI_SUCCESS The source addresses were copied to a list entry
head SourceList.
@retval EFI_NO_MAPPING The IPv6 stack is not auto configured.
**/
EFI_STATUS
Ip6SelectSourceAddress (
IN IP6_SERVICE *IpSb,
IN EFI_IPv6_ADDRESS *Destination,
OUT EFI_IPv6_ADDRESS *Source
)
{
EFI_STATUS Status;
LIST_ENTRY SourceList;
UINT32 SourceCount;
UINT8 ScopeD;
LIST_ENTRY *Entry;
IP6_ADDRESS_INFO *AddrInfo;
IP6_PREFIX_LIST_ENTRY *Prefix;
UINT8 LastCommonLength;
UINT8 CurrentCommonLength;
EFI_IPv6_ADDRESS *TmpAddress;
NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
Status = EFI_SUCCESS;
InitializeListHead (&SourceList);
if (!IpSb->LinkLocalOk) {
return EFI_NO_MAPPING;
}
//
// Rule 1: Prefer same address.
//
if (Ip6IsOneOfSetAddress (IpSb, Destination, NULL, NULL)) {
IP6_COPY_ADDRESS (Source, Destination);
goto Exit;
}
//
// Rule 2: Prefer appropriate scope.
//
if (IP6_IS_MULTICAST (Destination)) {
ScopeD = (UINT8) (Destination->Addr[1] >> 4);
} else if (NetIp6IsLinkLocalAddr (Destination)) {
ScopeD = 0x2;
} else {
ScopeD = 0xE;
}
if (ScopeD <= 0x2) {
//
// Return the link-local address if it exists
// One IP6_SERVICE only has one link-local address.
//
IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);
goto Exit;
}
//
// All candidate source addresses are global unicast address.
//
Ip6CandidateSource (IpSb, &SourceList, &SourceCount);
if (SourceCount == 0) {
Status = EFI_NO_MAPPING;
goto Exit;
}
IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);
if (SourceCount == 1) {
goto Exit;
}
//
// Rule 3: Avoid deprecated addresses.
// TODO: check the "deprecated" state of the stateful configured address
//
NET_LIST_FOR_EACH (Entry, &IpSb->AutonomousPrefix) {
Prefix = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
if (Prefix->PreferredLifetime == 0) {
Ip6RemoveAddr (NULL, &SourceList, &SourceCount, &Prefix->Prefix, Prefix->PrefixLength);
if (SourceCount == 1) {
goto Exit;
}
}
}
//
// TODO: Rule 4: Prefer home addresses.
// TODO: Rule 5: Prefer outgoing interface.
// TODO: Rule 6: Prefer matching label.
// TODO: Rule 7: Prefer public addresses.
//
//
// Rule 8: Use longest matching prefix.
//
LastCommonLength = Ip6CommonPrefixLen (Source, Destination);
TmpAddress = NULL;
for (Entry = SourceList.ForwardLink; Entry != &SourceList; Entry = Entry->ForwardLink) {
AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
CurrentCommonLength = Ip6CommonPrefixLen (&AddrInfo->Address, Destination);
if (CurrentCommonLength > LastCommonLength) {
LastCommonLength = CurrentCommonLength;
TmpAddress = &AddrInfo->Address;
}
}
if (TmpAddress != NULL) {
IP6_COPY_ADDRESS (Source, TmpAddress);
}
Exit:
Ip6RemoveAddr (NULL, &SourceList, &SourceCount, NULL, 0);
return Status;
}
/**
Select an interface to send the packet generated in the IP6 driver
itself: that is, not by the requests of the IP6 child's consumer. Such
packets include the ICMPv6 echo replies and other ICMPv6 error packets.
@param[in] IpSb The IP4 service that wants to send the packets.
@param[in] Destination The destination of the packet.
@param[in, out] Source The source of the packet.
@return NULL if no proper interface is found, otherwise, the interface that
can be used to send the system packet from.
**/
IP6_INTERFACE *
Ip6SelectInterface (
IN IP6_SERVICE *IpSb,
IN EFI_IPv6_ADDRESS *Destination,
IN OUT EFI_IPv6_ADDRESS *Source
)
{
EFI_STATUS Status;
EFI_IPv6_ADDRESS SelectedSource;
IP6_INTERFACE *IpIf;
BOOLEAN Exist;
NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
ASSERT (Destination != NULL && Source != NULL);
if (NetIp6IsUnspecifiedAddr (Destination)) {
return NULL;
}
if (!NetIp6IsUnspecifiedAddr (Source)) {
Exist = Ip6IsOneOfSetAddress (IpSb, Source, &IpIf, NULL);
ASSERT (Exist);
return IpIf;
}
//
// If source is unspecified, select a source according to the destination.
//
Status = Ip6SelectSourceAddress (IpSb, Destination, &SelectedSource);
if (EFI_ERROR (Status)) {
return IpSb->DefaultInterface;
}
Ip6IsOneOfSetAddress (IpSb, &SelectedSource, &IpIf, NULL);
IP6_COPY_ADDRESS (Source, &SelectedSource);
return IpIf;
}
/**
The default callback function for the system generated packet.
It will free the packet.
@param[in] Packet The packet that transmitted.
@param[in] IoStatus The result of the transmission, succeeded or failed.
@param[in] LinkFlag Not used when transmitted. Check IP6_FRAME_CALLBACK
for reference.
@param[in] Context The context provided by us.
**/
VOID
Ip6SysPacketSent (
NET_BUF *Packet,
EFI_STATUS IoStatus,
UINT32 LinkFlag,
VOID *Context
)
{
NetbufFree (Packet);
Packet = NULL;
}
/**
Prefix an IP6 basic head and unfragmentable extension headers and a fragment header
to the Packet. Used for IP6 fragmentation.
@param[in] IpSb The IP6 service instance to transmit the packet.
@param[in] Packet The packet to prefix the IP6 header to.
@param[in] Head The caller supplied header.
@param[in] FragmentOffset The fragment offset of the data following the header.
@param[in] ExtHdrs The length of the original extension header.
@param[in] ExtHdrsLen The length of the extension headers.
@param[in] LastHeader The pointer of next header of last extension header.
@param[in] HeadLen The length of the unfragmented part of the IP6 header.
@retval EFI_BAD_BUFFER_SIZE There is no enough room in the head space of
Packet.
@retval EFI_SUCCESS The operation performed successfully.
**/
EFI_STATUS
Ip6PrependHead (
IN IP6_SERVICE *IpSb,
IN NET_BUF *Packet,
IN EFI_IP6_HEADER *Head,
IN UINT16 FragmentOffset,
IN UINT8 *ExtHdrs,
IN UINT32 ExtHdrsLen,
IN UINT8 LastHeader,
IN UINT32 HeadLen
)
{
UINT32 Len;
UINT32 UnFragExtHdrsLen;
EFI_IP6_HEADER *PacketHead;
UINT8 *UpdatedExtHdrs;
EFI_STATUS Status;
UINT8 NextHeader;
UpdatedExtHdrs = NULL;
//
// HeadLen is the length of the fixed part of the sequences of fragments, i.e.
// the unfragment part.
//
PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);
if (PacketHead == NULL) {
return EFI_BAD_BUFFER_SIZE;
}
//
// Set the head up, convert the host byte order to network byte order
//
CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));
PacketHead->PayloadLength = HTONS ((UINT16) (Packet->TotalSize - sizeof (EFI_IP6_HEADER)));
Packet->Ip.Ip6 = PacketHead;
Len = HeadLen - sizeof (EFI_IP6_HEADER);
UnFragExtHdrsLen = Len - sizeof (IP6_FRAGMENT_HEADER);
if (UnFragExtHdrsLen == 0) {
PacketHead->NextHeader = IP6_FRAGMENT;
}
//
// Append the extension headers: firstly copy the unfragmentable headers, then append
// fragmentation header.
//
if ((FragmentOffset & IP6_FRAGMENT_OFFSET_MASK) == 0) {
NextHeader = Head->NextHeader;
} else {
NextHeader = PacketHead->NextHeader;
}
Status = Ip6FillFragmentHeader (
IpSb,
NextHeader,
LastHeader,
ExtHdrs,
ExtHdrsLen,
FragmentOffset,
&UpdatedExtHdrs
);
if (EFI_ERROR (Status)) {
return Status;
}
CopyMem (
(UINT8 *) (PacketHead + 1),
UpdatedExtHdrs,
UnFragExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER)
);
FreePool (UpdatedExtHdrs);
return EFI_SUCCESS;
}
/**
Transmit an IP6 packet. The packet comes either from the IP6
child's consumer (IpInstance != NULL) or the IP6 driver itself
(IpInstance == NULL). It will route the packet, fragment it,
then transmit all the fragments through an interface.
@param[in] IpSb The IP6 service instance to transmit the packet.
@param[in] Interface The IP6 interface to transmit the packet. Ignored
if NULL.
@param[in] IpInstance The IP6 child that issues the transmission. It is
NULL if the packet is from the system.
@param[in] Packet The user data to send, excluding the IP header.
@param[in] Head The caller supplied header. The caller should set
the following header fields: NextHeader, HopLimit,
Src, Dest, FlowLabel, PayloadLength. This function
will fill in the Ver, TrafficClass.
@param[in] ExtHdrs The extension headers to append to the IPv6 basic
header.
@param[in] ExtHdrsLen The length of the extension headers.
@param[in] Callback The callback function to issue when transmission
completed.
@param[in] Context The opaque context for the callback.
@retval EFI_INVALID_PARAMETER Any input parameter or the packet is invalid.
@retval EFI_NO_MAPPING There is no interface to the destination.
@retval EFI_NOT_FOUND There is no route to the destination.
@retval EFI_SUCCESS The packet successfully transmitted.
@retval EFI_OUT_OF_RESOURCES Failed to finish the operation due to lack of
resources.
@retval Others Failed to transmit the packet.
**/
EFI_STATUS
Ip6Output (
IN IP6_SERVICE *IpSb,
IN IP6_INTERFACE *Interface OPTIONAL,
IN IP6_PROTOCOL *IpInstance OPTIONAL,
IN NET_BUF *Packet,
IN EFI_IP6_HEADER *Head,
IN UINT8 *ExtHdrs,
IN UINT32 ExtHdrsLen,
IN IP6_FRAME_CALLBACK Callback,
IN VOID *Context
)
{
IP6_INTERFACE *IpIf;
EFI_IPv6_ADDRESS NextHop;
IP6_NEIGHBOR_ENTRY *NeighborCache;
IP6_ROUTE_CACHE_ENTRY *RouteCache;
EFI_STATUS Status;
UINT32 Mtu;
UINT32 HeadLen;
UINT16 FragmentOffset;
UINT8 *LastHeader;
UINT32 UnFragmentLen;
UINT32 UnFragmentHdrsLen;
UINT32 FragmentHdrsLen;
UINT16 *Checksum;
UINT16 PacketChecksum;
UINT16 PseudoChecksum;
UINT32 Index;
UINT32 PacketLen;
UINT32 RealExtLen;
UINT32 Offset;
NET_BUF *TmpPacket;
NET_BUF *Fragment;
UINT32 Num;
UINT8 *Buf;
EFI_IP6_HEADER *PacketHead;
IP6_ICMP_HEAD *IcmpHead;
IP6_TXTOKEN_WRAP *Wrap;
IP6_ROUTE_ENTRY *RouteEntry;
UINT8 *UpdatedExtHdrs;
UINT8 NextHeader;
UINT8 LastHeaderBackup;
BOOLEAN FragmentHeadInserted;
UINT8 *ExtHdrsBackup;
UINT8 NextHeaderBackup;
EFI_IPv6_ADDRESS Source;
EFI_IPv6_ADDRESS Destination;
NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
//
// RFC2460: Each extension header is an integer multiple of 8 octets long,
// in order to retain 8-octet alignment for subsequent headers.
//
if ((ExtHdrsLen & 0x7) != 0) {
return EFI_INVALID_PARAMETER;
}
LastHeader = NULL;
Ip6IsExtsValid (
NULL,
NULL,
&Head->NextHeader,
ExtHdrs,
ExtHdrsLen,
FALSE,
NULL,
&LastHeader,
NULL,
NULL,
NULL
);
//
// Select an interface/source for system packet, application
// should select them itself.
//
IpIf = Interface;
if (IpIf == NULL) {
//
// IpInstance->Interface is NULL when IpInstance is configured with both stationaddress
// and destinationaddress is unspecified.
//
if (IpInstance == NULL || IpInstance->Interface == NULL) {
IpIf = Ip6SelectInterface (IpSb, &Head->DestinationAddress, &Head->SourceAddress);
if (IpInstance != NULL) {
IpInstance->Interface = IpIf;
}
} else {
IpIf = IpInstance->Interface;
}
}
if (IpIf == NULL) {
return EFI_NO_MAPPING;
}
//
// Update the common field in Head here.
//
Head->Version = 6;
Head->TrafficClassL = 0;
Head->TrafficClassH = 0;
Checksum = NULL;
NextHeader = *LastHeader;
switch (NextHeader) {
case EFI_IP_PROTO_UDP:
Packet->Udp = (EFI_UDP_HEADER *) NetbufGetByte (Packet, 0, NULL);
ASSERT (Packet->Udp != NULL);
if (Packet->Udp->Checksum == 0) {
Checksum = &Packet->Udp->Checksum;
}
break;
case EFI_IP_PROTO_TCP:
Packet->Tcp = (TCP_HEAD *) NetbufGetByte (Packet, 0, NULL);
ASSERT (Packet->Tcp != NULL);
if (Packet->Tcp->Checksum == 0) {
Checksum = &Packet->Tcp->Checksum;
}
break;
case IP6_ICMP:
//
// Don't send ICMP packet to an IPv6 anycast address.
//
if (Ip6IsAnycast (IpSb, &Head->DestinationAddress)) {
return EFI_INVALID_PARAMETER;
}
IcmpHead = (IP6_ICMP_HEAD *) NetbufGetByte (Packet, 0, NULL);
ASSERT (IcmpHead != NULL);
if (IcmpHead->Checksum == 0) {
Checksum = &IcmpHead->Checksum;
}
break;
default:
break;
}
if (Checksum != NULL) {
//
// Calculate the checksum for upper layer protocol if it is not calculated due to lack of
// IPv6 source address.
//
PacketChecksum = NetbufChecksum (Packet);
PseudoChecksum = NetIp6PseudoHeadChecksum (
&Head->SourceAddress,
&Head->DestinationAddress,
NextHeader,
Packet->TotalSize
);
*Checksum = (UINT16) ~NetAddChecksum (PacketChecksum, PseudoChecksum);
}
Status = Ip6IpSecProcessPacket (
IpSb,
&Head,
LastHeader, // no need get the lasthead value for output
&Packet,
&ExtHdrs,
&ExtHdrsLen,
EfiIPsecOutBound,
Context
);
if (EFI_ERROR(Status)) {
return Status;
}
LastHeader = NULL;
//
// Check incoming parameters.
//
if (!Ip6IsExtsValid (
IpSb,
Packet,
&Head->NextHeader,
ExtHdrs,
ExtHdrsLen,
FALSE,
NULL,
&LastHeader,
&RealExtLen,
&UnFragmentHdrsLen,
NULL
)) {
return EFI_INVALID_PARAMETER;
}
if ((RealExtLen & 0x7) != 0) {
return EFI_INVALID_PARAMETER;
}
LastHeaderBackup = *LastHeader;
//
// Perform next hop determination:
// For multicast packets, the next-hop is always the destination address and
// is considered to be on-link.
//
if (IP6_IS_MULTICAST (&Head->DestinationAddress)) {
IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);
} else {
//
// For unicast packets, use a combination of the Destination Cache, the Prefix List
// and the Default Router List to determine the IP address of the appropriate next hop.
//
NeighborCache = Ip6FindNeighborEntry (IpSb, &Head->DestinationAddress);
if (NeighborCache != NULL) {
//
// Hit Neighbor Cache.
//
IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);
} else {
//
// Not in Neighbor Cache, check Router cache
//
RouteCache = Ip6Route (IpSb, &Head->DestinationAddress, &Head->SourceAddress);
if (RouteCache == NULL) {
return EFI_NOT_FOUND;
}
IP6_COPY_ADDRESS (&NextHop, &RouteCache->NextHop);
Ip6FreeRouteCacheEntry (RouteCache);
}
}
//
// Examines the Neighbor Cache for link-layer information about that neighbor.
// DO NOT create neighbor cache if neighbor is itself - when reporting ICMP error.
//
if (!IP6_IS_MULTICAST (&NextHop) && !EFI_IP6_EQUAL (&Head->DestinationAddress, &Head->SourceAddress)) {
NeighborCache = Ip6FindNeighborEntry (IpSb, &NextHop);
if (NeighborCache == NULL) {
NeighborCache = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, &NextHop, NULL);
if (NeighborCache == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Send out multicast neighbor solicitation for address resolution immediately.
//
Ip6CreateSNMulticastAddr (&NeighborCache->Neighbor, &Destination);
Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);
if (EFI_ERROR (Status)) {
return Status;
}
Status = Ip6SendNeighborSolicit (
IpSb,
&Source,
&Destination,
&NeighborCache->Neighbor,
&IpSb->SnpMode.CurrentAddress
);
if (EFI_ERROR (Status)) {
return Status;
}
--NeighborCache->Transmit;
NeighborCache->Ticks = IP6_GET_TICKS (IpSb->RetransTimer) + 1;
}
NeighborCache->Interface = IpIf;
}
UpdatedExtHdrs = NULL;
ExtHdrsBackup = NULL;
NextHeaderBackup = 0;
FragmentHeadInserted = FALSE;
//
// Check whether we received Packet Too Big message for the packet sent to the
// Destination. If yes include a Fragment Header in the subsequent packets.
//
RouteEntry = Ip6FindRouteEntry (
IpSb->RouteTable,
&Head->DestinationAddress,
NULL
);
if (RouteEntry != NULL) {
if ((RouteEntry->Flag & IP6_PACKET_TOO_BIG) == IP6_PACKET_TOO_BIG) {
//
// FragmentHead is inserted after Hop-by-Hop Options header, Destination
// Options header (first occur), Routing header, and before Fragment header,
// Authentication header, Encapsulating Security Payload header, and
// Destination Options header (last occur), and upper-layer header.
//
Status = Ip6FillFragmentHeader (
IpSb,
Head->NextHeader,
LastHeaderBackup,
ExtHdrs,
ExtHdrsLen,
0,
&UpdatedExtHdrs
);
if (EFI_ERROR (Status)) {
return Status;
}
if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {
NextHeaderBackup = Head->NextHeader;
Head->NextHeader = IP6_FRAGMENT;
}
ExtHdrsBackup = ExtHdrs;
ExtHdrs = UpdatedExtHdrs;
ExtHdrsLen = ExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER);
RealExtLen = RealExtLen + sizeof (IP6_FRAGMENT_HEADER);
mIp6Id++;
FragmentHeadInserted = TRUE;
}
Ip6FreeRouteEntry (RouteEntry);
}
//
// OK, selected the source and route, fragment the packet then send
// them. Tag each fragment other than the first one as spawn from it.
// Each extension header is an integer multiple of 8 octets long, in
// order to retain 8-octet alignment for subsequent headers.
//
Mtu = IpSb->MaxPacketSize + sizeof (EFI_IP6_HEADER);
HeadLen = sizeof (EFI_IP6_HEADER) + RealExtLen;
if (Packet->TotalSize + HeadLen > Mtu) {
//
// Remove the inserted Fragment Header since we need fragment the packet.
//
if (FragmentHeadInserted) {
ExtHdrs = ExtHdrsBackup;
ExtHdrsLen = ExtHdrsLen - sizeof (IP6_FRAGMENT_HEADER);
if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {
Head->NextHeader = NextHeaderBackup;
}
}
FragmentHdrsLen = ExtHdrsLen - UnFragmentHdrsLen;
//
// The packet is beyond the maximum which can be described through the
// fragment offset field in Fragment header.
//
if ((((Packet->TotalSize + FragmentHdrsLen) >> 3) & (~0x1fff)) != 0) {
Status = EFI_BAD_BUFFER_SIZE;
goto Error;
}
if (FragmentHdrsLen != 0) {
//
// Append the fragmentable extension hdrs before the upper layer payload
// to form a new NET_BUF. This NET_BUF contains all the buffer which will
// be fragmented below.
//
TmpPacket = NetbufGetFragment (Packet, 0, Packet->TotalSize, FragmentHdrsLen);
ASSERT (TmpPacket != NULL);
//
// Allocate the space to contain the fragmentable hdrs and copy the data.
//
Buf = NetbufAllocSpace (TmpPacket, FragmentHdrsLen, TRUE);
ASSERT (Buf != NULL);
CopyMem (Buf, ExtHdrs + UnFragmentHdrsLen, FragmentHdrsLen);
//
// Free the old Packet.
//
NetbufFree (Packet);
Packet = TmpPacket;
}
//
// The unfragment part which appears in every fragmented IPv6 packet includes
// the IPv6 header, the unfragmentable extension hdrs and the fragment header.
//
UnFragmentLen = sizeof (EFI_IP6_HEADER) + UnFragmentHdrsLen + sizeof (IP6_FRAGMENT_HEADER);
//
// Mtu now is the length of the fragment part in a full-length fragment.
//
Mtu = (Mtu - UnFragmentLen) & (~0x07);
Num = (Packet->TotalSize + Mtu - 1) / Mtu;
for (Index = 0, Offset = 0, PacketLen = Mtu; Index < Num; Index++) {
//
// Get fragment from the Packet, append UnFragnmentLen spare buffer
// before the fragmented data, the corresponding data is filled in later.
//
Fragment = NetbufGetFragment (Packet, Offset, PacketLen, UnFragmentLen);
if (Fragment == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Error;
}
FragmentOffset = (UINT16) ((UINT16) Offset | 0x1);
if (Index == Num - 1){
//
// The last fragment, clear the M flag.
//
FragmentOffset &= (~0x1);
}
Status = Ip6PrependHead (
IpSb,
Fragment,
Head,
FragmentOffset,
ExtHdrs,
ExtHdrsLen,
LastHeaderBackup,
UnFragmentLen
);
ASSERT (Status == EFI_SUCCESS);
Status = Ip6SendFrame (
IpIf,
IpInstance,
Fragment,
&NextHop,
Ip6SysPacketSent,
Packet
);
if (EFI_ERROR (Status)) {
goto Error;
}
//
// The last fragment of upper layer packet, update the IP6 token status.
//
if ((Index == Num -1) && (Context != NULL)) {
Wrap = (IP6_TXTOKEN_WRAP *) Context;
Wrap->Token->Status = Status;
}
Offset += PacketLen;
PacketLen = Packet->TotalSize - Offset;
if (PacketLen > Mtu) {
PacketLen = Mtu;
}
}
NetbufFree (Packet);
mIp6Id++;
if (UpdatedExtHdrs != NULL) {
FreePool (UpdatedExtHdrs);
}
return EFI_SUCCESS;
}
//
// Need not fragment the packet, send it in one frame.
//
PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);
if (PacketHead == NULL) {
Status = EFI_BAD_BUFFER_SIZE;
goto Error;
}
CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));
Packet->Ip.Ip6 = PacketHead;
if (ExtHdrs != NULL) {
Buf = (UINT8 *) (PacketHead + 1);
CopyMem (Buf, ExtHdrs, ExtHdrsLen);
}
if (UpdatedExtHdrs != NULL) {
//
// A Fragment Header is inserted to the packet, update the payload length.
//
PacketHead->PayloadLength = (UINT16) (NTOHS (PacketHead->PayloadLength) +
sizeof (IP6_FRAGMENT_HEADER));
PacketHead->PayloadLength = HTONS (PacketHead->PayloadLength);
FreePool (UpdatedExtHdrs);
}
return Ip6SendFrame (
IpIf,
IpInstance,
Packet,
&NextHop,
Callback,
Context
);
Error:
if (UpdatedExtHdrs != NULL) {
FreePool (UpdatedExtHdrs);
}
Ip6CancelPacket (IpIf, Packet, Status);
return Status;
}
/**
The filter function to find a packet and all its fragments.
The packet's fragments have their Context set to the packet.
@param[in] Frame The frames hold by the low level interface.
@param[in] Context Context to the function, which is the packet.
@retval TRUE This is the packet to cancel or its fragments.
@retval FALSE This is an unrelated packet.
**/
BOOLEAN
Ip6CancelPacketFragments (
IN IP6_LINK_TX_TOKEN *Frame,
IN VOID *Context
)
{
if ((Frame->Packet == (NET_BUF *) Context) || (Frame->Context == Context)) {
return TRUE;
}
return FALSE;
}
/**
Remove all the frames on the interface that pass the FrameToCancel,
either queued on ARP queues or that have already been delivered to
MNP and not yet recycled.
@param[in] Interface Interface to remove the frames from.
@param[in] IoStatus The transmit status returned to the frames' callback.
@param[in] FrameToCancel Function to select the frame to cancel; NULL to select all.
@param[in] Context Opaque parameters passed to FrameToCancel. Ignored if
FrameToCancel is NULL.
**/
VOID
Ip6CancelFrames (
IN IP6_INTERFACE *Interface,
IN EFI_STATUS IoStatus,
IN IP6_FRAME_TO_CANCEL FrameToCancel OPTIONAL,
IN VOID *Context OPTIONAL
)
{
LIST_ENTRY *Entry;
LIST_ENTRY *Next;
IP6_LINK_TX_TOKEN *Token;
IP6_SERVICE *IpSb;
IP6_NEIGHBOR_ENTRY *ArpQue;
EFI_STATUS Status;
IpSb = Interface->Service;
NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
//
// Cancel all the pending frames on ARP requests
//
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {
ArpQue = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, ArpList);
Status = Ip6FreeNeighborEntry (
IpSb,
ArpQue,
FALSE,
FALSE,
IoStatus,
FrameToCancel,
Context
);
ASSERT_EFI_ERROR (Status);
}
//
// Cancel all the frames that have been delivered to MNP
// but not yet recycled.
//
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {
Token = NET_LIST_USER_STRUCT (Entry, IP6_LINK_TX_TOKEN, Link);
if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
IpSb->Mnp->Cancel (IpSb->Mnp, &Token->MnpToken);
}
}
}
/**
Cancel the Packet and all its fragments.
@param[in] IpIf The interface from which the Packet is sent.
@param[in] Packet The Packet to cancel.
@param[in] IoStatus The status returns to the sender.
**/
VOID
Ip6CancelPacket (
IN IP6_INTERFACE *IpIf,
IN NET_BUF *Packet,
IN EFI_STATUS IoStatus
)
{
Ip6CancelFrames (IpIf, IoStatus, Ip6CancelPacketFragments, Packet);
}