MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.c

   1 /** @file
   2   IP4 input process.
   3
   4 Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Ip4Impl.h"
  16
  17
  18 /**
  19   Create an empty assemble entry for the packet identified by
  20   (Dst, Src, Id, Protocol). The default life for the packet is
  21   120 seconds.
  22
  23   @param[in]  Dst                    The destination address
  24   @param[in]  Src                    The source address
  25   @param[in]  Id                     The ID field in IP header
  26   @param[in]  Protocol               The protocol field in IP header
  27
  28   @return NULL if failed to allocate memory for the entry, otherwise
  29           the point to just created reassemble entry.
  30
  31 **/
  32 IP4_ASSEMBLE_ENTRY *
  33 Ip4CreateAssembleEntry (
  34   IN IP4_ADDR               Dst,
  35   IN IP4_ADDR               Src,
  36   IN UINT16                 Id,
  37   IN UINT8                  Protocol
  38   )
  39 {
  40
  41   IP4_ASSEMBLE_ENTRY        *Assemble;
  42
  43   Assemble = AllocatePool (sizeof (IP4_ASSEMBLE_ENTRY));
  44
  45   if (Assemble == NULL) {
  46     return NULL;
  47   }
  48
  49   InitializeListHead (&Assemble->Link);
  50   InitializeListHead (&Assemble->Fragments);
  51
  52   Assemble->Dst      = Dst;
  53   Assemble->Src      = Src;
  54   Assemble->Id       = Id;
  55   Assemble->Protocol = Protocol;
  56   Assemble->TotalLen = 0;
  57   Assemble->CurLen   = 0;
  58   Assemble->Head     = NULL;
  59   Assemble->Info     = NULL;
  60   Assemble->Life     = IP4_FRAGMENT_LIFE;
  61
  62   return Assemble;
  63 }
  64
  65
  66 /**
  67   Release all the fragments of a packet, then free the assemble entry.
  68
  69   @param[in]  Assemble               The assemble entry to free
  70
  71 **/
  72 VOID
  73 Ip4FreeAssembleEntry (
  74   IN IP4_ASSEMBLE_ENTRY     *Assemble
  75   )
  76 {
  77   LIST_ENTRY                *Entry;
  78   LIST_ENTRY                *Next;
  79   NET_BUF                   *Fragment;
  80
  81   NET_LIST_FOR_EACH_SAFE (Entry, Next, &Assemble->Fragments) {
  82     Fragment = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
  83
  84     RemoveEntryList (Entry);
  85     NetbufFree (Fragment);
  86   }
  87
  88   FreePool (Assemble);
  89 }
  90
  91
  92 /**
  93   Initialize an already allocated assemble table. This is generally
  94   the assemble table embedded in the IP4 service instance.
  95
  96   @param[in, out]  Table                  The assemble table to initialize.
  97
  98 **/
  99 VOID
 100 Ip4InitAssembleTable (
 101   IN OUT IP4_ASSEMBLE_TABLE     *Table
 102   )
 103 {
 104   UINT32                    Index;
 105
 106   for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
 107     InitializeListHead (&Table->Bucket[Index]);
 108   }
 109 }
 110
 111
 112 /**
 113   Clean up the assemble table: remove all the fragments
 114   and assemble entries.
 115
 116   @param[in]  Table                  The assemble table to clean up
 117
 118 **/
 119 VOID
 120 Ip4CleanAssembleTable (
 121   IN IP4_ASSEMBLE_TABLE     *Table
 122   )
 123 {
 124   LIST_ENTRY                *Entry;
 125   LIST_ENTRY                *Next;
 126   IP4_ASSEMBLE_ENTRY        *Assemble;
 127   UINT32                    Index;
 128
 129   for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
 130     NET_LIST_FOR_EACH_SAFE (Entry, Next, &Table->Bucket[Index]) {
 131       Assemble = NET_LIST_USER_STRUCT (Entry, IP4_ASSEMBLE_ENTRY, Link);
 132
 133       RemoveEntryList (Entry);
 134       Ip4FreeAssembleEntry (Assemble);
 135     }
 136   }
 137 }
 138
 139
 140 /**
 141   Trim the packet to fit in [Start, End), and update the per
 142   packet information.
 143
 144   @param  Packet                 Packet to trim
 145   @param  Start                  The sequence of the first byte to fit in
 146   @param  End                    One beyond the sequence of last byte to fit in.
 147
 148 **/
 149 VOID
 150 Ip4TrimPacket (
 151   IN OUT NET_BUF                *Packet,
 152   IN     INTN                   Start,
 153   IN     INTN                   End
 154   )
 155 {
 156   IP4_CLIP_INFO             *Info;
 157   INTN                      Len;
 158
 159   Info = IP4_GET_CLIP_INFO (Packet);
 160
 161   ASSERT (Info->Start + Info->Length == Info->End);
 162   ASSERT ((Info->Start < End) && (Start < Info->End));
 163
 164    if (Info->Start < Start) {
 165     Len = Start - Info->Start;
 166
 167     NetbufTrim (Packet, (UINT32) Len, NET_BUF_HEAD);
 168     Info->Start   = Start;
 169     Info->Length -= Len;
 170   }
 171
 172   if (End < Info->End) {
 173     Len = End - Info->End;
 174
 175     NetbufTrim (Packet, (UINT32) Len, NET_BUF_TAIL);
 176     Info->End     = End;
 177     Info->Length -= Len;
 178   }
 179 }
 180
 181
 182 /**
 183   Release all the fragments of the packet. This is the callback for
 184   the assembled packet's OnFree. It will free the assemble entry,
 185   which in turn will free all the fragments of the packet.
 186
 187   @param[in]  Arg                    The assemble entry to free
 188
 189 **/
 190 VOID
 191 EFIAPI
 192 Ip4OnFreeFragments (
 193   IN VOID                   *Arg
 194   )
 195 {
 196   Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY *) Arg);
 197 }
 198
 199
 200 /**
 201   Reassemble the IP fragments. If all the fragments of the packet
 202   have been received, it will wrap the packet in a net buffer then
 203   return it to caller. If the packet can't be assembled, NULL is
 204   return.
 205
 206   @param  Table     The assemble table used. New assemble entry will be created
 207                     if the Packet is from a new chain of fragments.
 208   @param  Packet    The fragment to assemble. It might be freed if the fragment
 209                     can't be re-assembled.
 210
 211   @return NULL if the packet can't be reassemble. The point to just assembled
 212           packet if all the fragments of the packet have arrived.
 213
 214 **/
 215 NET_BUF *
 216 Ip4Reassemble (
 217   IN OUT IP4_ASSEMBLE_TABLE     *Table,
 218   IN OUT NET_BUF                *Packet
 219   )
 220 {
 221   IP4_HEAD                  *IpHead;
 222   IP4_CLIP_INFO             *This;
 223   IP4_CLIP_INFO             *Node;
 224   IP4_ASSEMBLE_ENTRY        *Assemble;
 225   LIST_ENTRY                *Head;
 226   LIST_ENTRY                *Prev;
 227   LIST_ENTRY                *Cur;
 228   NET_BUF                   *Fragment;
 229   NET_BUF                   *NewPacket;
 230   INTN                      Index;
 231
 232   IpHead  = Packet->Ip.Ip4;
 233   This    = IP4_GET_CLIP_INFO (Packet);
 234
 235   ASSERT (IpHead != NULL);
 236
 237   //
 238   // First: find the related assemble entry
 239   //
 240   Assemble  = NULL;
 241   Index     = IP4_ASSEMBLE_HASH (IpHead->Dst, IpHead->Src, IpHead->Id, IpHead->Protocol);
 242
 243   NET_LIST_FOR_EACH (Cur, &Table->Bucket[Index]) {
 244     Assemble = NET_LIST_USER_STRUCT (Cur, IP4_ASSEMBLE_ENTRY, Link);
 245
 246     if ((Assemble->Dst == IpHead->Dst) && (Assemble->Src == IpHead->Src) &&
 247         (Assemble->Id == IpHead->Id)   && (Assemble->Protocol == IpHead->Protocol)) {
 248       break;
 249     }
 250   }
 251
 252   //
 253   // Create a new assemble entry if no assemble entry is related to this packet
 254   //
 255   if (Cur == &Table->Bucket[Index]) {
 256     Assemble = Ip4CreateAssembleEntry (
 257                  IpHead->Dst,
 258                  IpHead->Src,
 259                  IpHead->Id,
 260                  IpHead->Protocol
 261                  );
 262
 263     if (Assemble == NULL) {
 264       goto DROP;
 265     }
 266
 267     InsertHeadList (&Table->Bucket[Index], &Assemble->Link);
 268   }
 269   //
 270   // Assemble shouldn't be NULL here
 271   //
 272   ASSERT (Assemble != NULL);
 273
 274   //
 275   // Find the point to insert the packet: before the first
 276   // fragment with THIS.Start < CUR.Start. the previous one
 277   // has PREV.Start <= THIS.Start < CUR.Start.
 278   //
 279   Head = &Assemble->Fragments;
 280
 281   NET_LIST_FOR_EACH (Cur, Head) {
 282     Fragment = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);
 283
 284     if (This->Start < IP4_GET_CLIP_INFO (Fragment)->Start) {
 285       break;
 286     }
 287   }
 288
 289   //
 290   // Check whether the current fragment overlaps with the previous one.
 291   // It holds that: PREV.Start <= THIS.Start < THIS.End. Only need to
 292   // check whether THIS.Start < PREV.End for overlap. If two fragments
 293   // overlaps, trim the overlapped part off THIS fragment.
 294   //
 295   if ((Cur != Head) && ((Prev = Cur->BackLink) != Head)) {
 296     Fragment  = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);
 297     Node      = IP4_GET_CLIP_INFO (Fragment);
 298
 299     if (This->Start < Node->End) {
 300       if (This->End <= Node->End) {
 301         NetbufFree (Packet);
 302         return NULL;
 303       }
 304
 305       Ip4TrimPacket (Packet, Node->End, This->End);
 306     }
 307   }
 308
 309   //
 310   // Insert the fragment into the packet. The fragment may be removed
 311   // from the list by the following checks.
 312   //
 313   NetListInsertBefore (Cur, &Packet->List);
 314
 315   //
 316   // Check the packets after the insert point. It holds that:
 317   // THIS.Start <= NODE.Start < NODE.End. The equality holds
 318   // if PREV and NEXT are continuous. THIS fragment may fill
 319   // several holes. Remove the completely overlapped fragments
 320   //
 321   while (Cur != Head) {
 322     Fragment = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);
 323     Node     = IP4_GET_CLIP_INFO (Fragment);
 324
 325     //
 326     // Remove fragments completely overlapped by this fragment
 327     //
 328     if (Node->End <= This->End) {
 329       Cur = Cur->ForwardLink;
 330
 331       RemoveEntryList (&Fragment->List);
 332       Assemble->CurLen -= Node->Length;
 333
 334       NetbufFree (Fragment);
 335       continue;
 336     }
 337
 338     //
 339     // The conditions are: THIS.Start <= NODE.Start, and THIS.End <
 340     // NODE.End. Two fragments overlaps if NODE.Start < THIS.End.
 341     // If two fragments start at the same offset, remove THIS fragment
 342     // because ((THIS.Start == NODE.Start) && (THIS.End < NODE.End)).
 343     //
 344     if (Node->Start < This->End) {
 345       if (This->Start == Node->Start) {
 346         RemoveEntryList (&Packet->List);
 347         goto DROP;
 348       }
 349
 350       Ip4TrimPacket (Packet, This->Start, Node->Start);
 351     }
 352
 353     break;
 354   }
 355
 356   //
 357   // Update the assemble info: increase the current length. If it is
 358   // the frist fragment, update the packet's IP head and per packet
 359   // info. If it is the last fragment, update the total length.
 360   //
 361   Assemble->CurLen += This->Length;
 362
 363   if (This->Start == 0) {
 364     //
 365     // Once the first fragment is enqueued, it can't be removed
 366     // from the fragment list. So, Assemble->Head always point
 367     // to valid memory area.
 368     //
 369     ASSERT (Assemble->Head == NULL);
 370
 371     Assemble->Head  = IpHead;
 372     Assemble->Info  = IP4_GET_CLIP_INFO (Packet);
 373   }
 374
 375   //
 376   // Don't update the length more than once.
 377   //
 378   if (IP4_LAST_FRAGMENT (IpHead->Fragment) && (Assemble->TotalLen == 0)) {
 379     Assemble->TotalLen = This->End;
 380   }
 381
 382   //
 383   // Deliver the whole packet if all the fragments received.
 384   // All fragments received if:
 385   //  1. received the last one, so, the total length is know
 386   //  2. received all the data. If the last fragment on the
 387   //     queue ends at the total length, all data is received.
 388   //
 389   if ((Assemble->TotalLen != 0) && (Assemble->CurLen >= Assemble->TotalLen)) {
 390
 391     RemoveEntryList (&Assemble->Link);
 392
 393     //
 394     // If the packet is properly formated, the last fragment's End
 395     // equals to the packet's total length. Otherwise, the packet
 396     // is a fake, drop it now.
 397     //
 398     Fragment = NET_LIST_USER_STRUCT (Head->BackLink, NET_BUF, List);
 399
 400     if (IP4_GET_CLIP_INFO (Fragment)->End != Assemble->TotalLen) {
 401       Ip4FreeAssembleEntry (Assemble);
 402       return NULL;
 403     }
 404
 405     //
 406     // Wrap the packet in a net buffer then deliver it up
 407     //
 408     NewPacket = NetbufFromBufList (
 409                   &Assemble->Fragments,
 410                   0,
 411                   0,
 412                   Ip4OnFreeFragments,
 413                   Assemble
 414                   );
 415
 416     if (NewPacket == NULL) {
 417       Ip4FreeAssembleEntry (Assemble);
 418       return NULL;
 419     }
 420
 421     NewPacket->Ip.Ip4 = Assemble->Head;
 422     CopyMem (IP4_GET_CLIP_INFO (NewPacket), Assemble->Info, sizeof (*IP4_GET_CLIP_INFO (NewPacket)));
 423     return NewPacket;
 424   }
 425
 426   return NULL;
 427
 428 DROP:
 429   NetbufFree (Packet);
 430   return NULL;
 431 }
 432
 433 /**
 434   The callback function for the net buffer which wraps the packet processed by
 435   IPsec. It releases the wrap packet and also signals IPsec to free the resources.
 436
 437   @param[in]  Arg       The wrap context
 438
 439 **/
 440 VOID
 441 EFIAPI
 442 Ip4IpSecFree (
 443   IN VOID                   *Arg
 444   )
 445 {
 446   IP4_IPSEC_WRAP            *Wrap;
 447
 448   Wrap = (IP4_IPSEC_WRAP *) Arg;
 449
 450   if (Wrap->IpSecRecycleSignal != NULL) {
 451     gBS->SignalEvent (Wrap->IpSecRecycleSignal);
 452   }
 453
 454   NetbufFree (Wrap->Packet);
 455
 456   FreePool (Wrap);
 457
 458   return;
 459 }
 460
 461 /**
 462   The work function to locate IPsec protocol to process the inbound or
 463   outbound IP packets. The process routine handls the packet with following
 464   actions: bypass the packet, discard the packet, or protect the packet.
 465
 466   @param[in]       IpSb          The IP4 service instance
 467   @param[in]       Head          The The caller supplied IP4 header.
 468   @param[in, out]  Netbuf        The IP4 packet to be processed by IPsec
 469   @param[in]       Options       The caller supplied options
 470   @param[in]       OptionsLen    The length of the option
 471   @param[in]       Direction     The directionality in an SPD entry,
 472                                  EfiIPsecInBound or EfiIPsecOutBound
 473   @param[in]       Context       The token's wrap
 474
 475   @retval EFI_SUCCESS            The IPsec protocol is not available or disabled.
 476   @retval EFI_SUCCESS            The packet was bypassed and all buffers remain the same.
 477   @retval EFI_SUCCESS            The packet was protected.
 478   @retval EFI_ACCESS_DENIED      The packet was discarded.
 479   @retval EFI_OUT_OF_RESOURCES   There is no suffcient resource to complete the operation.
 480   @retval EFI_BUFFER_TOO_SMALL   The number of non-empty block is bigger than the
 481                                  number of input data blocks when build a fragment table.
 482
 483 **/
 484 EFI_STATUS
 485 Ip4IpSecProcessPacket (
 486   IN IP4_SERVICE            *IpSb,
 487   IN IP4_HEAD               *Head,
 488   IN OUT NET_BUF            **Netbuf,
 489   IN UINT8                  *Options,
 490   IN UINT32                 OptionsLen,
 491   IN EFI_IPSEC_TRAFFIC_DIR  Direction,
 492   IN VOID                   *Context
 493   )
 494 {
 495   NET_FRAGMENT              *FragmentTable;
 496   UINT32                    FragmentCount;
 497   EFI_EVENT                 RecycleEvent;
 498   NET_BUF                   *Packet;
 499   IP4_TXTOKEN_WRAP          *TxWrap;
 500   IP4_IPSEC_WRAP            *IpSecWrap;
 501   EFI_STATUS                Status;
 502
 503   Status        = EFI_SUCCESS;
 504   Packet        = *Netbuf;
 505   RecycleEvent  = NULL;
 506   IpSecWrap     = NULL;
 507   FragmentTable = NULL;
 508   TxWrap        = (IP4_TXTOKEN_WRAP *) Context;
 509   FragmentCount = Packet->BlockOpNum;
 510
 511   if (mIpSec == NULL) {
 512     gBS->LocateProtocol (&gEfiIpSecProtocolGuid, NULL, (VOID **) &mIpSec);
 513     if (mIpSec == NULL) {
 514       goto ON_EXIT;
 515     }
 516   }
 517
 518   //
 519   // Check whether the IPsec enable variable is set.
 520   //
 521   if (mIpSec->DisabledFlag) {
 522     //
 523     // If IPsec is disabled, restore the original MTU
 524     //
 525     IpSb->MaxPacketSize = IpSb->OldMaxPacketSize;
 526     goto ON_EXIT;
 527   } else {
 528     //
 529     // If IPsec is enabled, use the MTU which reduce the IPsec header length.
 530     //
 531     IpSb->MaxPacketSize = IpSb->OldMaxPacketSize - IP4_MAX_IPSEC_HEADLEN;
 532   }
 533
 534   //
 535   // Rebuild fragment table from netbuf to ease IPsec process.
 536   //
 537   FragmentTable = AllocateZeroPool (FragmentCount * sizeof (NET_FRAGMENT));
 538
 539   if (FragmentTable == NULL) {
 540     Status = EFI_OUT_OF_RESOURCES;
 541     goto ON_EXIT;
 542   }
 543
 544   Status = NetbufBuildExt (Packet, FragmentTable, &FragmentCount);
 545
 546   if (EFI_ERROR (Status)) {
 547     FreePool (FragmentTable);
 548     goto ON_EXIT;
 549   }
 550
 551   //
 552   // Convert host byte order to network byte order
 553   //
 554   Ip4NtohHead (Head);
 555
 556   Status = mIpSec->Process (
 557                      mIpSec,
 558                      IpSb->Controller,
 559                      IP_VERSION_4,
 560                      (VOID *) Head,
 561                      &Head->Protocol,
 562                      NULL,
 563                      0,
 564                      (EFI_IPSEC_FRAGMENT_DATA **) (&FragmentTable),
 565                      &FragmentCount,
 566                      Direction,
 567                      &RecycleEvent
 568                      );
 569   //
 570   // Convert back to host byte order
 571   //
 572   Ip4NtohHead (Head);
 573
 574   if (EFI_ERROR (Status)) {
 575     goto ON_EXIT;
 576   }
 577
 578   if (Direction == EfiIPsecOutBound && TxWrap != NULL) {
 579
 580     TxWrap->IpSecRecycleSignal = RecycleEvent;
 581     TxWrap->Packet             = NetbufFromExt (
 582                                    FragmentTable,
 583                                    FragmentCount,
 584                                    IP4_MAX_HEADLEN,
 585                                    0,
 586                                    Ip4FreeTxToken,
 587                                    TxWrap
 588                                    );
 589     if (TxWrap->Packet == NULL) {
 590       Status = EFI_OUT_OF_RESOURCES;
 591       goto ON_EXIT;
 592     }
 593
 594     *Netbuf = TxWrap->Packet;
 595
 596   } else {
 597
 598     IpSecWrap = AllocateZeroPool (sizeof (IP4_IPSEC_WRAP));
 599
 600     if (IpSecWrap == NULL) {
 601       goto ON_EXIT;
 602     }
 603
 604     IpSecWrap->IpSecRecycleSignal = RecycleEvent;
 605     IpSecWrap->Packet             = Packet;
 606     Packet                        = NetbufFromExt (
 607                                       FragmentTable,
 608                                       FragmentCount,
 609                                       IP4_MAX_HEADLEN,
 610                                       0,
 611                                       Ip4IpSecFree,
 612                                       IpSecWrap
 613                                       );
 614
 615     if (Packet == NULL) {
 616       Status = EFI_OUT_OF_RESOURCES;
 617       goto ON_EXIT;
 618     }
 619
 620     if (Direction == EfiIPsecInBound) {
 621       Ip4PrependHead (Packet, Head, Options, OptionsLen);
 622       Ip4NtohHead (Packet->Ip.Ip4);
 623       NetbufTrim (Packet, (Head->HeadLen << 2), TRUE);
 624
 625       CopyMem (
 626         IP4_GET_CLIP_INFO (Packet),
 627         IP4_GET_CLIP_INFO (IpSecWrap->Packet),
 628         sizeof (IP4_CLIP_INFO)
 629         );
 630     }
 631
 632     *Netbuf = Packet;
 633   }
 634
 635 ON_EXIT:
 636   return Status;
 637 }
 638
 639 /**
 640   The IP4 input routine. It is called by the IP4_INTERFACE when a
 641   IP4 fragment is received from MNP.
 642
 643   @param[in]  Ip4Instance        The IP4 child that request the receive, most like
 644                                  it is NULL.
 645   @param[in]  Packet             The IP4 packet received.
 646   @param[in]  IoStatus           The return status of receive request.
 647   @param[in]  Flag               The link layer flag for the packet received, such
 648                                  as multicast.
 649   @param[in]  Context            The IP4 service instance that own the MNP.
 650
 651 **/
 652 VOID
 653 Ip4AccpetFrame (
 654   IN IP4_PROTOCOL           *Ip4Instance,
 655   IN NET_BUF                *Packet,
 656   IN EFI_STATUS             IoStatus,
 657   IN UINT32                 Flag,
 658   IN VOID                   *Context
 659   )
 660 {
 661   IP4_SERVICE               *IpSb;
 662   IP4_CLIP_INFO             *Info;
 663   IP4_HEAD                  *Head;
 664   UINT32                    HeadLen;
 665   UINT32                    OptionLen;
 666   UINT32                    TotalLen;
 667   UINT16                    Checksum;
 668   EFI_STATUS                Status;
 669
 670   IpSb = (IP4_SERVICE *) Context;
 671
 672   if (EFI_ERROR (IoStatus) || (IpSb->State == IP4_SERVICE_DESTORY)) {
 673     goto DROP;
 674   }
 675
 676   //
 677   // Check that the IP4 header is correctly formatted
 678   //
 679   if (Packet->TotalSize < IP4_MIN_HEADLEN) {
 680     goto RESTART;
 681   }
 682
 683   Head     = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
 684   HeadLen  = (Head->HeadLen << 2);
 685   TotalLen = NTOHS (Head->TotalLen);
 686
 687   //
 688   // Mnp may deliver frame trailer sequence up, trim it off.
 689   //
 690   if (TotalLen < Packet->TotalSize) {
 691     NetbufTrim (Packet, Packet->TotalSize - TotalLen, FALSE);
 692   }
 693
 694   if ((Head->Ver != 4) || (HeadLen < IP4_MIN_HEADLEN) ||
 695       (TotalLen < HeadLen) || (TotalLen != Packet->TotalSize)) {
 696     goto RESTART;
 697   }
 698
 699   //
 700   // Some OS may send IP packets without checksum.
 701   //
 702   Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Head, HeadLen));
 703
 704   if ((Head->Checksum != 0) && (Checksum != 0)) {
 705     goto RESTART;
 706   }
 707
 708   //
 709   // Convert the IP header to host byte order, then get the per packet info.
 710   //
 711   Packet->Ip.Ip4  = Ip4NtohHead (Head);
 712
 713   Info            = IP4_GET_CLIP_INFO (Packet);
 714   Info->LinkFlag  = Flag;
 715   Info->CastType  = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);
 716   Info->Start     = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;
 717   Info->Length    = Head->TotalLen - HeadLen;
 718   Info->End       = Info->Start + Info->Length;
 719   Info->Status    = EFI_SUCCESS;
 720
 721   //
 722   // The packet is destinated to us if the CastType is non-zero.
 723   //
 724   if ((Info->CastType == 0) || (Info->End > IP4_MAX_PACKET_SIZE)) {
 725     goto RESTART;
 726   }
 727
 728   //
 729   // Validate the options. Don't call the Ip4OptionIsValid if
 730   // there is no option to save some CPU process.
 731   //
 732   OptionLen = HeadLen - IP4_MIN_HEADLEN;
 733
 734   if ((OptionLen > 0) && !Ip4OptionIsValid ((UINT8 *) (Head + 1), OptionLen, TRUE)) {
 735     goto RESTART;
 736   }
 737
 738   //
 739   // Trim the head off, after this point, the packet is headless.
 740   // and Packet->TotalLen == Info->Length.
 741   //
 742   NetbufTrim (Packet, HeadLen, TRUE);
 743
 744   //
 745   // Reassemble the packet if this is a fragment. The packet is a
 746   // fragment if its head has MF (more fragment) set, or it starts
 747   // at non-zero byte.
 748   //
 749   if (((Head->Fragment & IP4_HEAD_MF_MASK) != 0) || (Info->Start != 0)) {
 750     //
 751     // Drop the fragment if DF is set but it is fragmented. Gateway
 752     // need to send a type 4 destination unreache ICMP message here.
 753     //
 754     if ((Head->Fragment & IP4_HEAD_DF_MASK) != 0) {
 755       goto RESTART;
 756     }
 757
 758     //
 759     // The length of all but the last fragments is in the unit of 8 bytes.
 760     //
 761     if (((Head->Fragment & IP4_HEAD_MF_MASK) != 0) && (Info->Length % 8 != 0)) {
 762       goto RESTART;
 763     }
 764
 765     Packet = Ip4Reassemble (&IpSb->Assemble, Packet);
 766
 767     //
 768     // Packet assembly isn't complete, start receive more packet.
 769     //
 770     if (Packet == NULL) {
 771       goto RESTART;
 772     }
 773   }
 774
 775   //
 776   // After trim off, the packet is a esp/ah/udp/tcp/icmp6 net buffer,
 777   // and no need consider any other ahead ext headers.
 778   //
 779   Status = Ip4IpSecProcessPacket (
 780              IpSb,
 781              Head,
 782              &Packet,
 783              NULL,
 784              0,
 785              EfiIPsecInBound,
 786              NULL
 787              );
 788
 789   if (EFI_ERROR(Status)) {
 790     goto RESTART;
 791   }
 792   // Packet may have been changed. Head, HeadLen, TotalLen, and
 793   // info must be reloaded bofore use. The ownership of the packet
 794   // is transfered to the packet process logic.
 795   //
 796   Head  = Packet->Ip.Ip4;
 797   IP4_GET_CLIP_INFO (Packet)->Status = EFI_SUCCESS;
 798
 799   switch (Head->Protocol) {
 800   case EFI_IP_PROTO_ICMP:
 801     Ip4IcmpHandle (IpSb, Head, Packet);
 802     break;
 803
 804   case IP4_PROTO_IGMP:
 805     Ip4IgmpHandle (IpSb, Head, Packet);
 806     break;
 807
 808   default:
 809     Ip4Demultiplex (IpSb, Head, Packet);
 810   }
 811
 812   Packet = NULL;
 813
 814   //
 815   // Dispatch the DPCs queued by the NotifyFunction of the rx token's events
 816   // which are signaled with received data.
 817   //
 818   DispatchDpc ();
 819
 820 RESTART:
 821   Ip4ReceiveFrame (IpSb->DefaultInterface, NULL, Ip4AccpetFrame, IpSb);
 822
 823 DROP:
 824   if (Packet != NULL) {
 825     NetbufFree (Packet);
 826   }
 827
 828   return ;
 829 }
 830
 831
 832 /**
 833   Check whether this IP child accepts the packet.
 834
 835   @param[in]  IpInstance             The IP child to check
 836   @param[in]  Head                   The IP header of the packet
 837   @param[in]  Packet                 The data of the packet
 838
 839   @retval TRUE   If the child wants to receive the packet.
 840   @retval FALSE  Otherwise.
 841
 842 **/
 843 BOOLEAN
 844 Ip4InstanceFrameAcceptable (
 845   IN IP4_PROTOCOL           *IpInstance,
 846   IN IP4_HEAD               *Head,
 847   IN NET_BUF                *Packet
 848   )
 849 {
 850   IP4_ICMP_ERROR_HEAD       Icmp;
 851   EFI_IP4_CONFIG_DATA       *Config;
 852   IP4_CLIP_INFO             *Info;
 853   UINT16                    Proto;
 854   UINT32                    Index;
 855
 856   Config = &IpInstance->ConfigData;
 857
 858   //
 859   // Dirty trick for the Tiano UEFI network stack implmentation. If
 860   // ReceiveTimeout == -1, the receive of the packet for this instance
 861   // is disabled. The UEFI spec don't have such capability. We add
 862   // this to improve the performance because IP will make a copy of
 863   // the received packet for each accepting instance. Some IP instances
 864   // used by UDP/TCP only send packets, they don't wants to receive.
 865   //
 866   if (Config->ReceiveTimeout == (UINT32)(-1)) {
 867     return FALSE;
 868   }
 869
 870   if (Config->AcceptPromiscuous) {
 871     return TRUE;
 872   }
 873
 874   //
 875   // Use protocol from the IP header embedded in the ICMP error
 876   // message to filter, instead of ICMP itself. ICMP handle will
 877   // call Ip4Demultiplex to deliver ICMP errors.
 878   //
 879   Proto = Head->Protocol;
 880
 881   if ((Proto == EFI_IP_PROTO_ICMP) && (!Config->AcceptAnyProtocol) && (Proto != Config->DefaultProtocol)) {
 882     NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *) &Icmp.Head);
 883
 884     if (mIcmpClass[Icmp.Head.Type].IcmpClass == ICMP_ERROR_MESSAGE) {
 885       if (!Config->AcceptIcmpErrors) {
 886         return FALSE;
 887       }
 888
 889       NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *) &Icmp);
 890       Proto = Icmp.IpHead.Protocol;
 891     }
 892   }
 893
 894   //
 895   // Match the protocol
 896   //
 897   if (!Config->AcceptAnyProtocol && (Proto != Config->DefaultProtocol)) {
 898     return FALSE;
 899   }
 900
 901   //
 902   // Check for broadcast, the caller has computed the packet's
 903   // cast type for this child's interface.
 904   //
 905   Info = IP4_GET_CLIP_INFO (Packet);
 906
 907   if (IP4_IS_BROADCAST (Info->CastType)) {
 908     return Config->AcceptBroadcast;
 909   }
 910
 911   //
 912   // If it is a multicast packet, check whether we are in the group.
 913   //
 914   if (Info->CastType == IP4_MULTICAST) {
 915     //
 916     // Receive the multicast if the instance wants to receive all packets.
 917     //
 918     if (!IpInstance->ConfigData.UseDefaultAddress && (IpInstance->Interface->Ip == 0)) {
 919       return TRUE;
 920     }
 921
 922     for (Index = 0; Index < IpInstance->GroupCount; Index++) {
 923       if (IpInstance->Groups[Index] == HTONL (Head->Dst)) {
 924         break;
 925       }
 926     }
 927
 928     return (BOOLEAN)(Index < IpInstance->GroupCount);
 929   }
 930
 931   return TRUE;
 932 }
 933
 934
 935 /**
 936   Enqueue a shared copy of the packet to the IP4 child if the
 937   packet is acceptable to it. Here the data of the packet is
 938   shared, but the net buffer isn't.
 939
 940   @param[in]  IpInstance             The IP4 child to enqueue the packet to
 941   @param[in]  Head                   The IP header of the received packet
 942   @param[in]  Packet                 The data of the received packet
 943
 944   @retval EFI_NOT_STARTED        The IP child hasn't been configured.
 945   @retval EFI_INVALID_PARAMETER  The child doesn't want to receive the packet
 946   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resource
 947   @retval EFI_SUCCESS            A shared copy the packet is enqueued to the child.
 948
 949 **/
 950 EFI_STATUS
 951 Ip4InstanceEnquePacket (
 952   IN IP4_PROTOCOL           *IpInstance,
 953   IN IP4_HEAD               *Head,
 954   IN NET_BUF                *Packet
 955   )
 956 {
 957   IP4_CLIP_INFO             *Info;
 958   NET_BUF                   *Clone;
 959
 960   //
 961   // Check whether the packet is acceptable to this instance.
 962   //
 963   if (IpInstance->State != IP4_STATE_CONFIGED) {
 964     return EFI_NOT_STARTED;
 965   }
 966
 967   if (!Ip4InstanceFrameAcceptable (IpInstance, Head, Packet)) {
 968     return EFI_INVALID_PARAMETER;
 969   }
 970
 971   //
 972   // Enque a shared copy of the packet.
 973   //
 974   Clone = NetbufClone (Packet);
 975
 976   if (Clone == NULL) {
 977     return EFI_OUT_OF_RESOURCES;
 978   }
 979
 980   //
 981   // Set the receive time out for the assembled packet. If it expires,
 982   // packet will be removed from the queue.
 983   //
 984   Info        = IP4_GET_CLIP_INFO (Clone);
 985   Info->Life  = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);
 986
 987   InsertTailList (&IpInstance->Received, &Clone->List);
 988   return EFI_SUCCESS;
 989 }
 990
 991
 992 /**
 993   The signal handle of IP4's recycle event. It is called back
 994   when the upper layer release the packet.
 995
 996   @param  Event              The IP4's recycle event.
 997   @param  Context            The context of the handle, which is a
 998                              IP4_RXDATA_WRAP
 999
1000 **/
1001 VOID
1002 EFIAPI
1003 Ip4OnRecyclePacket (
1004   IN EFI_EVENT              Event,
1005   IN VOID                   *Context
1006   )
1007 {
1008   IP4_RXDATA_WRAP           *Wrap;
1009
1010   Wrap = (IP4_RXDATA_WRAP *) Context;
1011
1012   EfiAcquireLockOrFail (&Wrap->IpInstance->RecycleLock);
1013   RemoveEntryList (&Wrap->Link);
1014   EfiReleaseLock (&Wrap->IpInstance->RecycleLock);
1015
1016   ASSERT (!NET_BUF_SHARED (Wrap->Packet));
1017   NetbufFree (Wrap->Packet);
1018
1019   gBS->CloseEvent (Wrap->RxData.RecycleSignal);
1020   FreePool (Wrap);
1021 }
1022
1023
1024 /**
1025   Wrap the received packet to a IP4_RXDATA_WRAP, which will be
1026   delivered to the upper layer. Each IP4 child that accepts the
1027   packet will get a not-shared copy of the packet which is wrapped
1028   in the IP4_RXDATA_WRAP. The IP4_RXDATA_WRAP->RxData is passed
1029   to the upper layer. Upper layer will signal the recycle event in
1030   it when it is done with the packet.
1031
1032   @param[in]  IpInstance             The IP4 child to receive the packet
1033   @param[in]  Packet                 The packet to deliver up.
1034
1035   @retval Wrap              if warp the packet succeed.
1036   @retval NULL              failed to wrap the packet .
1037
1038 **/
1039 IP4_RXDATA_WRAP *
1040 Ip4WrapRxData (
1041   IN IP4_PROTOCOL           *IpInstance,
1042   IN NET_BUF                *Packet
1043   )
1044 {
1045   IP4_RXDATA_WRAP           *Wrap;
1046   EFI_IP4_RECEIVE_DATA      *RxData;
1047   EFI_STATUS                Status;
1048
1049   Wrap = AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet->BlockOpNum));
1050
1051   if (Wrap == NULL) {
1052     return NULL;
1053   }
1054
1055   InitializeListHead (&Wrap->Link);
1056
1057   Wrap->IpInstance  = IpInstance;
1058   Wrap->Packet      = Packet;
1059   RxData            = &Wrap->RxData;
1060
1061   ZeroMem (&RxData->TimeStamp, sizeof (EFI_TIME));
1062
1063   Status = gBS->CreateEvent (
1064                   EVT_NOTIFY_SIGNAL,
1065                   TPL_NOTIFY,
1066                   Ip4OnRecyclePacket,
1067                   Wrap,
1068                   &RxData->RecycleSignal
1069                   );
1070
1071   if (EFI_ERROR (Status)) {
1072     FreePool (Wrap);
1073     return NULL;
1074   }
1075
1076   ASSERT (Packet->Ip.Ip4 != NULL);
1077
1078   //
1079   // The application expects a network byte order header.
1080   //
1081   RxData->HeaderLength  = (Packet->Ip.Ip4->HeadLen << 2);
1082   RxData->Header        = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);
1083
1084   RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;
1085   RxData->Options       = NULL;
1086
1087   if (RxData->OptionsLength != 0) {
1088     RxData->Options = (VOID *) (RxData->Header + 1);
1089   }
1090
1091   RxData->DataLength  = Packet->TotalSize;
1092
1093   //
1094   // Build the fragment table to be delivered up.
1095   //
1096   RxData->FragmentCount = Packet->BlockOpNum;
1097   NetbufBuildExt (Packet, (NET_FRAGMENT *) RxData->FragmentTable, &RxData->FragmentCount);
1098
1099   return Wrap;
1100 }
1101
1102
1103 /**
1104   Deliver the received packets to upper layer if there are both received
1105   requests and enqueued packets. If the enqueued packet is shared, it will
1106   duplicate it to a non-shared packet, release the shared packet, then
1107   deliver the non-shared packet up.
1108
1109   @param[in]  IpInstance         The IP child to deliver the packet up.
1110
1111   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources to deliver the
1112                                  packets.
1113   @retval EFI_SUCCESS            All the enqueued packets that can be delivered
1114                                  are delivered up.
1115
1116 **/
1117 EFI_STATUS
1118 Ip4InstanceDeliverPacket (
1119   IN IP4_PROTOCOL           *IpInstance
1120   )
1121 {
1122   EFI_IP4_COMPLETION_TOKEN  *Token;
1123   IP4_RXDATA_WRAP           *Wrap;
1124   NET_BUF                   *Packet;
1125   NET_BUF                   *Dup;
1126   UINT8                     *Head;
1127
1128   //
1129   // Deliver a packet if there are both a packet and a receive token.
1130   //
1131   while (!IsListEmpty (&IpInstance->Received) &&
1132          !NetMapIsEmpty (&IpInstance->RxTokens)) {
1133
1134     Packet = NET_LIST_HEAD (&IpInstance->Received, NET_BUF, List);
1135
1136     if (!NET_BUF_SHARED (Packet)) {
1137       //
1138       // If this is the only instance that wants the packet, wrap it up.
1139       //
1140       Wrap = Ip4WrapRxData (IpInstance, Packet);
1141
1142       if (Wrap == NULL) {
1143         return EFI_OUT_OF_RESOURCES;
1144       }
1145
1146       RemoveEntryList (&Packet->List);
1147
1148     } else {
1149       //
1150       // Create a duplicated packet if this packet is shared
1151       //
1152       Dup = NetbufDuplicate (Packet, NULL, IP4_MAX_HEADLEN);
1153
1154       if (Dup == NULL) {
1155         return EFI_OUT_OF_RESOURCES;
1156       }
1157
1158       //
1159       // Copy the IP head over. The packet to deliver up is
1160       // headless. Trim the head off after copy. The IP head
1161       // may be not continuous before the data.
1162       //
1163       Head    = NetbufAllocSpace (Dup, IP4_MAX_HEADLEN, NET_BUF_HEAD);
1164       Dup->Ip.Ip4 = (IP4_HEAD *) Head;
1165
1166       CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);
1167       NetbufTrim (Dup, IP4_MAX_HEADLEN, TRUE);
1168
1169       Wrap = Ip4WrapRxData (IpInstance, Dup);
1170
1171       if (Wrap == NULL) {
1172         NetbufFree (Dup);
1173         return EFI_OUT_OF_RESOURCES;
1174       }
1175
1176       RemoveEntryList (&Packet->List);
1177       NetbufFree (Packet);
1178
1179       Packet = Dup;
1180     }
1181
1182     //
1183     // Insert it into the delivered packet, then get a user's
1184     // receive token, pass the wrapped packet up.
1185     //
1186     EfiAcquireLockOrFail (&IpInstance->RecycleLock);
1187     InsertHeadList (&IpInstance->Delivered, &Wrap->Link);
1188     EfiReleaseLock (&IpInstance->RecycleLock);
1189
1190     Token                = NetMapRemoveHead (&IpInstance->RxTokens, NULL);
1191     Token->Status        = IP4_GET_CLIP_INFO (Packet)->Status;
1192     Token->Packet.RxData = &Wrap->RxData;
1193
1194     gBS->SignalEvent (Token->Event);
1195   }
1196
1197   return EFI_SUCCESS;
1198 }
1199
1200
1201 /**
1202   Enqueue a received packet to all the IP children that share
1203   the same interface.
1204
1205   @param[in]  IpSb                   The IP4 service instance that receive the packet
1206   @param[in]  Head                   The header of the received packet
1207   @param[in]  Packet                 The data of the received packet
1208   @param[in]  IpIf                   The interface to enqueue the packet to
1209
1210   @return The number of the IP4 children that accepts the packet
1211
1212 **/
1213 INTN
1214 Ip4InterfaceEnquePacket (
1215   IN IP4_SERVICE            *IpSb,
1216   IN IP4_HEAD               *Head,
1217   IN NET_BUF                *Packet,
1218   IN IP4_INTERFACE          *IpIf
1219   )
1220 {
1221   IP4_PROTOCOL              *IpInstance;
1222   IP4_CLIP_INFO             *Info;
1223   LIST_ENTRY                *Entry;
1224   INTN                      Enqueued;
1225   INTN                      LocalType;
1226   INTN                      SavedType;
1227
1228   //
1229   // First, check that the packet is acceptable to this interface
1230   // and find the local cast type for the interface. A packet sent
1231   // to say 192.168.1.1 should NOT be delliever to 10.0.0.1 unless
1232   // promiscuous receiving.
1233   //
1234   LocalType = 0;
1235   Info      = IP4_GET_CLIP_INFO (Packet);
1236
1237   if ((Info->CastType == IP4_MULTICAST) || (Info->CastType == IP4_LOCAL_BROADCAST)) {
1238     //
1239     // If the CastType is multicast, don't need to filter against
1240     // the group address here, Ip4InstanceFrameAcceptable will do
1241     // that later.
1242     //
1243     LocalType = Info->CastType;
1244
1245   } else {
1246     //
1247     // Check the destination againist local IP. If the station
1248     // address is 0.0.0.0, it means receiving all the IP destined
1249     // to local non-zero IP. Otherwise, it is necessary to compare
1250     // the destination to the interface's IP address.
1251     //
1252     if (IpIf->Ip == IP4_ALLZERO_ADDRESS) {
1253       LocalType = IP4_LOCAL_HOST;
1254
1255     } else {
1256       LocalType = Ip4GetNetCast (Head->Dst, IpIf);
1257
1258       if ((LocalType == 0) && IpIf->PromiscRecv) {
1259         LocalType = IP4_PROMISCUOUS;
1260       }
1261     }
1262   }
1263
1264   if (LocalType == 0) {
1265     return 0;
1266   }
1267
1268   //
1269   // Iterate through the ip instances on the interface, enqueue
1270   // the packet if filter passed. Save the original cast type,
1271   // and pass the local cast type to the IP children on the
1272   // interface. The global cast type will be restored later.
1273   //
1274   SavedType       = Info->CastType;
1275   Info->CastType  = LocalType;
1276
1277   Enqueued        = 0;
1278
1279   NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
1280     IpInstance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
1281     NET_CHECK_SIGNATURE (IpInstance, IP4_PROTOCOL_SIGNATURE);
1282
1283     if (Ip4InstanceEnquePacket (IpInstance, Head, Packet) == EFI_SUCCESS) {
1284       Enqueued++;
1285     }
1286   }
1287
1288   Info->CastType = SavedType;
1289   return Enqueued;
1290 }
1291
1292
1293 /**
1294   Deliver the packet for each IP4 child on the interface.
1295
1296   @param[in]  IpSb               The IP4 service instance that received the packet
1297   @param[in]  IpIf               The IP4 interface to deliver the packet.
1298
1299   @retval EFI_SUCCESS            It always returns EFI_SUCCESS now
1300
1301 **/
1302 EFI_STATUS
1303 Ip4InterfaceDeliverPacket (
1304   IN IP4_SERVICE            *IpSb,
1305   IN IP4_INTERFACE          *IpIf
1306   )
1307 {
1308   IP4_PROTOCOL              *Ip4Instance;
1309   LIST_ENTRY                *Entry;
1310
1311   NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
1312     Ip4Instance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
1313     Ip4InstanceDeliverPacket (Ip4Instance);
1314   }
1315
1316   return EFI_SUCCESS;
1317 }
1318
1319
1320 /**
1321   Demultiple the packet. the packet delivery is processed in two
1322   passes. The first pass will enque a shared copy of the packet
1323   to each IP4 child that accepts the packet. The second pass will
1324   deliver a non-shared copy of the packet to each IP4 child that
1325   has pending receive requests. Data is copied if more than one
1326   child wants to consume the packet because each IP child needs
1327   its own copy of the packet to make changes.
1328
1329   @param[in]  IpSb                   The IP4 service instance that received the packet
1330   @param[in]  Head                   The header of the received packet
1331   @param[in]  Packet                 The data of the received packet
1332
1333   @retval EFI_NOT_FOUND          No IP child accepts the packet
1334   @retval EFI_SUCCESS            The packet is enqueued or delivered to some IP
1335                                  children.
1336
1337 **/
1338 EFI_STATUS
1339 Ip4Demultiplex (
1340   IN IP4_SERVICE            *IpSb,
1341   IN IP4_HEAD               *Head,
1342   IN NET_BUF                *Packet
1343   )
1344 {
1345   LIST_ENTRY                *Entry;
1346   IP4_INTERFACE             *IpIf;
1347   INTN                      Enqueued;
1348
1349   //
1350   // Two pass delivery: first, enque a shared copy of the packet
1351   // to each instance that accept the packet.
1352   //
1353   Enqueued = 0;
1354
1355   NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
1356     IpIf = NET_LIST_USER_STRUCT (Entry, IP4_INTERFACE, Link);
1357
1358     if (IpIf->Configured) {
1359       Enqueued += Ip4InterfaceEnquePacket (IpSb, Head, Packet, IpIf);
1360     }
1361   }
1362
1363   //
1364   // Second: deliver a duplicate of the packet to each instance.
1365   // Release the local reference first, so that the last instance
1366   // getting the packet will not copy the data.
1367   //
1368   NetbufFree (Packet);
1369
1370   if (Enqueued == 0) {
1371     return EFI_NOT_FOUND;
1372   }
1373
1374   NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
1375     IpIf = NET_LIST_USER_STRUCT (Entry, IP4_INTERFACE, Link);
1376
1377     if (IpIf->Configured) {
1378       Ip4InterfaceDeliverPacket (IpSb, IpIf);
1379     }
1380   }
1381
1382   return EFI_SUCCESS;
1383 }
1384
1385
1386 /**
1387   Timeout the fragment and enqueued packets.
1388
1389   @param[in]  IpSb                   The IP4 service instance to timeout
1390
1391 **/
1392 VOID
1393 Ip4PacketTimerTicking (
1394   IN IP4_SERVICE            *IpSb
1395   )
1396 {
1397   LIST_ENTRY                *InstanceEntry;
1398   LIST_ENTRY                *Entry;
1399   LIST_ENTRY                *Next;
1400   IP4_PROTOCOL              *IpInstance;
1401   IP4_ASSEMBLE_ENTRY        *Assemble;
1402   NET_BUF                   *Packet;
1403   IP4_CLIP_INFO             *Info;
1404   UINT32                    Index;
1405
1406   //
1407   // First, time out the fragments. The packet's life is counting down
1408   // once the first-arrived fragment was received.
1409   //
1410   for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
1411     NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->Assemble.Bucket[Index]) {
1412       Assemble = NET_LIST_USER_STRUCT (Entry, IP4_ASSEMBLE_ENTRY, Link);
1413
1414       if ((Assemble->Life > 0) && (--Assemble->Life == 0)) {
1415         RemoveEntryList (Entry);
1416         Ip4FreeAssembleEntry (Assemble);
1417       }
1418     }
1419   }
1420
1421   NET_LIST_FOR_EACH (InstanceEntry, &IpSb->Children) {
1422     IpInstance = NET_LIST_USER_STRUCT (InstanceEntry, IP4_PROTOCOL, Link);
1423
1424     //
1425     // Second, time out the assembled packets enqueued on each IP child.
1426     //
1427     NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpInstance->Received) {
1428       Packet = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
1429       Info   = IP4_GET_CLIP_INFO (Packet);
1430
1431       if ((Info->Life > 0) && (--Info->Life == 0)) {
1432         RemoveEntryList (Entry);
1433         NetbufFree (Packet);
1434       }
1435     }
1436
1437     //
1438     // Third: time out the transmitted packets.
1439     //
1440     NetMapIterate (&IpInstance->TxTokens, Ip4SentPacketTicking, NULL);
1441   }
1442 }