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, out]  Head          The The caller supplied IP4 header.
 468   @param[in, out]  Netbuf        The IP4 packet to be processed by IPsec.
 469   @param[in, out]  Options       The caller supplied options.
 470   @param[in, out]  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 OUT IP4_HEAD               **Head,
 488   IN OUT NET_BUF                **Netbuf,
 489   IN OUT UINT8                  **Options,
 490   IN OUT UINT32                 *OptionsLen,
 491   IN     EFI_IPSEC_TRAFFIC_DIR  Direction,
 492   IN     VOID                   *Context
 493   )
 494 {
 495   NET_FRAGMENT              *FragmentTable;
 496   NET_FRAGMENT              *OriginalFragmentTable;
 497   UINT32                    FragmentCount;
 498   UINT32                    OriginalFragmentCount;
 499   EFI_EVENT                 RecycleEvent;
 500   NET_BUF                   *Packet;
 501   IP4_TXTOKEN_WRAP          *TxWrap;
 502   IP4_IPSEC_WRAP            *IpSecWrap;
 503   EFI_STATUS                Status;
 504   IP4_HEAD                  ZeroHead;
 505
 506   Status        = EFI_SUCCESS;
 507   Packet        = *Netbuf;
 508   RecycleEvent  = NULL;
 509   IpSecWrap     = NULL;
 510   FragmentTable = NULL;
 511   TxWrap        = (IP4_TXTOKEN_WRAP *) Context;
 512   FragmentCount = Packet->BlockOpNum;
 513
 514   ZeroMem (&ZeroHead, sizeof (IP4_HEAD));
 515
 516   if (mIpSec == NULL) {
 517     gBS->LocateProtocol (&gEfiIpSec2ProtocolGuid, NULL, (VOID **) &mIpSec);
 518     if (mIpSec == NULL) {
 519       goto ON_EXIT;
 520     }
 521   }
 522
 523   //
 524   // Check whether the IPsec enable variable is set.
 525   //
 526   if (mIpSec->DisabledFlag) {
 527     //
 528     // If IPsec is disabled, restore the original MTU
 529     //
 530     IpSb->MaxPacketSize = IpSb->OldMaxPacketSize;
 531     goto ON_EXIT;
 532   } else {
 533     //
 534     // If IPsec is enabled, use the MTU which reduce the IPsec header length.
 535     //
 536     IpSb->MaxPacketSize = IpSb->OldMaxPacketSize - IP4_MAX_IPSEC_HEADLEN;
 537   }
 538
 539   //
 540   // Rebuild fragment table from netbuf to ease IPsec process.
 541   //
 542   FragmentTable = AllocateZeroPool (FragmentCount * sizeof (NET_FRAGMENT));
 543
 544   if (FragmentTable == NULL) {
 545     Status = EFI_OUT_OF_RESOURCES;
 546     goto ON_EXIT;
 547   }
 548
 549   Status = NetbufBuildExt (Packet, FragmentTable, &FragmentCount);
 550
 551   //
 552   // Record the original FragmentTable and count.
 553   //
 554   OriginalFragmentTable = FragmentTable;
 555   OriginalFragmentCount = FragmentCount;
 556
 557   if (EFI_ERROR (Status)) {
 558     FreePool (FragmentTable);
 559     goto ON_EXIT;
 560   }
 561
 562   //
 563   // Convert host byte order to network byte order
 564   //
 565   Ip4NtohHead (*Head);
 566
 567   Status = mIpSec->ProcessExt (
 568                      mIpSec,
 569                      IpSb->Controller,
 570                      IP_VERSION_4,
 571                      (VOID *) (*Head),
 572                      &(*Head)->Protocol,
 573                      (VOID **) Options,
 574                      OptionsLen,
 575                      (EFI_IPSEC_FRAGMENT_DATA **) (&FragmentTable),
 576                      &FragmentCount,
 577                      Direction,
 578                      &RecycleEvent
 579                      );
 580   //
 581   // Convert back to host byte order
 582   //
 583   Ip4NtohHead (*Head);
 584
 585   if (EFI_ERROR (Status)) {
 586     goto ON_EXIT;
 587   }
 588
 589   if (OriginalFragmentTable == FragmentTable && OriginalFragmentCount == FragmentCount) {
 590     goto ON_EXIT;
 591   }
 592
 593   if (Direction == EfiIPsecOutBound && TxWrap != NULL) {
 594
 595     TxWrap->IpSecRecycleSignal = RecycleEvent;
 596     TxWrap->Packet             = NetbufFromExt (
 597                                    FragmentTable,
 598                                    FragmentCount,
 599                                    IP4_MAX_HEADLEN,
 600                                    0,
 601                                    Ip4FreeTxToken,
 602                                    TxWrap
 603                                    );
 604     if (TxWrap->Packet == NULL) {
 605       Status = EFI_OUT_OF_RESOURCES;
 606       goto ON_EXIT;
 607     }
 608
 609     //
 610     // Free orginal Netbuf.
 611     //
 612     NetIpSecNetbufFree (*Netbuf);
 613     *Netbuf = TxWrap->Packet;
 614
 615   } else {
 616
 617     IpSecWrap = AllocateZeroPool (sizeof (IP4_IPSEC_WRAP));
 618
 619     if (IpSecWrap == NULL) {
 620       goto ON_EXIT;
 621     }
 622
 623     IpSecWrap->IpSecRecycleSignal = RecycleEvent;
 624     IpSecWrap->Packet             = Packet;
 625     Packet                        = NetbufFromExt (
 626                                       FragmentTable,
 627                                       FragmentCount,
 628                                       IP4_MAX_HEADLEN,
 629                                       0,
 630                                       Ip4IpSecFree,
 631                                       IpSecWrap
 632                                       );
 633
 634     if (Packet == NULL) {
 635       Status = EFI_OUT_OF_RESOURCES;
 636       goto ON_EXIT;
 637     }
 638
 639     if (Direction == EfiIPsecInBound && 0 != CompareMem (*Head, &ZeroHead, sizeof (IP4_HEAD))) {
 640       Ip4PrependHead (Packet, *Head, *Options, *OptionsLen);
 641       Ip4NtohHead (Packet->Ip.Ip4);
 642       NetbufTrim (Packet, ((*Head)->HeadLen << 2), TRUE);
 643
 644       CopyMem (
 645         IP4_GET_CLIP_INFO (Packet),
 646         IP4_GET_CLIP_INFO (IpSecWrap->Packet),
 647         sizeof (IP4_CLIP_INFO)
 648         );
 649     }
 650     *Netbuf = Packet;
 651   }
 652
 653 ON_EXIT:
 654   return Status;
 655 }
 656
 657 /**
 658   Pre-process the IPv4 packet. First validates the IPv4 packet, and
 659   then reassembles packet if it is necessary.
 660
 661   @param[in]       IpSb            Pointer to IP4_SERVICE.
 662   @param[in, out]  Packet          Pointer to the Packet to be processed.
 663   @param[in]       Head            Pointer to the IP4_HEAD.
 664   @param[in]       Option          Pointer to a buffer which contains the IPv4 option.
 665   @param[in]       OptionLen       The length of Option in bytes.
 666   @param[in]       Flag            The link layer flag for the packet received, such
 667                                    as multicast.
 668
 669   @retval     EFI_SEUCCESS               The recieved packet is in well form.
 670   @retval     EFI_INVAILD_PARAMETER      The recieved packet is malformed.
 671
 672 **/
 673 EFI_STATUS
 674 Ip4PreProcessPacket (
 675   IN     IP4_SERVICE    *IpSb,
 676   IN OUT NET_BUF        **Packet,
 677   IN     IP4_HEAD       *Head,
 678   IN     UINT8          *Option,
 679   IN     UINT32         OptionLen,
 680   IN     UINT32         Flag
 681   )
 682 {
 683   IP4_CLIP_INFO             *Info;
 684   UINT32                    HeadLen;
 685   UINT32                    TotalLen;
 686   UINT16                    Checksum;
 687
 688   //
 689   // Check that the IP4 header is correctly formatted
 690   //
 691   if ((*Packet)->TotalSize < IP4_MIN_HEADLEN) {
 692     return EFI_INVALID_PARAMETER;
 693   }
 694
 695   HeadLen  = (Head->HeadLen << 2);
 696   TotalLen = NTOHS (Head->TotalLen);
 697
 698   //
 699   // Mnp may deliver frame trailer sequence up, trim it off.
 700   //
 701   if (TotalLen < (*Packet)->TotalSize) {
 702     NetbufTrim (*Packet, (*Packet)->TotalSize - TotalLen, FALSE);
 703   }
 704
 705   if ((Head->Ver != 4) || (HeadLen < IP4_MIN_HEADLEN) ||
 706       (TotalLen < HeadLen) || (TotalLen != (*Packet)->TotalSize)) {
 707     return EFI_INVALID_PARAMETER;
 708   }
 709
 710   //
 711   // Some OS may send IP packets without checksum.
 712   //
 713   Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Head, HeadLen));
 714
 715   if ((Head->Checksum != 0) && (Checksum != 0)) {
 716     return EFI_INVALID_PARAMETER;
 717   }
 718
 719   //
 720   // Convert the IP header to host byte order, then get the per packet info.
 721   //
 722   (*Packet)->Ip.Ip4  = Ip4NtohHead (Head);
 723
 724   Info            = IP4_GET_CLIP_INFO (*Packet);
 725   Info->LinkFlag  = Flag;
 726   Info->CastType  = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);
 727   Info->Start     = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;
 728   Info->Length    = Head->TotalLen - HeadLen;
 729   Info->End       = Info->Start + Info->Length;
 730   Info->Status    = EFI_SUCCESS;
 731
 732   //
 733   // The packet is destinated to us if the CastType is non-zero.
 734   //
 735   if ((Info->CastType == 0) || (Info->End > IP4_MAX_PACKET_SIZE)) {
 736     return EFI_INVALID_PARAMETER;
 737   }
 738
 739   //
 740   // Validate the options. Don't call the Ip4OptionIsValid if
 741   // there is no option to save some CPU process.
 742   //
 743
 744   if ((OptionLen > 0) && !Ip4OptionIsValid (Option, OptionLen, TRUE)) {
 745     return EFI_INVALID_PARAMETER;
 746   }
 747
 748   //
 749   // Trim the head off, after this point, the packet is headless.
 750   // and Packet->TotalLen == Info->Length.
 751   //
 752   NetbufTrim (*Packet, HeadLen, TRUE);
 753
 754   //
 755   // Reassemble the packet if this is a fragment. The packet is a
 756   // fragment if its head has MF (more fragment) set, or it starts
 757   // at non-zero byte.
 758   //
 759   if (((Head->Fragment & IP4_HEAD_MF_MASK) != 0) || (Info->Start != 0)) {
 760     //
 761     // Drop the fragment if DF is set but it is fragmented. Gateway
 762     // need to send a type 4 destination unreache ICMP message here.
 763     //
 764     if ((Head->Fragment & IP4_HEAD_DF_MASK) != 0) {
 765       return EFI_INVALID_PARAMETER;
 766     }
 767
 768     //
 769     // The length of all but the last fragments is in the unit of 8 bytes.
 770     //
 771     if (((Head->Fragment & IP4_HEAD_MF_MASK) != 0) && (Info->Length % 8 != 0)) {
 772       return EFI_INVALID_PARAMETER;
 773     }
 774
 775     *Packet = Ip4Reassemble (&IpSb->Assemble, *Packet);
 776
 777     //
 778     // Packet assembly isn't complete, start receive more packet.
 779     //
 780     if (*Packet == NULL) {
 781       return EFI_INVALID_PARAMETER;
 782     }
 783   }
 784
 785   return EFI_SUCCESS;
 786 }
 787
 788 /**
 789   The IP4 input routine. It is called by the IP4_INTERFACE when a
 790   IP4 fragment is received from MNP.
 791
 792   @param[in]  Ip4Instance        The IP4 child that request the receive, most like
 793                                  it is NULL.
 794   @param[in]  Packet             The IP4 packet received.
 795   @param[in]  IoStatus           The return status of receive request.
 796   @param[in]  Flag               The link layer flag for the packet received, such
 797                                  as multicast.
 798   @param[in]  Context            The IP4 service instance that own the MNP.
 799
 800 **/
 801 VOID
 802 Ip4AccpetFrame (
 803   IN IP4_PROTOCOL           *Ip4Instance,
 804   IN NET_BUF                *Packet,
 805   IN EFI_STATUS             IoStatus,
 806   IN UINT32                 Flag,
 807   IN VOID                   *Context
 808   )
 809 {
 810   IP4_SERVICE               *IpSb;
 811   IP4_HEAD                  *Head;
 812   EFI_STATUS                Status;
 813   IP4_HEAD                  ZeroHead;
 814   UINT8                     *Option;
 815   UINT32                    OptionLen;
 816
 817   IpSb   = (IP4_SERVICE *) Context;
 818   Option = NULL;
 819
 820   if (EFI_ERROR (IoStatus) || (IpSb->State == IP4_SERVICE_DESTORY)) {
 821     goto DROP;
 822   }
 823
 824   Head      = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
 825   OptionLen = (Head->HeadLen << 2) - IP4_MIN_HEADLEN;
 826   if (OptionLen > 0) {
 827     Option = (UINT8 *) (Head + 1);
 828   }
 829
 830   //
 831   // Validate packet format and reassemble packet if it is necessary.
 832   //
 833   Status = Ip4PreProcessPacket (
 834              IpSb,
 835              &Packet,
 836              Head,
 837              Option,
 838              OptionLen,
 839              Flag
 840              );
 841
 842   if (EFI_ERROR (Status)) {
 843     goto RESTART;
 844   }
 845
 846   //
 847   // After trim off, the packet is a esp/ah/udp/tcp/icmp6 net buffer,
 848   // and no need consider any other ahead ext headers.
 849   //
 850   Status = Ip4IpSecProcessPacket (
 851              IpSb,
 852              &Head,
 853              &Packet,
 854              &Option,
 855              &OptionLen,
 856              EfiIPsecInBound,
 857              NULL
 858              );
 859
 860   if (EFI_ERROR (Status)) {
 861     goto RESTART;
 862   }
 863
 864   //
 865   // If the packet is protected by tunnel mode, parse the inner Ip Packet.
 866   //
 867   ZeroMem (&ZeroHead, sizeof (IP4_HEAD));
 868   if (0 == CompareMem (Head, &ZeroHead, sizeof (IP4_HEAD))) {
 869   // Packet may have been changed. Head, HeadLen, TotalLen, and
 870   // info must be reloaded bofore use. The ownership of the packet
 871   // is transfered to the packet process logic.
 872   //
 873     Head = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
 874     Status = Ip4PreProcessPacket (
 875                IpSb,
 876                &Packet,
 877                Head,
 878                Option,
 879                OptionLen,
 880                Flag
 881                );
 882     if (EFI_ERROR (Status)) {
 883       goto RESTART;
 884     }
 885   }
 886
 887   ASSERT (Packet != NULL);
 888   Head  = Packet->Ip.Ip4;
 889   IP4_GET_CLIP_INFO (Packet)->Status = EFI_SUCCESS;
 890
 891   switch (Head->Protocol) {
 892   case EFI_IP_PROTO_ICMP:
 893     Ip4IcmpHandle (IpSb, Head, Packet);
 894     break;
 895
 896   case IP4_PROTO_IGMP:
 897     Ip4IgmpHandle (IpSb, Head, Packet);
 898     break;
 899
 900   default:
 901     Ip4Demultiplex (IpSb, Head, Packet);
 902   }
 903
 904   Packet = NULL;
 905
 906   //
 907   // Dispatch the DPCs queued by the NotifyFunction of the rx token's events
 908   // which are signaled with received data.
 909   //
 910   DispatchDpc ();
 911
 912 RESTART:
 913   Ip4ReceiveFrame (IpSb->DefaultInterface, NULL, Ip4AccpetFrame, IpSb);
 914
 915 DROP:
 916   if (Packet != NULL) {
 917     NetbufFree (Packet);
 918   }
 919
 920   return ;
 921 }
 922
 923
 924 /**
 925   Check whether this IP child accepts the packet.
 926
 927   @param[in]  IpInstance             The IP child to check
 928   @param[in]  Head                   The IP header of the packet
 929   @param[in]  Packet                 The data of the packet
 930
 931   @retval TRUE   If the child wants to receive the packet.
 932   @retval FALSE  Otherwise.
 933
 934 **/
 935 BOOLEAN
 936 Ip4InstanceFrameAcceptable (
 937   IN IP4_PROTOCOL           *IpInstance,
 938   IN IP4_HEAD               *Head,
 939   IN NET_BUF                *Packet
 940   )
 941 {
 942   IP4_ICMP_ERROR_HEAD       Icmp;
 943   EFI_IP4_CONFIG_DATA       *Config;
 944   IP4_CLIP_INFO             *Info;
 945   UINT16                    Proto;
 946   UINT32                    Index;
 947
 948   Config = &IpInstance->ConfigData;
 949
 950   //
 951   // Dirty trick for the Tiano UEFI network stack implmentation. If
 952   // ReceiveTimeout == -1, the receive of the packet for this instance
 953   // is disabled. The UEFI spec don't have such capability. We add
 954   // this to improve the performance because IP will make a copy of
 955   // the received packet for each accepting instance. Some IP instances
 956   // used by UDP/TCP only send packets, they don't wants to receive.
 957   //
 958   if (Config->ReceiveTimeout == (UINT32)(-1)) {
 959     return FALSE;
 960   }
 961
 962   if (Config->AcceptPromiscuous) {
 963     return TRUE;
 964   }
 965
 966   //
 967   // Use protocol from the IP header embedded in the ICMP error
 968   // message to filter, instead of ICMP itself. ICMP handle will
 969   // call Ip4Demultiplex to deliver ICMP errors.
 970   //
 971   Proto = Head->Protocol;
 972
 973   if ((Proto == EFI_IP_PROTO_ICMP) && (!Config->AcceptAnyProtocol) && (Proto != Config->DefaultProtocol)) {
 974     NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *) &Icmp.Head);
 975
 976     if (mIcmpClass[Icmp.Head.Type].IcmpClass == ICMP_ERROR_MESSAGE) {
 977       if (!Config->AcceptIcmpErrors) {
 978         return FALSE;
 979       }
 980
 981       NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *) &Icmp);
 982       Proto = Icmp.IpHead.Protocol;
 983     }
 984   }
 985
 986   //
 987   // Match the protocol
 988   //
 989   if (!Config->AcceptAnyProtocol && (Proto != Config->DefaultProtocol)) {
 990     return FALSE;
 991   }
 992
 993   //
 994   // Check for broadcast, the caller has computed the packet's
 995   // cast type for this child's interface.
 996   //
 997   Info = IP4_GET_CLIP_INFO (Packet);
 998
 999   if (IP4_IS_BROADCAST (Info->CastType)) {
1000     return Config->AcceptBroadcast;
1001   }
1002
1003   //
1004   // If it is a multicast packet, check whether we are in the group.
1005   //
1006   if (Info->CastType == IP4_MULTICAST) {
1007     //
1008     // Receive the multicast if the instance wants to receive all packets.
1009     //
1010     if (!IpInstance->ConfigData.UseDefaultAddress && (IpInstance->Interface->Ip == 0)) {
1011       return TRUE;
1012     }
1013
1014     for (Index = 0; Index < IpInstance->GroupCount; Index++) {
1015       if (IpInstance->Groups[Index] == HTONL (Head->Dst)) {
1016         break;
1017       }
1018     }
1019
1020     return (BOOLEAN)(Index < IpInstance->GroupCount);
1021   }
1022
1023   return TRUE;
1024 }
1025
1026
1027 /**
1028   Enqueue a shared copy of the packet to the IP4 child if the
1029   packet is acceptable to it. Here the data of the packet is
1030   shared, but the net buffer isn't.
1031
1032   @param[in]  IpInstance             The IP4 child to enqueue the packet to
1033   @param[in]  Head                   The IP header of the received packet
1034   @param[in]  Packet                 The data of the received packet
1035
1036   @retval EFI_NOT_STARTED        The IP child hasn't been configured.
1037   @retval EFI_INVALID_PARAMETER  The child doesn't want to receive the packet
1038   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resource
1039   @retval EFI_SUCCESS            A shared copy the packet is enqueued to the child.
1040
1041 **/
1042 EFI_STATUS
1043 Ip4InstanceEnquePacket (
1044   IN IP4_PROTOCOL           *IpInstance,
1045   IN IP4_HEAD               *Head,
1046   IN NET_BUF                *Packet
1047   )
1048 {
1049   IP4_CLIP_INFO             *Info;
1050   NET_BUF                   *Clone;
1051
1052   //
1053   // Check whether the packet is acceptable to this instance.
1054   //
1055   if (IpInstance->State != IP4_STATE_CONFIGED) {
1056     return EFI_NOT_STARTED;
1057   }
1058
1059   if (!Ip4InstanceFrameAcceptable (IpInstance, Head, Packet)) {
1060     return EFI_INVALID_PARAMETER;
1061   }
1062
1063   //
1064   // Enque a shared copy of the packet.
1065   //
1066   Clone = NetbufClone (Packet);
1067
1068   if (Clone == NULL) {
1069     return EFI_OUT_OF_RESOURCES;
1070   }
1071
1072   //
1073   // Set the receive time out for the assembled packet. If it expires,
1074   // packet will be removed from the queue.
1075   //
1076   Info        = IP4_GET_CLIP_INFO (Clone);
1077   Info->Life  = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);
1078
1079   InsertTailList (&IpInstance->Received, &Clone->List);
1080   return EFI_SUCCESS;
1081 }
1082
1083
1084 /**
1085   The signal handle of IP4's recycle event. It is called back
1086   when the upper layer release the packet.
1087
1088   @param  Event              The IP4's recycle event.
1089   @param  Context            The context of the handle, which is a
1090                              IP4_RXDATA_WRAP
1091
1092 **/
1093 VOID
1094 EFIAPI
1095 Ip4OnRecyclePacket (
1096   IN EFI_EVENT              Event,
1097   IN VOID                   *Context
1098   )
1099 {
1100   IP4_RXDATA_WRAP           *Wrap;
1101
1102   Wrap = (IP4_RXDATA_WRAP *) Context;
1103
1104   EfiAcquireLockOrFail (&Wrap->IpInstance->RecycleLock);
1105   RemoveEntryList (&Wrap->Link);
1106   EfiReleaseLock (&Wrap->IpInstance->RecycleLock);
1107
1108   ASSERT (!NET_BUF_SHARED (Wrap->Packet));
1109   NetbufFree (Wrap->Packet);
1110
1111   gBS->CloseEvent (Wrap->RxData.RecycleSignal);
1112   FreePool (Wrap);
1113 }
1114
1115
1116 /**
1117   Wrap the received packet to a IP4_RXDATA_WRAP, which will be
1118   delivered to the upper layer. Each IP4 child that accepts the
1119   packet will get a not-shared copy of the packet which is wrapped
1120   in the IP4_RXDATA_WRAP. The IP4_RXDATA_WRAP->RxData is passed
1121   to the upper layer. Upper layer will signal the recycle event in
1122   it when it is done with the packet.
1123
1124   @param[in]  IpInstance             The IP4 child to receive the packet
1125   @param[in]  Packet                 The packet to deliver up.
1126
1127   @retval Wrap              if warp the packet succeed.
1128   @retval NULL              failed to wrap the packet .
1129
1130 **/
1131 IP4_RXDATA_WRAP *
1132 Ip4WrapRxData (
1133   IN IP4_PROTOCOL           *IpInstance,
1134   IN NET_BUF                *Packet
1135   )
1136 {
1137   IP4_RXDATA_WRAP           *Wrap;
1138   EFI_IP4_RECEIVE_DATA      *RxData;
1139   EFI_STATUS                Status;
1140
1141   Wrap = AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet->BlockOpNum));
1142
1143   if (Wrap == NULL) {
1144     return NULL;
1145   }
1146
1147   InitializeListHead (&Wrap->Link);
1148
1149   Wrap->IpInstance  = IpInstance;
1150   Wrap->Packet      = Packet;
1151   RxData            = &Wrap->RxData;
1152
1153   ZeroMem (&RxData->TimeStamp, sizeof (EFI_TIME));
1154
1155   Status = gBS->CreateEvent (
1156                   EVT_NOTIFY_SIGNAL,
1157                   TPL_NOTIFY,
1158                   Ip4OnRecyclePacket,
1159                   Wrap,
1160                   &RxData->RecycleSignal
1161                   );
1162
1163   if (EFI_ERROR (Status)) {
1164     FreePool (Wrap);
1165     return NULL;
1166   }
1167
1168   ASSERT (Packet->Ip.Ip4 != NULL);
1169
1170   //
1171   // The application expects a network byte order header.
1172   //
1173   RxData->HeaderLength  = (Packet->Ip.Ip4->HeadLen << 2);
1174   RxData->Header        = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);
1175
1176   RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;
1177   RxData->Options       = NULL;
1178
1179   if (RxData->OptionsLength != 0) {
1180     RxData->Options = (VOID *) (RxData->Header + 1);
1181   }
1182
1183   RxData->DataLength  = Packet->TotalSize;
1184
1185   //
1186   // Build the fragment table to be delivered up.
1187   //
1188   RxData->FragmentCount = Packet->BlockOpNum;
1189   NetbufBuildExt (Packet, (NET_FRAGMENT *) RxData->FragmentTable, &RxData->FragmentCount);
1190
1191   return Wrap;
1192 }
1193
1194
1195 /**
1196   Deliver the received packets to upper layer if there are both received
1197   requests and enqueued packets. If the enqueued packet is shared, it will
1198   duplicate it to a non-shared packet, release the shared packet, then
1199   deliver the non-shared packet up.
1200
1201   @param[in]  IpInstance         The IP child to deliver the packet up.
1202
1203   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources to deliver the
1204                                  packets.
1205   @retval EFI_SUCCESS            All the enqueued packets that can be delivered
1206                                  are delivered up.
1207
1208 **/
1209 EFI_STATUS
1210 Ip4InstanceDeliverPacket (
1211   IN IP4_PROTOCOL           *IpInstance
1212   )
1213 {
1214   EFI_IP4_COMPLETION_TOKEN  *Token;
1215   IP4_RXDATA_WRAP           *Wrap;
1216   NET_BUF                   *Packet;
1217   NET_BUF                   *Dup;
1218   UINT8                     *Head;
1219
1220   //
1221   // Deliver a packet if there are both a packet and a receive token.
1222   //
1223   while (!IsListEmpty (&IpInstance->Received) &&
1224          !NetMapIsEmpty (&IpInstance->RxTokens)) {
1225
1226     Packet = NET_LIST_HEAD (&IpInstance->Received, NET_BUF, List);
1227
1228     if (!NET_BUF_SHARED (Packet)) {
1229       //
1230       // If this is the only instance that wants the packet, wrap it up.
1231       //
1232       Wrap = Ip4WrapRxData (IpInstance, Packet);
1233
1234       if (Wrap == NULL) {
1235         return EFI_OUT_OF_RESOURCES;
1236       }
1237
1238       RemoveEntryList (&Packet->List);
1239
1240     } else {
1241       //
1242       // Create a duplicated packet if this packet is shared
1243       //
1244       Dup = NetbufDuplicate (Packet, NULL, IP4_MAX_HEADLEN);
1245
1246       if (Dup == NULL) {
1247         return EFI_OUT_OF_RESOURCES;
1248       }
1249
1250       //
1251       // Copy the IP head over. The packet to deliver up is
1252       // headless. Trim the head off after copy. The IP head
1253       // may be not continuous before the data.
1254       //
1255       Head    = NetbufAllocSpace (Dup, IP4_MAX_HEADLEN, NET_BUF_HEAD);
1256       Dup->Ip.Ip4 = (IP4_HEAD *) Head;
1257
1258       CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);
1259       NetbufTrim (Dup, IP4_MAX_HEADLEN, TRUE);
1260
1261       Wrap = Ip4WrapRxData (IpInstance, Dup);
1262
1263       if (Wrap == NULL) {
1264         NetbufFree (Dup);
1265         return EFI_OUT_OF_RESOURCES;
1266       }
1267
1268       RemoveEntryList (&Packet->List);
1269       NetbufFree (Packet);
1270
1271       Packet = Dup;
1272     }
1273
1274     //
1275     // Insert it into the delivered packet, then get a user's
1276     // receive token, pass the wrapped packet up.
1277     //
1278     EfiAcquireLockOrFail (&IpInstance->RecycleLock);
1279     InsertHeadList (&IpInstance->Delivered, &Wrap->Link);
1280     EfiReleaseLock (&IpInstance->RecycleLock);
1281
1282     Token                = NetMapRemoveHead (&IpInstance->RxTokens, NULL);
1283     Token->Status        = IP4_GET_CLIP_INFO (Packet)->Status;
1284     Token->Packet.RxData = &Wrap->RxData;
1285
1286     gBS->SignalEvent (Token->Event);
1287   }
1288
1289   return EFI_SUCCESS;
1290 }
1291
1292
1293 /**
1294   Enqueue a received packet to all the IP children that share
1295   the same interface.
1296
1297   @param[in]  IpSb                   The IP4 service instance that receive the packet
1298   @param[in]  Head                   The header of the received packet
1299   @param[in]  Packet                 The data of the received packet
1300   @param[in]  IpIf                   The interface to enqueue the packet to
1301
1302   @return The number of the IP4 children that accepts the packet
1303
1304 **/
1305 INTN
1306 Ip4InterfaceEnquePacket (
1307   IN IP4_SERVICE            *IpSb,
1308   IN IP4_HEAD               *Head,
1309   IN NET_BUF                *Packet,
1310   IN IP4_INTERFACE          *IpIf
1311   )
1312 {
1313   IP4_PROTOCOL              *IpInstance;
1314   IP4_CLIP_INFO             *Info;
1315   LIST_ENTRY                *Entry;
1316   INTN                      Enqueued;
1317   INTN                      LocalType;
1318   INTN                      SavedType;
1319
1320   //
1321   // First, check that the packet is acceptable to this interface
1322   // and find the local cast type for the interface. A packet sent
1323   // to say 192.168.1.1 should NOT be delliever to 10.0.0.1 unless
1324   // promiscuous receiving.
1325   //
1326   LocalType = 0;
1327   Info      = IP4_GET_CLIP_INFO (Packet);
1328
1329   if ((Info->CastType == IP4_MULTICAST) || (Info->CastType == IP4_LOCAL_BROADCAST)) {
1330     //
1331     // If the CastType is multicast, don't need to filter against
1332     // the group address here, Ip4InstanceFrameAcceptable will do
1333     // that later.
1334     //
1335     LocalType = Info->CastType;
1336
1337   } else {
1338     //
1339     // Check the destination againist local IP. If the station
1340     // address is 0.0.0.0, it means receiving all the IP destined
1341     // to local non-zero IP. Otherwise, it is necessary to compare
1342     // the destination to the interface's IP address.
1343     //
1344     if (IpIf->Ip == IP4_ALLZERO_ADDRESS) {
1345       LocalType = IP4_LOCAL_HOST;
1346
1347     } else {
1348       LocalType = Ip4GetNetCast (Head->Dst, IpIf);
1349
1350       if ((LocalType == 0) && IpIf->PromiscRecv) {
1351         LocalType = IP4_PROMISCUOUS;
1352       }
1353     }
1354   }
1355
1356   if (LocalType == 0) {
1357     return 0;
1358   }
1359
1360   //
1361   // Iterate through the ip instances on the interface, enqueue
1362   // the packet if filter passed. Save the original cast type,
1363   // and pass the local cast type to the IP children on the
1364   // interface. The global cast type will be restored later.
1365   //
1366   SavedType       = Info->CastType;
1367   Info->CastType  = LocalType;
1368
1369   Enqueued        = 0;
1370
1371   NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
1372     IpInstance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
1373     NET_CHECK_SIGNATURE (IpInstance, IP4_PROTOCOL_SIGNATURE);
1374
1375     if (Ip4InstanceEnquePacket (IpInstance, Head, Packet) == EFI_SUCCESS) {
1376       Enqueued++;
1377     }
1378   }
1379
1380   Info->CastType = SavedType;
1381   return Enqueued;
1382 }
1383
1384
1385 /**
1386   Deliver the packet for each IP4 child on the interface.
1387
1388   @param[in]  IpSb               The IP4 service instance that received the packet
1389   @param[in]  IpIf               The IP4 interface to deliver the packet.
1390
1391   @retval EFI_SUCCESS            It always returns EFI_SUCCESS now
1392
1393 **/
1394 EFI_STATUS
1395 Ip4InterfaceDeliverPacket (
1396   IN IP4_SERVICE            *IpSb,
1397   IN IP4_INTERFACE          *IpIf
1398   )
1399 {
1400   IP4_PROTOCOL              *Ip4Instance;
1401   LIST_ENTRY                *Entry;
1402
1403   NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
1404     Ip4Instance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);
1405     Ip4InstanceDeliverPacket (Ip4Instance);
1406   }
1407
1408   return EFI_SUCCESS;
1409 }
1410
1411
1412 /**
1413   Demultiple the packet. the packet delivery is processed in two
1414   passes. The first pass will enque a shared copy of the packet
1415   to each IP4 child that accepts the packet. The second pass will
1416   deliver a non-shared copy of the packet to each IP4 child that
1417   has pending receive requests. Data is copied if more than one
1418   child wants to consume the packet because each IP child needs
1419   its own copy of the packet to make changes.
1420
1421   @param[in]  IpSb                   The IP4 service instance that received the packet
1422   @param[in]  Head                   The header of the received packet
1423   @param[in]  Packet                 The data of the received packet
1424
1425   @retval EFI_NOT_FOUND          No IP child accepts the packet
1426   @retval EFI_SUCCESS            The packet is enqueued or delivered to some IP
1427                                  children.
1428
1429 **/
1430 EFI_STATUS
1431 Ip4Demultiplex (
1432   IN IP4_SERVICE            *IpSb,
1433   IN IP4_HEAD               *Head,
1434   IN NET_BUF                *Packet
1435   )
1436 {
1437   LIST_ENTRY                *Entry;
1438   IP4_INTERFACE             *IpIf;
1439   INTN                      Enqueued;
1440
1441   //
1442   // Two pass delivery: first, enque a shared copy of the packet
1443   // to each instance that accept the packet.
1444   //
1445   Enqueued = 0;
1446
1447   NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
1448     IpIf = NET_LIST_USER_STRUCT (Entry, IP4_INTERFACE, Link);
1449
1450     if (IpIf->Configured) {
1451       Enqueued += Ip4InterfaceEnquePacket (IpSb, Head, Packet, IpIf);
1452     }
1453   }
1454
1455   //
1456   // Second: deliver a duplicate of the packet to each instance.
1457   // Release the local reference first, so that the last instance
1458   // getting the packet will not copy the data.
1459   //
1460   NetbufFree (Packet);
1461
1462   if (Enqueued == 0) {
1463     return EFI_NOT_FOUND;
1464   }
1465
1466   NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
1467     IpIf = NET_LIST_USER_STRUCT (Entry, IP4_INTERFACE, Link);
1468
1469     if (IpIf->Configured) {
1470       Ip4InterfaceDeliverPacket (IpSb, IpIf);
1471     }
1472   }
1473
1474   return EFI_SUCCESS;
1475 }
1476
1477
1478 /**
1479   Timeout the fragment and enqueued packets.
1480
1481   @param[in]  IpSb                   The IP4 service instance to timeout
1482
1483 **/
1484 VOID
1485 Ip4PacketTimerTicking (
1486   IN IP4_SERVICE            *IpSb
1487   )
1488 {
1489   LIST_ENTRY                *InstanceEntry;
1490   LIST_ENTRY                *Entry;
1491   LIST_ENTRY                *Next;
1492   IP4_PROTOCOL              *IpInstance;
1493   IP4_ASSEMBLE_ENTRY        *Assemble;
1494   NET_BUF                   *Packet;
1495   IP4_CLIP_INFO             *Info;
1496   UINT32                    Index;
1497
1498   //
1499   // First, time out the fragments. The packet's life is counting down
1500   // once the first-arrived fragment was received.
1501   //
1502   for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
1503     NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->Assemble.Bucket[Index]) {
1504       Assemble = NET_LIST_USER_STRUCT (Entry, IP4_ASSEMBLE_ENTRY, Link);
1505
1506       if ((Assemble->Life > 0) && (--Assemble->Life == 0)) {
1507         RemoveEntryList (Entry);
1508         Ip4FreeAssembleEntry (Assemble);
1509       }
1510     }
1511   }
1512
1513   NET_LIST_FOR_EACH (InstanceEntry, &IpSb->Children) {
1514     IpInstance = NET_LIST_USER_STRUCT (InstanceEntry, IP4_PROTOCOL, Link);
1515
1516     //
1517     // Second, time out the assembled packets enqueued on each IP child.
1518     //
1519     NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpInstance->Received) {
1520       Packet = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
1521       Info   = IP4_GET_CLIP_INFO (Packet);
1522
1523       if ((Info->Life > 0) && (--Info->Life == 0)) {
1524         RemoveEntryList (Entry);
1525         NetbufFree (Packet);
1526       }
1527     }
1528
1529     //
1530     // Third: time out the transmitted packets.
1531     //
1532     NetMapIterate (&IpInstance->TxTokens, Ip4SentPacketTicking, NULL);
1533   }
1534 }