VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Ip4Dxe/Ip4Input.c

    r85718 r99404  
    1010
    1111#include "Ip4Impl.h"
    12 
    1312
    1413/**
    … …  
    2827IP4_ASSEMBLE_ENTRY *
    2928Ip4CreateAssembleEntry (
    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;
     29  IN IP4_ADDR  Dst,
     30  IN IP4_ADDR  Src,
     31  IN UINT16    Id,
     32  IN UINT8     Protocol
     33  )
     34{
     35  IP4_ASSEMBLE_ENTRY  *Assemble;
    3836
    3937  Assemble = AllocatePool (sizeof (IP4_ASSEMBLE_ENTRY));
    … …  
    5957}
    6058
    61 
    6259/**
    6360  Release all the fragments of a packet, then free the assemble entry.
    … …  
    6865VOID
    6966Ip4FreeAssembleEntry (
    70   IN IP4_ASSEMBLE_ENTRY     *Assemble
    71   )
    72 {
    73   LIST_ENTRY                *Entry;
    74   LIST_ENTRY                *Next;
    75   NET_BUF                   *Fragment;
     67  IN IP4_ASSEMBLE_ENTRY  *Assemble
     68  )
     69{
     70  LIST_ENTRY  *Entry;
     71  LIST_ENTRY  *Next;
     72  NET_BUF     *Fragment;
    7673
    7774  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Assemble->Fragments) {
    … …  
    8582}
    8683
    87 
    8884/**
    8985  Initialize an already allocated assemble table. This is generally
    … …  
    9591VOID
    9692Ip4InitAssembleTable (
    97   IN OUT IP4_ASSEMBLE_TABLE     *Table
    98   )
    99 {
    100   UINT32                    Index;
     93  IN OUT IP4_ASSEMBLE_TABLE  *Table
     94  )
     95{
     96  UINT32  Index;
    10197
    10298  for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
    … …  
    105101}
    106102
    107 
    108103/**
    109104  Clean up the assemble table: remove all the fragments
    … …  
    115110VOID
    116111Ip4CleanAssembleTable (
    117   IN IP4_ASSEMBLE_TABLE     *Table
    118   )
    119 {
    120   LIST_ENTRY                *Entry;
    121   LIST_ENTRY                *Next;
    122   IP4_ASSEMBLE_ENTRY        *Assemble;
    123   UINT32                    Index;
     112  IN IP4_ASSEMBLE_TABLE  *Table
     113  )
     114{
     115  LIST_ENTRY          *Entry;
     116  LIST_ENTRY          *Next;
     117  IP4_ASSEMBLE_ENTRY  *Assemble;
     118  UINT32              Index;
    124119
    125120  for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {
    … …  
    133128}
    134129
    135 
    136130/**
    137131  Trim the packet to fit in [Start, End), and update the per
    … …  
    145139VOID
    146140Ip4TrimPacket (
    147   IN OUT NET_BUF                *Packet,
    148   IN     INTN                   Start,
    149   IN     INTN                   End
    150   )
    151 {
    152   IP4_CLIP_INFO             *Info;
    153   INTN                      Len;
     141  IN OUT NET_BUF  *Packet,
     142  IN     INTN     Start,
     143  IN     INTN     End
     144  )
     145{
     146  IP4_CLIP_INFO  *Info;
     147  INTN           Len;
    154148
    155149  Info = IP4_GET_CLIP_INFO (Packet);
    … …  
    158152  ASSERT ((Info->Start < End) && (Start < Info->End));
    159153
    160    if (Info->Start < Start) {
     154  if (Info->Start < Start) {
    161155    Len = Start - Info->Start;
    162156
    163     NetbufTrim (Packet, (UINT32) Len, NET_BUF_HEAD);
     157    NetbufTrim (Packet, (UINT32)Len, NET_BUF_HEAD);
    164158    Info->Start   = Start;
    165159    Info->Length -= Len;
    … …  
    169163    Len = End - Info->End;
    170164
    171     NetbufTrim (Packet, (UINT32) Len, NET_BUF_TAIL);
     165    NetbufTrim (Packet, (UINT32)Len, NET_BUF_TAIL);
    172166    Info->End     = End;
    173167    Info->Length -= Len;
    174168  }
    175169}
    176 
    177170
    178171/**
    … …  
    187180EFIAPI
    188181Ip4OnFreeFragments (
    189   IN VOID                   *Arg
    190   )
    191 {
    192   Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY *) Arg);
    193 }
    194 
     182  IN VOID  *Arg
     183  )
     184{
     185  Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY *)Arg);
     186}
    195187
    196188/**
    … …  
    211203NET_BUF *
    212204Ip4Reassemble (
    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);
     205  IN OUT IP4_ASSEMBLE_TABLE  *Table,
     206  IN OUT NET_BUF             *Packet
     207  )
     208{
     209  IP4_HEAD            *IpHead;
     210  IP4_CLIP_INFO       *This;
     211  IP4_CLIP_INFO       *Node;
     212  IP4_ASSEMBLE_ENTRY  *Assemble;
     213  LIST_ENTRY          *Head;
     214  LIST_ENTRY          *Prev;
     215  LIST_ENTRY          *Cur;
     216  NET_BUF             *Fragment;
     217  NET_BUF             *NewPacket;
     218  INTN                Index;
     219
     220  IpHead = Packet->Ip.Ip4;
     221  This   = IP4_GET_CLIP_INFO (Packet);
    230222
    231223  ASSERT (IpHead != NULL);
    … …  
    234226  // First: find the related assemble entry
    235227  //
    236   Assemble  = NULL;
    237   Index     = IP4_ASSEMBLE_HASH (IpHead->Dst, IpHead->Src, IpHead->Id, IpHead->Protocol);
     228  Assemble = NULL;
     229  Index    = IP4_ASSEMBLE_HASH (IpHead->Dst, IpHead->Src, IpHead->Id, IpHead->Protocol);
    238230
    239231  NET_LIST_FOR_EACH (Cur, &Table->Bucket[Index]) {
    … …  
    241233
    242234    if ((Assemble->Dst == IpHead->Dst) && (Assemble->Src == IpHead->Src) &&
    243         (Assemble->Id == IpHead->Id)   && (Assemble->Protocol == IpHead->Protocol)) {
     235        (Assemble->Id == IpHead->Id)   && (Assemble->Protocol == IpHead->Protocol))
     236    {
    244237      break;
    245238    }
    … …  
    263256    InsertHeadList (&Table->Bucket[Index], &Assemble->Link);
    264257  }
     258
    265259  //
    266260  // Assemble shouldn't be NULL here
    … …  
    290284  //
    291285  if ((Prev = Cur->BackLink) != Head) {
    292     Fragment  = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);
    293     Node      = IP4_GET_CLIP_INFO (Fragment);
     286    Fragment = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);
     287    Node     = IP4_GET_CLIP_INFO (Fragment);
    294288
    295289    if (This->Start < Node->End) {
    … …  
    365359    ASSERT (Assemble->Head == NULL);
    366360
    367     Assemble->Head  = IpHead;
    368     Assemble->Info  = IP4_GET_CLIP_INFO (Packet);
     361    Assemble->Head = IpHead;
     362    Assemble->Info = IP4_GET_CLIP_INFO (Packet);
    369363  }
    370364
    … …  
    384378  //
    385379  if ((Assemble->TotalLen != 0) && (Assemble->CurLen >= Assemble->TotalLen)) {
    386 
    387380    RemoveEntryList (&Assemble->Link);
    388381
    … …  
    445438EFIAPI
    446439Ip4IpSecFree (
    447   IN VOID                   *Arg
    448   )
    449 {
    450   IP4_IPSEC_WRAP            *Wrap;
    451 
    452   Wrap = (IP4_IPSEC_WRAP *) Arg;
     440  IN VOID  *Arg
     441  )
     442{
     443  IP4_IPSEC_WRAP  *Wrap;
     444
     445  Wrap = (IP4_IPSEC_WRAP *)Arg;
    453446
    454447  if (Wrap->IpSecRecycleSignal != NULL) {
    … …  
    497490  )
    498491{
    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;
     492  NET_FRAGMENT      *FragmentTable;
     493  NET_FRAGMENT      *OriginalFragmentTable;
     494  UINT32            FragmentCount;
     495  UINT32            OriginalFragmentCount;
     496  EFI_EVENT         RecycleEvent;
     497  NET_BUF           *Packet;
     498  IP4_TXTOKEN_WRAP  *TxWrap;
     499  IP4_IPSEC_WRAP    *IpSecWrap;
     500  EFI_STATUS        Status;
     501  IP4_HEAD          ZeroHead;
     502
     503  Status = EFI_SUCCESS;
    511504
    512505  if (!mIpSec2Installed) {
    513506    goto ON_EXIT;
    514507  }
     508
    515509  ASSERT (mIpSec != NULL);
    516510
    … …  
    519513  IpSecWrap     = NULL;
    520514  FragmentTable = NULL;
    521   TxWrap        = (IP4_TXTOKEN_WRAP *) Context;
     515  TxWrap        = (IP4_TXTOKEN_WRAP *)Context;
    522516  FragmentCount = Packet->BlockOpNum;
    523517
    … …  
    572566                     IpSb->Controller,
    573567                     IP_VERSION_4,
    574                      (VOID *) (*Head),
     568                     (VOID *)(*Head),
    575569                     &(*Head)->Protocol,
    576                      (VOID **) Options,
     570                     (VOID **)Options,
    577571                     OptionsLen,
    578                      (EFI_IPSEC_FRAGMENT_DATA **) (&FragmentTable),
     572                     (EFI_IPSEC_FRAGMENT_DATA **)(&FragmentTable),
    579573                     &FragmentCount,
    580574                     Direction,
    … …  
    591585  }
    592586
    593   if (OriginalFragmentTable == FragmentTable && OriginalFragmentCount == FragmentCount) {
     587  if ((OriginalFragmentTable == FragmentTable) && (OriginalFragmentCount == FragmentCount)) {
    594588    //
    595589    // For ByPass Packet
    … …  
    604598  }
    605599
    606   if (Direction == EfiIPsecOutBound && TxWrap != NULL) {
    607 
     600  if ((Direction == EfiIPsecOutBound) && (TxWrap != NULL)) {
    608601    TxWrap->IpSecRecycleSignal = RecycleEvent;
    609602    TxWrap->Packet             = NetbufFromExt (
    … …  
    621614      //
    622615      TxWrap->Packet = *Netbuf;
    623       Status = EFI_OUT_OF_RESOURCES;
     616      Status         = EFI_OUT_OF_RESOURCES;
    624617      goto ON_EXIT;
    625618    }
    … …  
    630623    NetIpSecNetbufFree (*Netbuf);
    631624    *Netbuf = TxWrap->Packet;
    632 
    633625  } else {
    634 
    635626    IpSecWrap = AllocateZeroPool (sizeof (IP4_IPSEC_WRAP));
    636627
    … …  
    660651    }
    661652
    662     if (Direction == EfiIPsecInBound && 0 != CompareMem (*Head, &ZeroHead, sizeof (IP4_HEAD))) {
     653    if ((Direction == EfiIPsecInBound) && (0 != CompareMem (*Head, &ZeroHead, sizeof (IP4_HEAD)))) {
    663654      Ip4PrependHead (Packet, *Head, *Options, *OptionsLen);
    664655      Ip4NtohHead (Packet->Ip.Ip4);
    … …  
    671662        );
    672663    }
     664
    673665    *Netbuf = Packet;
    674666  }
    … …  
    696688EFI_STATUS
    697689Ip4PreProcessPacket (
    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;
     690  IN     IP4_SERVICE  *IpSb,
     691  IN OUT NET_BUF      **Packet,
     692  IN     IP4_HEAD     *Head,
     693  IN     UINT8        *Option,
     694  IN     UINT32       OptionLen,
     695  IN     UINT32       Flag
     696  )
     697{
     698  IP4_CLIP_INFO  *Info;
     699  UINT32         HeadLen;
     700  UINT32         TotalLen;
     701  UINT16         Checksum;
    710702
    711703  //
    … …  
    723715
    724716  if ((Head->Ver != 4) || (HeadLen < IP4_MIN_HEADLEN) ||
    725       (TotalLen < HeadLen) || (TotalLen != (*Packet)->TotalSize)) {
     717      (TotalLen < HeadLen) || (TotalLen != (*Packet)->TotalSize))
     718  {
    726719    return EFI_INVALID_PARAMETER;
    727720  }
    … …  
    730723  // Some OS may send IP packets without checksum.
    731724  //
    732   Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Head, HeadLen));
     725  Checksum = (UINT16)(~NetblockChecksum ((UINT8 *)Head, HeadLen));
    733726
    734727  if ((Head->Checksum != 0) && (Checksum != 0)) {
    … …  
    739732  // Convert the IP header to host byte order, then get the per packet info.
    740733  //
    741   (*Packet)->Ip.Ip4  = Ip4NtohHead (Head);
    742 
    743   Info            = IP4_GET_CLIP_INFO (*Packet);
    744   Info->LinkFlag  = Flag;
    745   Info->CastType  = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);
    746   Info->Start     = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;
    747   Info->Length    = Head->TotalLen - HeadLen;
    748   Info->End       = Info->Start + Info->Length;
    749   Info->Status    = EFI_SUCCESS;
     734  (*Packet)->Ip.Ip4 = Ip4NtohHead (Head);
     735
     736  Info           = IP4_GET_CLIP_INFO (*Packet);
     737  Info->LinkFlag = Flag;
     738  Info->CastType = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);
     739  Info->Start    = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;
     740  Info->Length   = Head->TotalLen - HeadLen;
     741  Info->End      = Info->Start + Info->Length;
     742  Info->Status   = EFI_SUCCESS;
    750743
    751744  //
    … …  
    816809BOOLEAN
    817810Ip4IsValidPacketLength (
    818   IN NET_BUF        *Packet
     811  IN NET_BUF  *Packet
    819812  )
    820813{
    … …  
    844837VOID
    845838Ip4AccpetFrame (
    846   IN IP4_PROTOCOL           *Ip4Instance,
    847   IN NET_BUF                *Packet,
    848   IN EFI_STATUS             IoStatus,
    849   IN UINT32                 Flag,
    850   IN VOID                   *Context
    851   )
    852 {
    853   IP4_SERVICE               *IpSb;
    854   IP4_HEAD                  *Head;
    855   EFI_STATUS                Status;
    856   IP4_HEAD                  ZeroHead;
    857   UINT8                     *Option;
    858   UINT32                    OptionLen;
    859 
    860   IpSb   = (IP4_SERVICE *) Context;
     839  IN IP4_PROTOCOL  *Ip4Instance,
     840  IN NET_BUF       *Packet,
     841  IN EFI_STATUS    IoStatus,
     842  IN UINT32        Flag,
     843  IN VOID          *Context
     844  )
     845{
     846  IP4_SERVICE  *IpSb;
     847  IP4_HEAD     *Head;
     848  EFI_STATUS   Status;
     849  IP4_HEAD     ZeroHead;
     850  UINT8        *Option;
     851  UINT32       OptionLen;
     852
     853  IpSb   = (IP4_SERVICE *)Context;
    861854  Option = NULL;
    862855
    … …  
    869862  }
    870863
    871   Head      = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
     864  Head = (IP4_HEAD *)NetbufGetByte (Packet, 0, NULL);
    872865  ASSERT (Head != NULL);
    873866  OptionLen = (Head->HeadLen << 2) - IP4_MIN_HEADLEN;
    874867  if (OptionLen > 0) {
    875     Option = (UINT8 *) (Head + 1);
     868    Option = (UINT8 *)(Head + 1);
    876869  }
    877870
    … …  
    923916    }
    924917
    925     Head = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);
     918    Head = (IP4_HEAD *)NetbufGetByte (Packet, 0, NULL);
    926919    ASSERT (Head != NULL);
    927920    Status = Ip4PreProcessPacket (
    … …  
    939932
    940933  ASSERT (Packet != NULL);
    941   Head  = Packet->Ip.Ip4;
     934  Head                               = Packet->Ip.Ip4;
    942935  IP4_GET_CLIP_INFO (Packet)->Status = EFI_SUCCESS;
    943936
    944937  switch (Head->Protocol) {
    945   case EFI_IP_PROTO_ICMP:
    946     Ip4IcmpHandle (IpSb, Head, Packet);
    947     break;
    948 
    949   case IP4_PROTO_IGMP:
    950     Ip4IgmpHandle (IpSb, Head, Packet);
    951     break;
    952 
    953   default:
    954     Ip4Demultiplex (IpSb, Head, Packet, Option, OptionLen);
     938    case EFI_IP_PROTO_ICMP:
     939      Ip4IcmpHandle (IpSb, Head, Packet);
     940      break;
     941
     942    case IP4_PROTO_IGMP:
     943      Ip4IgmpHandle (IpSb, Head, Packet);
     944      break;
     945
     946    default:
     947      Ip4Demultiplex (IpSb, Head, Packet, Option, OptionLen);
    955948  }
    956949
    … …  
    971964  }
    972965
    973   return ;
    974 }
    975 
     966  return;
     967}
    976968
    977969/**
    … …  
    988980BOOLEAN
    989981Ip4InstanceFrameAcceptable (
    990   IN IP4_PROTOCOL           *IpInstance,
    991   IN IP4_HEAD               *Head,
    992   IN NET_BUF                *Packet
    993   )
    994 {
    995   IP4_ICMP_ERROR_HEAD       Icmp;
    996   EFI_IP4_CONFIG_DATA       *Config;
    997   IP4_CLIP_INFO             *Info;
    998   UINT16                    Proto;
    999   UINT32                    Index;
     982  IN IP4_PROTOCOL  *IpInstance,
     983  IN IP4_HEAD      *Head,
     984  IN NET_BUF       *Packet
     985  )
     986{
     987  IP4_ICMP_ERROR_HEAD  Icmp;
     988  EFI_IP4_CONFIG_DATA  *Config;
     989  IP4_CLIP_INFO        *Info;
     990  UINT16               Proto;
     991  UINT32               Index;
    1000992
    1001993  Config = &IpInstance->ConfigData;
    … …  
    10251017
    10261018  if ((Proto == EFI_IP_PROTO_ICMP) && (!Config->AcceptAnyProtocol) && (Proto != Config->DefaultProtocol)) {
    1027     NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *) &Icmp.Head);
     1019    NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *)&Icmp.Head);
    10281020
    10291021    if (mIcmpClass[Icmp.Head.Type].IcmpClass == ICMP_ERROR_MESSAGE) {
    … …  
    10321024      }
    10331025
    1034       NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *) &Icmp);
     1026      NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
    10351027      Proto = Icmp.IpHead.Protocol;
    10361028    }
    … …  
    10771069}
    10781070
    1079 
    10801071/**
    10811072  Enqueue a shared copy of the packet to the IP4 child if the
    … …  
    10951086EFI_STATUS
    10961087Ip4InstanceEnquePacket (
    1097   IN IP4_PROTOCOL           *IpInstance,
    1098   IN IP4_HEAD               *Head,
    1099   IN NET_BUF                *Packet
    1100   )
    1101 {
    1102   IP4_CLIP_INFO             *Info;
    1103   NET_BUF                   *Clone;
     1088  IN IP4_PROTOCOL  *IpInstance,
     1089  IN IP4_HEAD      *Head,
     1090  IN NET_BUF       *Packet
     1091  )
     1092{
     1093  IP4_CLIP_INFO  *Info;
     1094  NET_BUF        *Clone;
    11041095
    11051096  //
    … …  
    11271118  // packet will be removed from the queue.
    11281119  //
    1129   Info        = IP4_GET_CLIP_INFO (Clone);
    1130   Info->Life  = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);
     1120  Info       = IP4_GET_CLIP_INFO (Clone);
     1121  Info->Life = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);
    11311122
    11321123  InsertTailList (&IpInstance->Received, &Clone->List);
    11331124  return EFI_SUCCESS;
    11341125}
    1135 
    11361126
    11371127/**
    … …  
    11471137EFIAPI
    11481138Ip4OnRecyclePacket (
    1149   IN EFI_EVENT              Event,
    1150   IN VOID                   *Context
    1151   )
    1152 {
    1153   IP4_RXDATA_WRAP           *Wrap;
    1154 
    1155   Wrap = (IP4_RXDATA_WRAP *) Context;
     1139  IN EFI_EVENT  Event,
     1140  IN VOID       *Context
     1141  )
     1142{
     1143  IP4_RXDATA_WRAP  *Wrap;
     1144
     1145  Wrap = (IP4_RXDATA_WRAP *)Context;
    11561146
    11571147  EfiAcquireLockOrFail (&Wrap->IpInstance->RecycleLock);
    … …  
    11651155  FreePool (Wrap);
    11661156}
    1167 
    11681157
    11691158/**
    … …  
    11841173IP4_RXDATA_WRAP *
    11851174Ip4WrapRxData (
    1186   IN IP4_PROTOCOL           *IpInstance,
    1187   IN NET_BUF                *Packet
    1188   )
    1189 {
    1190   IP4_RXDATA_WRAP           *Wrap;
    1191   EFI_IP4_RECEIVE_DATA      *RxData;
    1192   EFI_STATUS                Status;
    1193   BOOLEAN                   RawData;
     1175  IN IP4_PROTOCOL  *IpInstance,
     1176  IN NET_BUF       *Packet
     1177  )
     1178{
     1179  IP4_RXDATA_WRAP       *Wrap;
     1180  EFI_IP4_RECEIVE_DATA  *RxData;
     1181  EFI_STATUS            Status;
     1182  BOOLEAN               RawData;
    11941183
    11951184  Wrap = AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet->BlockOpNum));
    … …  
    12011190  InitializeListHead (&Wrap->Link);
    12021191
    1203   Wrap->IpInstance  = IpInstance;
    1204   Wrap->Packet      = Packet;
    1205   RxData            = &Wrap->RxData;
     1192  Wrap->IpInstance = IpInstance;
     1193  Wrap->Packet     = Packet;
     1194  RxData           = &Wrap->RxData;
    12061195
    12071196  ZeroMem (RxData, sizeof (EFI_IP4_RECEIVE_DATA));
    … …  
    12301219  if (!RawData) {
    12311220    RxData->HeaderLength  = (Packet->Ip.Ip4->HeadLen << 2);
    1232     RxData->Header        = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);
     1221    RxData->Header        = (EFI_IP4_HEADER *)Ip4NtohHead (Packet->Ip.Ip4);
    12331222    RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;
    12341223    RxData->Options       = NULL;
    12351224
    12361225    if (RxData->OptionsLength != 0) {
    1237       RxData->Options = (VOID *) (RxData->Header + 1);
    1238     }
    1239   }
    1240 
    1241   RxData->DataLength  = Packet->TotalSize;
     1226      RxData->Options = (VOID *)(RxData->Header + 1);
     1227    }
     1228  }
     1229
     1230  RxData->DataLength = Packet->TotalSize;
    12421231
    12431232  //
    … …  
    12451234  //
    12461235  RxData->FragmentCount = Packet->BlockOpNum;
    1247   NetbufBuildExt (Packet, (NET_FRAGMENT *) RxData->FragmentTable, &RxData->FragmentCount);
     1236  NetbufBuildExt (Packet, (NET_FRAGMENT *)RxData->FragmentTable, &RxData->FragmentCount);
    12481237
    12491238  return Wrap;
    12501239}
    1251 
    12521240
    12531241/**
    … …  
    12671255EFI_STATUS
    12681256Ip4InstanceDeliverPacket (
    1269   IN IP4_PROTOCOL           *IpInstance
     1257  IN IP4_PROTOCOL  *IpInstance
    12701258  )
    12711259{
    … …  
    12811269  //
    12821270  while (!IsListEmpty (&IpInstance->Received) &&
    1283          !NetMapIsEmpty (&IpInstance->RxTokens)) {
    1284 
     1271         !NetMapIsEmpty (&IpInstance->RxTokens))
     1272  {
    12851273    Packet = NET_LIST_HEAD (&IpInstance->Received, NET_BUF, List);
    12861274
    … …  
    12961284
    12971285      RemoveEntryList (&Packet->List);
    1298 
    12991286    } else {
    13001287      //
    … …  
    13221309        ASSERT (Head != NULL);
    13231310
    1324         Dup->Ip.Ip4 = (IP4_HEAD *) Head;
     1311        Dup->Ip.Ip4 = (IP4_HEAD *)Head;
    13251312
    13261313        CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);
    … …  
    13581345  return EFI_SUCCESS;
    13591346}
    1360 
    13611347
    13621348/**
    … …  
    13761362INTN
    13771363Ip4InterfaceEnquePacket (
    1378   IN IP4_SERVICE            *IpSb,
    1379   IN IP4_HEAD               *Head,
    1380   IN NET_BUF                *Packet,
    1381   IN UINT8                  *Option,
    1382   IN UINT32                 OptionLen,
    1383   IN IP4_INTERFACE          *IpIf
    1384   )
    1385 {
    1386   IP4_PROTOCOL              *IpInstance;
    1387   IP4_CLIP_INFO             *Info;
    1388   LIST_ENTRY                *Entry;
    1389   INTN                      Enqueued;
    1390   INTN                      LocalType;
    1391   INTN                      SavedType;
     1364  IN IP4_SERVICE    *IpSb,
     1365  IN IP4_HEAD       *Head,
     1366  IN NET_BUF        *Packet,
     1367  IN UINT8          *Option,
     1368  IN UINT32         OptionLen,
     1369  IN IP4_INTERFACE  *IpIf
     1370  )
     1371{
     1372  IP4_PROTOCOL   *IpInstance;
     1373  IP4_CLIP_INFO  *Info;
     1374  LIST_ENTRY     *Entry;
     1375  INTN           Enqueued;
     1376  INTN           LocalType;
     1377  INTN           SavedType;
    13921378
    13931379  //
    … …  
    14071393    //
    14081394    LocalType = Info->CastType;
    1409 
    14101395  } else {
    14111396    //
    … …  
    14171402    if (IpIf->Ip == IP4_ALLZERO_ADDRESS) {
    14181403      LocalType = IP4_LOCAL_HOST;
    1419 
    14201404    } else {
    14211405      LocalType = Ip4GetNetCast (Head->Dst, IpIf);
    … …  
    14371421  // interface. The global cast type will be restored later.
    14381422  //
    1439   SavedType       = Info->CastType;
    1440   Info->CastType  = LocalType;
    1441 
    1442   Enqueued        = 0;
     1423  SavedType      = Info->CastType;
     1424  Info->CastType = LocalType;
     1425
     1426  Enqueued = 0;
    14431427
    14441428  NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
    … …  
    14491433    // In RawData mode, add IPv4 headers and options back to packet.
    14501434    //
    1451     if ((IpInstance->ConfigData.RawData) && (Option != NULL) && (OptionLen != 0)){
     1435    if ((IpInstance->ConfigData.RawData) && (Option != NULL) && (OptionLen != 0)) {
    14521436      Ip4PrependHead (Packet, Head, Option, OptionLen);
    14531437    }
    … …  
    14621446}
    14631447
    1464 
    14651448/**
    14661449  Deliver the packet for each IP4 child on the interface.
    … …  
    14741457EFI_STATUS
    14751458Ip4InterfaceDeliverPacket (
    1476   IN IP4_SERVICE            *IpSb,
    1477   IN IP4_INTERFACE          *IpIf
    1478   )
    1479 {
    1480   IP4_PROTOCOL              *Ip4Instance;
    1481   LIST_ENTRY                *Entry;
     1459  IN IP4_SERVICE    *IpSb,
     1460  IN IP4_INTERFACE  *IpIf
     1461  )
     1462{
     1463  IP4_PROTOCOL  *Ip4Instance;
     1464  LIST_ENTRY    *Entry;
    14821465
    14831466  NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
    … …  
    14881471  return EFI_SUCCESS;
    14891472}
    1490 
    14911473
    14921474/**
    … …  
    15121494EFI_STATUS
    15131495Ip4Demultiplex (
    1514   IN IP4_SERVICE            *IpSb,
    1515   IN IP4_HEAD               *Head,
    1516   IN NET_BUF                *Packet,
    1517   IN UINT8                  *Option,
    1518   IN UINT32                 OptionLen
    1519   )
    1520 {
    1521   LIST_ENTRY                *Entry;
    1522   IP4_INTERFACE             *IpIf;
    1523   INTN                      Enqueued;
     1496  IN IP4_SERVICE  *IpSb,
     1497  IN IP4_HEAD     *Head,
     1498  IN NET_BUF      *Packet,
     1499  IN UINT8        *Option,
     1500  IN UINT32       OptionLen
     1501  )
     1502{
     1503  LIST_ENTRY     *Entry;
     1504  IP4_INTERFACE  *IpIf;
     1505  INTN           Enqueued;
    15241506
    15251507  //
    … …  
    15661548}
    15671549
    1568 
    15691550/**
    15701551  Timeout the fragment and enqueued packets.
    … …  
    15751556VOID
    15761557Ip4PacketTimerTicking (
    1577   IN IP4_SERVICE            *IpSb
    1578   )
    1579 {
    1580   LIST_ENTRY                *InstanceEntry;
    1581   LIST_ENTRY                *Entry;
    1582   LIST_ENTRY                *Next;
    1583   IP4_PROTOCOL              *IpInstance;
    1584   IP4_ASSEMBLE_ENTRY        *Assemble;
    1585   NET_BUF                   *Packet;
    1586   IP4_CLIP_INFO             *Info;
    1587   UINT32                    Index;
     1558  IN IP4_SERVICE  *IpSb
     1559  )
     1560{
     1561  LIST_ENTRY          *InstanceEntry;
     1562  LIST_ENTRY          *Entry;
     1563  LIST_ENTRY          *Next;
     1564  IP4_PROTOCOL        *IpInstance;
     1565  IP4_ASSEMBLE_ENTRY  *Assemble;
     1566  NET_BUF             *Packet;
     1567  IP4_CLIP_INFO       *Info;
     1568  UINT32              Index;
    15881569
    15891570  //
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette