MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.c

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