4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IP6 internal functions to process the incoming packets.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync This program and the accompanying materials
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are licensed and made available under the terms and conditions of the BSD License
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync which accompanies this distribution. The full text of the license may be found at
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Create an empty assemble entry for the packet identified by
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (Dst, Src, Id). The default life for the packet is 60 seconds.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Dst The destination address.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Src The source address.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Id The ID field in the IP header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @return NULL if failed to allocate memory for the entry. Otherwise,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the pointer to the just created reassemble entry.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Assemble = AllocatePool (sizeof (IP6_ASSEMBLE_ENTRY));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Release all the fragments of a packet, then free the assemble entry.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Assemble The assemble entry to free.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_LIST_FOR_EACH_SAFE (Entry, Next, &Assemble->Fragments) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Release all the fragments of the packet. This is the callback for
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the assembled packet's OnFree. It will free the assemble entry,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync which in turn frees all the fragments of the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Arg The assemble entry to free.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Trim the packet to fit in [Start, End), and update per the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync packet information.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Packet Packet to trim.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Start The sequence of the first byte to fit in.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] End One beyond the sequence of last byte to fit in.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ASSERT ((Info->Start < End) && (Start < Info->End));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Reassemble the IP fragments. If all the fragments of the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync have been received, it will wrap the packet in a net buffer then
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync return it to caller. If the packet can't be assembled, NULL is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Table The assemble table used. A new assemble entry will be created
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if the Packet is from a new chain of fragments.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The fragment to assemble. It might be freed if the fragment
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync can't be re-assembled.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @return NULL if the packet can't be reassembled. The pointer to the just assembled
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync packet if all the fragments of the packet have arrived.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Find the corresponding assemble entry by (Dst, Src, Id)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Index = IP6_ASSEMBLE_HASH (&Head->DestinationAddress, &Head->SourceAddress, This->Id);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Entry = NET_LIST_USER_STRUCT (Cur, IP6_ASSEMBLE_ENTRY, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync EFI_IP6_EQUAL (&Entry->Src, &Head->SourceAddress) &&
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync EFI_IP6_EQUAL (&Entry->Dst, &Head->DestinationAddress)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Create a new entry if can not find an existing one, insert it to assemble table
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync InsertHeadList (&Table->Bucket[Index], &Assemble->Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Find the point to insert the packet: before the first
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // fragment with THIS.Start < CUR.Start. the previous one
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // has PREV.Start <= THIS.Start < CUR.Start.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (This->Start < IP6_GET_CLIP_INFO (Fragment)->Start) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the current fragment overlaps with the previous one.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // It holds that: PREV.Start <= THIS.Start < THIS.End. Only need to
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // check whether THIS.Start < PREV.End for overlap. If two fragments
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // overlaps, trim the overlapped part off THIS fragment.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Cur != ListHead) && ((Prev = Cur->BackLink) != ListHead)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Trim the previous fragment from tail.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Ip6TrimPacket (Fragment, Node->Start, This->Start);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Insert the fragment into the packet. The fragment may be removed
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // from the list by the following checks.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check the packets after the insert point. It holds that:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // THIS.Start <= NODE.Start < NODE.End. The equality holds
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // if PREV and NEXT are continuous. THIS fragment may fill
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // several holes. Remove the completely overlapped fragments
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Remove fragments completely overlapped by this fragment
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // The conditions are: THIS.Start <= NODE.Start, and THIS.End <
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // NODE.End. Two fragments overlaps if NODE.Start < THIS.End.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If two fragments start at the same offset, remove THIS fragment
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // because ((THIS.Start == NODE.Start) && (THIS.End < NODE.End)).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Update the assemble info: increase the current length. If it is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the frist fragment, update the packet's IP head and per packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // info. If it is the last fragment, update the total length.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Once the first fragment is enqueued, it can't be removed
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // from the fragment list. So, Assemble->Head always point
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // to valid memory area.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Assemble->Head != NULL) || (Assemble->Packet != NULL)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Backup the first fragment in case the reasembly of that packet fail.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Duplicate = NetbufDuplicate (Packet, NULL, sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Revert IP head to network order.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Duplicate->Ip.Ip6 = Ip6NtohHead ((EFI_IP6_HEADER *) DupHead);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Adjust the unfragmentable part in first fragment
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync UnFragmentLen = (UINT16) (This->HeadLen - sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // There is not any unfragmentable extension header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Don't update the length more than once.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((This->LastFrag != 0) && (Assemble->TotalLen == 0)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Deliver the whole packet if all the fragments received.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // All fragments received if:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // 1. received the last one, so, the totoal length is know
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // 2. received all the data. If the last fragment on the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // queue ends at the total length, all data is received.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Assemble->TotalLen != 0) && (Assemble->CurLen >= Assemble->TotalLen)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If the packet is properly formated, the last fragment's End
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // equals to the packet's total length. Otherwise, the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // is a fake, drop it now.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (ListHead->BackLink, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (IP6_GET_CLIP_INFO (Fragment)->End != (INTN) Assemble->TotalLen) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_HEAD (ListHead, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // This TmpPacket is used to hold the unfragmentable part, i.e.,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the IPv6 header and the unfragmentable extension headers. Be noted that
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the Fragment Header is exluded.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync TmpPacket = NetbufGetFragment (Fragment, 0, This->HeadLen, 0);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Trim off the unfragment part plus the fragment header from all fragments.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Fragment = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufTrim (Fragment, This->HeadLen + sizeof (IP6_FRAGMENT_HEADER), TRUE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Wrap the packet in a net buffer then deliver it up
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync CopyMem (IP6_GET_CLIP_INFO (NewPacket), Assemble->Info, sizeof (IP6_CLIP_INFO));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The callback function for the net buffer that wraps the packet processed by
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IPsec. It releases the wrap packet and also signals IPsec to free the resources.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Arg The wrap context.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The work function to locate the IPsec protocol to process the inbound or
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync outbound IP packets. The process routine handles the packet with the following
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync actions: bypass the packet, discard the packet, or protect the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Head The caller-supplied IP6 header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] LastHead The next header field of last IP header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Netbuf The IP6 packet to be processed by IPsec.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] ExtHdrs The caller-supplied options.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] ExtHdrsLen The length of the option.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Direction The directionality in an SPD entry,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync EfiIPsecInBound, or EfiIPsecOutBound.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Context The token's wrap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS The IPsec protocol is not available or disabled.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS The packet was bypassed, and all buffers remain the same.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS The packet was protected.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_ACCESS_DENIED The packet was discarded.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_OUT_OF_RESOURCES There are not suffcient resources to complete the operation.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_BUFFER_TOO_SMALL The number of non-empty blocks is bigger than the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync number of input data blocks when building a fragment table.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync gBS->LocateProtocol (&gEfiIpSec2ProtocolGuid, NULL, (VOID **) &mIpSec);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the ipsec protocol is available.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the ipsec enable variable is set.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If IPsec is disabled, restore the original MTU
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If IPsec is enabled, use the MTU which reduce the IPsec header length.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpSb->MaxPacketSize = IpSb->OldMaxPacketSize - IP6_MAX_IPSEC_HEADLEN;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Bypass all multicast inbound or outbound traffic.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (IP6_IS_MULTICAST (&(*Head)->DestinationAddress) || IP6_IS_MULTICAST (&(*Head)->SourceAddress)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Rebuild fragment table from netbuf to ease ipsec process.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync FragmentTable = AllocateZeroPool (FragmentCount * sizeof (NET_FRAGMENT));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Status = NetbufBuildExt (Packet, FragmentTable, &FragmentCount);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Convert host byte order to network byte order
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Convert back to host byte order
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (OriginalFragmentCount == FragmentCount && OriginalFragmentTable == FragmentTable) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // For ByPass Packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Free the FragmentTable which allocated before calling the IPsec.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Direction == EfiIPsecOutBound && TxWrap != NULL) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpSecWrap = AllocateZeroPool (sizeof (IP6_IPSEC_WRAP));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Direction == EfiIPsecInBound && 0 != CompareMem (&ZeroHead, *Head, sizeof (EFI_IP6_HEADER))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync CopyMem (PacketHead, *Head, sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufTrim (Packet, sizeof (EFI_IP6_HEADER) + *ExtHdrsLen, TRUE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Pre-process the IPv6 packet. First validates the IPv6 packet, and
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync then reassembles packet if it is necessary.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Packet The received IP6 packet to be processed.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Flag The link layer flag for the packet received, such
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync as multicast.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] Payload The pointer to the payload of the recieved packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync it starts from the first byte of the extension header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] LastHead The pointer of NextHeader of the last extension
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync header processed by IP6.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] ExtHdrsLen The length of the whole option.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] UnFragmentLen The length of unfragmented length of extension headers.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] Fragmented Indicate whether the packet is fragmented.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[out] Head The pointer to the EFI_IP6_Header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS The received packet is well format.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_INVALID_PARAMETER The received packet is malformed.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the input packet is a valid packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Get header information of the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *Head = (EFI_IP6_HEADER *) NetbufGetByte (*Packet, 0, NULL);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Multicast addresses must not be used as source addresses in IPv6 packets.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (((*Head)->Version != 6) || (IP6_IS_MULTICAST (&(*Head)->SourceAddress))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // A packet with a destination address of loopback ::1/128 or unspecified must be dropped.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((CompareMem (&Loopback, &(*Head)->DestinationAddress, sizeof (EFI_IPv6_ADDRESS)) == 0) ||
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync (NetIp6IsUnspecifiedAddr (&(*Head)->DestinationAddress))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Convert the IP header to host byte order.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Get the per packet info.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (IpSb->MnpConfigData.EnablePromiscuousReceive) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Ip6IsOneOfSetAddress (IpSb, &(*Head)->DestinationAddress, NULL, NULL)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync } else if (IP6_IS_MULTICAST (&(*Head)->DestinationAddress)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Ip6FindMldEntry (IpSb, &(*Head)->DestinationAddress) != NULL) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Drop the packet that is not delivered to us.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync TotalLen = (UINT16) (PayloadLen + sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Mnp may deliver frame trailer sequence up, trim it off.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufTrim (*Packet, (*Packet)->TotalSize - TotalLen, FALSE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check the extension headers, if exist validate them
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufCopy (*Packet, sizeof (EFI_IP6_HEADER), PayloadLen, *Payload);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync HeadLen = sizeof (EFI_IP6_HEADER) + *UnFragmentLen;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Get the fragment offset from the Fragment header
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync FragmentHead = (IP6_FRAGMENT_HEADER *) NetbufGetByte (*Packet, HeadLen, NULL);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync FragmentOffset = NTOHS (FragmentHead->FragmentOffset);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // This is the first fragment of the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Fragments should in the unit of 8 octets long except the last one.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Info->LastFrag == 0) && (Info->Length % 8 != 0)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Reassemble the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *Packet = Ip6Reassemble (&IpSb->Assemble, *Packet);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Re-check the assembled packet to get the right values.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufCopy (*Packet, sizeof (EFI_IP6_HEADER), PayloadLen, *Payload);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Trim the head off, after this point, the packet is headless.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // and Packet->TotalLen == Info->Length.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufTrim (*Packet, sizeof (EFI_IP6_HEADER) + *ExtHdrsLen, TRUE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The IP6 input routine. It is called by the IP6_INTERFACE when an
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IP6 fragment is received from MNP.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The IP6 packet received.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IoStatus The return status of receive request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Flag The link layer flag for the packet received, such
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync as multicast.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Context The IP6 service instance that owns the MNP.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check input parameters
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (EFI_ERROR (IoStatus) || (IpSb->State == IP6_SERVICE_DESTROY)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Pre-Process the Ipv6 Packet and then reassemble if it is necessary.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // After trim off, the packet is a esp/ah/udp/tcp/icmp6 net buffer,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // and no need consider any other ahead ext headers.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If the packet is protected by IPsec Tunnel Mode, Check the Inner Ip Packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (0 == CompareMem (Head, &ZeroHead, sizeof (EFI_IP6_HEADER))) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check the Packet again.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Packet may have been changed. The ownership of the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // is transfered to the packet process logic.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Dispatch the DPCs queued by the NotifyFunction of the rx token's events
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // which are signaled with received data.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Initialize an already allocated assemble table. This is generally
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the assemble table embedded in the IP6 service instance.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Table The assemble table to initialize.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (Index = 0; Index < IP6_ASSEMLE_HASH_SIZE; Index++) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Clean up the assemble table by removing all of the fragments
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync and assemble entries.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in, out] Table The assemble table to clean up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (Index = 0; Index < IP6_ASSEMLE_HASH_SIZE; Index++) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_LIST_FOR_EACH_SAFE (Entry, Next, &Table->Bucket[Index]) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Assemble = NET_LIST_USER_STRUCT (Entry, IP6_ASSEMBLE_ENTRY, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync The signal handle of IP6's recycle event. It is called back
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync when the upper layer releases the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Event The IP6's recycle event.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Context The context of the handle, which is a IP6_RXDATA_WRAP.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync EfiAcquireLockOrFail (&Wrap->IpInstance->RecycleLock);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Wrap the received packet to a IP6_RXDATA_WRAP, which will be
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync delivered to the upper layer. Each IP6 child that accepts the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync packet will get a not-shared copy of the packet which is wrapped
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync in the IP6_RXDATA_WRAP. The IP6_RXDATA_WRAP->RxData is passed
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync to the upper layer. The upper layer will signal the recycle event in
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync it when it is done with the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpInstance The IP6 child to receive the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The packet to deliver up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @return NULL if it failed to wrap the packet; otherwise, the wrapper.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Wrap = AllocatePool (IP6_RXDATA_WRAP_SIZE (Packet->BlockOpNum));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // The application expects a network byte order header.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync RxData->Header = (EFI_IP6_HEADER *) Ip6NtohHead (Packet->Ip.Ip6);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Build the fragment table to be delivered up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufBuildExt (Packet, (NET_FRAGMENT *) RxData->FragmentTable, &RxData->FragmentCount);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Check whether this IP child accepts the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpInstance The IP child to check.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Head The IP header of the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The data of the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval TRUE The child wants to receive the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval FALSE The child does not want to receive the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Dirty trick for the Tiano UEFI network stack implmentation. If
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // ReceiveTimeout == -1, the receive of the packet for this instance
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // is disabled. The UEFI spec don't have such captibility. We add
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // this to improve the performance because IP will make a copy of
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the received packet for each accepting instance. Some IP instances
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // used by UDP/TCP only send packets, they don't wants to receive.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the protocol is acceptable.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // The upper layer driver may want to receive the ICMPv6 error packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // invoked by its packet, like UDP.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((*Proto == IP6_ICMP) && (!Config->AcceptAnyProtocol) && (*Proto != Config->DefaultProtocol)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *) &Icmp);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Get the protocol of the invoking packet of ICMPv6 error packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ErrMsgPayloadLen = NTOHS (Icmp.IpHead.PayloadLength);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync ErrMsgPayload = NetbufGetByte (Packet, sizeof (Icmp), NULL);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Match the protocol
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (!Config->AcceptAnyProtocol && (*Proto != Config->DefaultProtocol)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check for broadcast, the caller has computed the packet's
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // cast type for this child's interface.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If it is a multicast packet, check whether we are in the group.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Receive the multicast if the instance wants to receive all packets.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (NetIp6IsUnspecifiedAddr (&IpInstance->ConfigData.StationAddress)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (Index = 0; Index < IpInstance->GroupCount; Index++) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (EFI_IP6_EQUAL (IpInstance->GroupList + Index, &Head->DestinationAddress)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Enqueue a shared copy of the packet to the IP6 child if the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync packet is acceptable to it. Here the data of the packet is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync shared, but the net buffer isn't.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param IpInstance The IP6 child to enqueue the packet to.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param Head The IP header of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param Packet The data of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_NOT_STARTED The IP child hasn't been configured.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_INVALID_PARAMETER The child doesn't want to receive the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_OUT_OF_RESOURCES Failed to allocate some resources
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS A shared copy the packet is enqueued to the child.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Check whether the packet is acceptable to this instance.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (!Ip6InstanceFrameAcceptable (IpInstance, Head, Packet)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Enque a shared copy of the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Set the receive time out for the assembled packet. If it expires,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // packet will be removed from the queue.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Info->Life = IP6_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync InsertTailList (&IpInstance->Received, &Clone->List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Deliver the received packets to the upper layer if there are both received
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync requests and enqueued packets. If the enqueued packet is shared, it will
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync duplicate it to a non-shared packet, release the shared packet, then
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync deliver the non-shared packet up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpInstance The IP child to deliver the packet up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to deliver the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS All the enqueued packets that can be delivered
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync are delivered up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Deliver a packet if there are both a packet and a receive token.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync while (!IsListEmpty (&IpInstance->Received) && !NetMapIsEmpty (&IpInstance->RxTokens)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Packet = NET_LIST_HEAD (&IpInstance->Received, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If this is the only instance that wants the packet, wrap it up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Create a duplicated packet if this packet is shared
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Dup = NetbufDuplicate (Packet, NULL, sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Copy the IP head over. The packet to deliver up is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // headless. Trim the head off after copy. The IP head
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // may be not continuous before the data.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Head = NetbufAllocSpace (Dup, sizeof (EFI_IP6_HEADER), NET_BUF_HEAD);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync CopyMem (Head, Packet->Ip.Ip6, sizeof (EFI_IP6_HEADER));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Insert it into the delivered packet, then get a user's
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // receive token, pass the wrapped packet up.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync InsertHeadList (&IpInstance->Delivered, &Wrap->Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Token = NetMapRemoveHead (&IpInstance->RxTokens, NULL);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Token->Status = IP6_GET_CLIP_INFO (Packet)->Status;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Enqueue a received packet to all the IP children that share
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync the same interface.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance that receive the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Head The header of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The data of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpIf The interface to enqueue the packet to.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @return The number of the IP6 children that accepts the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // First, check that the packet is acceptable to this interface
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // and find the local cast type for the interface.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Iterate through the ip instances on the interface, enqueue
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the packet if filter passed. Save the original cast type,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // and pass the local cast type to the IP children on the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // interface. The global cast type will be restored later.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpInstance = NET_LIST_USER_STRUCT (Entry, IP6_PROTOCOL, AddrLink);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_CHECK_SIGNATURE (IpInstance, IP6_PROTOCOL_SIGNATURE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if (Ip6InstanceEnquePacket (IpInstance, Head, Packet) == EFI_SUCCESS) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Deliver the packet for each IP6 child on the interface.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance that received the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpIf The IP6 interface to deliver the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpInstance = NET_LIST_USER_STRUCT (Entry, IP6_PROTOCOL, AddrLink);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync De-multiplex the packet. the packet delivery is processed in two
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync passes. The first pass will enqueue a shared copy of the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync to each IP6 child that accepts the packet. The second pass will
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync deliver a non-shared copy of the packet to each IP6 child that
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync has pending receive requests. Data is copied if more than one
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync child wants to consume the packet, because each IP child needs
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync its own copy of the packet to make changes.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance that received the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Head The header of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Packet The data of the received packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_NOT_FOUND No IP child accepts the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS The packet is enqueued or delivered to some IP
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Two pass delivery: first, enque a shared copy of the packet
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // to each instance that accept the packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Enqueued += Ip6InterfaceEnquePacket (IpSb, Head, Packet, IpIf);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Second: deliver a duplicate of the packet to each instance.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Release the local reference first, so that the last instance
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // getting the packet will not copy the data.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Decrease the life of the transmitted packets. If it is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync decreased to zero, cancel the packet. This function is
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync called by Ip6packetTimerTicking that provides timeout for both the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync received-but-not-delivered and transmitted-but-not-recycle
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Map The IP6 child's transmit map.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Item Current transmitted packet.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] Context Not used.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @retval EFI_SUCCESS Always returns EFI_SUCCESS.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Ip6CancelPacket (Wrap->IpInstance->Interface, Wrap->Packet, EFI_ABORTED);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Timeout the fragments, and the enqueued, and transmitted packets.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync @param[in] IpSb The IP6 service instance to timeout.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // First, time out the fragments. The packet's life is counting down
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // once the first-arriving fragment of that packet was received.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync for (Index = 0; Index < IP6_ASSEMLE_HASH_SIZE; Index++) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_LIST_FOR_EACH_SAFE (Entry, Next, &(IpSb->Assemble.Bucket[Index])) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Assemble = NET_LIST_USER_STRUCT (Entry, IP6_ASSEMBLE_ENTRY, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync if ((Assemble->Life > 0) && (--Assemble->Life == 0)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If the first fragment (the one with a Fragment Offset of zero)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // has been received, an ICMP Time Exceeded - Fragment Reassembly
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Time Exceeded message should be sent to the source of that fragment.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync !IP6_IS_MULTICAST (&Assemble->Head->DestinationAddress)) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // If reassembly of a packet is not completed within 60 seconds of
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // the reception of the first-arriving fragment of that packet, the
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // reassembly must be abandoned and all the fragments that have been
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // received for that packet must be discarded.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_LIST_FOR_EACH (InstanceEntry, &IpSb->Children) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync IpInstance = NET_LIST_USER_STRUCT (InstanceEntry, IP6_PROTOCOL, Link);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Second, time out the assembled packets enqueued on each IP child.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpInstance->Received) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync Packet = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync // Third: time out the transmitted packets.