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/UefiPxeBcDxe/PxeBcSupport.c

    r85718 r99404  
    99
    1010#include "PxeBcImpl.h"
    11 
    1211
    1312/**
    … …  
    2423EFI_STATUS
    2524PxeBcFlushStationIp (
    26   PXEBC_PRIVATE_DATA       *Private,
    27   EFI_IP_ADDRESS           *StationIp,     OPTIONAL
    28   EFI_IP_ADDRESS           *SubnetMask     OPTIONAL
    29   )
    30 {
    31   EFI_PXE_BASE_CODE_MODE   *Mode;
    32   EFI_STATUS               Status;
    33   EFI_ARP_CONFIG_DATA      ArpConfigData;
     25  PXEBC_PRIVATE_DATA  *Private,
     26  EFI_IP_ADDRESS      *StationIp      OPTIONAL,
     27  EFI_IP_ADDRESS      *SubnetMask     OPTIONAL
     28  )
     29{
     30  EFI_PXE_BASE_CODE_MODE  *Mode;
     31  EFI_STATUS              Status;
     32  EFI_ARP_CONFIG_DATA     ArpConfigData;
    3433
    3534  Mode   = Private->PxeBc.Mode;
    … …  
    3736  ZeroMem (&ArpConfigData, sizeof (EFI_ARP_CONFIG_DATA));
    3837
    39   if (Mode->UsingIpv6 && StationIp != NULL) {
     38  if (Mode->UsingIpv6 && (StationIp != NULL)) {
    4039    //
    4140    // Overwrite Udp6CfgData/Ip6CfgData StationAddress.
    … …  
    6261      //
    6362      ArpConfigData.SwAddressType   = 0x0800;
    64       ArpConfigData.SwAddressLength = (UINT8) sizeof (EFI_IPv4_ADDRESS);
    65       ArpConfigData.StationAddress = StationIp;
     63      ArpConfigData.SwAddressLength = (UINT8)sizeof (EFI_IPv4_ADDRESS);
     64      ArpConfigData.StationAddress  = StationIp;
    6665
    6766      Private->Arp->Configure (Private->Arp, NULL);
    … …  
    8382    }
    8483
    85     if (StationIp != NULL && SubnetMask != NULL) {
     84    if ((StationIp != NULL) && (SubnetMask != NULL)) {
    8685      //
    8786      // Updated the route table.
    … …  
    9392    }
    9493
    95     if (StationIp != NULL || SubnetMask != NULL) {
     94    if ((StationIp != NULL) || (SubnetMask != NULL)) {
    9695      //
    9796      // Reconfigure the Ip4 instance to capture background ICMP packets with new station Ip address.
    … …  
    113112}
    114113
    115 
    116114/**
    117115  Notify the callback function when an event is triggered.
    … …  
    124122EFIAPI
    125123PxeBcCommonNotify (
    126   IN EFI_EVENT           Event,
    127   IN VOID                *Context
    128   )
    129 {
    130   *((BOOLEAN *) Context) = TRUE;
    131 }
    132 
     124  IN EFI_EVENT  Event,
     125  IN VOID       *Context
     126  )
     127{
     128  *((BOOLEAN *)Context) = TRUE;
     129}
    133130
    134131/**
    … …  
    146143BOOLEAN
    147144PxeBcCheckArpCache (
    148   IN  EFI_PXE_BASE_CODE_MODE    *Mode,
    149   IN  EFI_IPv4_ADDRESS          *Ip4Addr,
    150   OUT EFI_MAC_ADDRESS           *MacAddress
    151   )
    152 {
    153   UINT32       Index;
     145  IN  EFI_PXE_BASE_CODE_MODE  *Mode,
     146  IN  EFI_IPv4_ADDRESS        *Ip4Addr,
     147  OUT EFI_MAC_ADDRESS         *MacAddress
     148  )
     149{
     150  UINT32  Index;
    154151
    155152  ASSERT (!Mode->UsingIpv6);
    … …  
    172169}
    173170
    174 
    175171/**
    176172  Update the arp cache periodically.
    … …  
    183179EFIAPI
    184180PxeBcArpCacheUpdate (
    185   IN EFI_EVENT            Event,
    186   IN VOID                 *Context
     181  IN EFI_EVENT  Event,
     182  IN VOID       *Context
    187183  )
    188184{
    … …  
    195191  EFI_STATUS              Status;
    196192
    197   Private = (PXEBC_PRIVATE_DATA *) Context;
     193  Private = (PXEBC_PRIVATE_DATA *)Context;
    198194  Mode    = Private->PxeBc.Mode;
    199195
    … …  
    229225    CopyMem (
    230226      &Mode->ArpCache[Index].MacAddr,
    231       (UINT8 *) (ArpEntry + 1) + ArpEntry->SwAddressLength,
     227      (UINT8 *)(ArpEntry + 1) + ArpEntry->SwAddressLength,
    232228      ArpEntry->HwAddressLength
    233229      );
    234     ArpEntry = (EFI_ARP_FIND_DATA *) ((UINT8 *) ArpEntry + EntryLength);
    235   }
    236 }
    237 
     230    ArpEntry = (EFI_ARP_FIND_DATA *)((UINT8 *)ArpEntry + EntryLength);
     231  }
     232}
    238233
    239234/**
    … …  
    246241EFIAPI
    247242PxeBcIcmpErrorDpcHandle (
    248   IN VOID                      *Context
    249   )
    250 {
    251   EFI_STATUS                   Status;
    252   EFI_IP4_RECEIVE_DATA         *RxData;
    253   EFI_IP4_PROTOCOL             *Ip4;
    254   PXEBC_PRIVATE_DATA           *Private;
    255   EFI_PXE_BASE_CODE_MODE       *Mode;
    256   UINT8                        Type;
    257   UINTN                        Index;
    258   UINT32                       CopiedLen;
    259   UINT8                        *IcmpError;
    260 
    261   Private = (PXEBC_PRIVATE_DATA *) Context;
     243  IN VOID  *Context
     244  )
     245{
     246  EFI_STATUS              Status;
     247  EFI_IP4_RECEIVE_DATA    *RxData;
     248  EFI_IP4_PROTOCOL        *Ip4;
     249  PXEBC_PRIVATE_DATA      *Private;
     250  EFI_PXE_BASE_CODE_MODE  *Mode;
     251  UINT8                   Type;
     252  UINTN                   Index;
     253  UINT32                  CopiedLen;
     254  UINT8                   *IcmpError;
     255
     256  Private = (PXEBC_PRIVATE_DATA *)Context;
    262257  Mode    = &Private->Mode;
    263258  Status  = Private->IcmpToken.Status;
    … …  
    285280  }
    286281
    287   if (EFI_IP4 (RxData->Header->SourceAddress) != 0 &&
     282  if ((EFI_IP4 (RxData->Header->SourceAddress) != 0) &&
    288283      (NTOHL (Mode->SubnetMask.Addr[0]) != 0) &&
    289       IP4_NET_EQUAL (NTOHL(Mode->StationIp.Addr[0]), EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])) &&
    290       !NetIp4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0]))) {
     284      IP4_NET_EQUAL (NTOHL (Mode->StationIp.Addr[0]), EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])) &&
     285      !NetIp4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])))
     286  {
    291287    //
    292288    // The source address of the received packet should be a valid unicast address.
    … …  
    307303  ASSERT (RxData->Header->Protocol == EFI_IP_PROTO_ICMP);
    308304
    309   Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
    310 
    311   if (Type != ICMP_DEST_UNREACHABLE &&
    312       Type != ICMP_SOURCE_QUENCH &&
    313       Type != ICMP_REDIRECT &&
    314       Type != ICMP_TIME_EXCEEDED &&
    315       Type != ICMP_PARAMETER_PROBLEM) {
     305  Type = *((UINT8 *)RxData->FragmentTable[0].FragmentBuffer);
     306
     307  if ((Type != ICMP_DEST_UNREACHABLE) &&
     308      (Type != ICMP_SOURCE_QUENCH) &&
     309      (Type != ICMP_REDIRECT) &&
     310      (Type != ICMP_TIME_EXCEEDED) &&
     311      (Type != ICMP_PARAMETER_PROBLEM))
     312  {
    316313    //
    317314    // The type of the receveid ICMP message should be ICMP_ERROR_MESSAGE.
    … …  
    324321  //
    325322  CopiedLen = 0;
    326   IcmpError = (UINT8 *) &Mode->IcmpError;
     323  IcmpError = (UINT8 *)&Mode->IcmpError;
    327324
    328325  for (Index = 0; Index < RxData->FragmentCount; Index++) {
    … …  
    341338        );
    342339    }
     340
    343341    IcmpError += CopiedLen;
    344342  }
    … …  
    352350}
    353351
    354 
    355352/**
    356353  Callback function to update the latest ICMP6 error message.
    … …  
    363360EFIAPI
    364361PxeBcIcmpErrorUpdate (
    365   IN EFI_EVENT            Event,
    366   IN VOID                 *Context
     362  IN EFI_EVENT  Event,
     363  IN VOID       *Context
    367364  )
    368365{
    369366  QueueDpc (TPL_CALLBACK, PxeBcIcmpErrorDpcHandle, Context);
    370367}
    371 
    372368
    373369/**
    … …  
    380376EFIAPI
    381377PxeBcIcmp6ErrorDpcHandle (
    382   IN VOID                 *Context
     378  IN VOID  *Context
    383379  )
    384380{
    … …  
    393389  UINT8                   *Icmp6Error;
    394390
    395   Private = (PXEBC_PRIVATE_DATA *) Context;
     391  Private = (PXEBC_PRIVATE_DATA *)Context;
    396392  Mode    = &Private->Mode;
    397393  Status  = Private->Icmp6Token.Status;
    … …  
    427423
    428424  if (!NetIp6IsUnspecifiedAddr (&Mode->StationIp.v6) &&
    429       !EFI_IP6_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v6)) {
     425      !EFI_IP6_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v6))
     426  {
    430427    //
    431428    // The destination address of the received packet should be equal to the host address.
    … …  
    439436  ASSERT (RxData->Header->NextHeader == IP6_ICMP);
    440437
    441   Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
    442 
    443   if (Type != ICMP_V6_DEST_UNREACHABLE &&
    444       Type != ICMP_V6_PACKET_TOO_BIG &&
    445       Type != ICMP_V6_TIME_EXCEEDED &&
    446       Type != ICMP_V6_PARAMETER_PROBLEM) {
     438  Type = *((UINT8 *)RxData->FragmentTable[0].FragmentBuffer);
     439
     440  if ((Type != ICMP_V6_DEST_UNREACHABLE) &&
     441      (Type != ICMP_V6_PACKET_TOO_BIG) &&
     442      (Type != ICMP_V6_TIME_EXCEEDED) &&
     443      (Type != ICMP_V6_PARAMETER_PROBLEM))
     444  {
    447445    //
    448446    // The type of the receveid packet should be an ICMP6 error message.
    … …  
    455453  //
    456454  CopiedLen  = 0;
    457   Icmp6Error = (UINT8 *) &Mode->IcmpError;
     455  Icmp6Error = (UINT8 *)&Mode->IcmpError;
    458456
    459457  for (Index = 0; Index < RxData->FragmentCount; Index++) {
    … …  
    472470        );
    473471    }
     472
    474473    Icmp6Error += CopiedLen;
    475474  }
    … …  
    483482}
    484483
    485 
    486484/**
    487485  Callback function to update the latest ICMP6 error message.
    … …  
    494492EFIAPI
    495493PxeBcIcmp6ErrorUpdate (
    496   IN EFI_EVENT               Event,
    497   IN VOID                    *Context
     494  IN EFI_EVENT  Event,
     495  IN VOID       *Context
    498496  )
    499497{
    500498  QueueDpc (TPL_CALLBACK, PxeBcIcmp6ErrorDpcHandle, Context);
    501499}
    502 
    503500
    504501/**
    … …  
    564561  }
    565562
    566   if (!EFI_ERROR (Status) && *SrcPort == 0) {
     563  if (!EFI_ERROR (Status) && (*SrcPort == 0)) {
    567564    Udp4->GetModeData (Udp4, &Udp4CfgData, NULL, NULL, NULL);
    568565    *SrcPort = Udp4CfgData.StationPort;
    … …  
    571568  return Status;
    572569}
    573 
    574570
    575571/**
    … …  
    614610  }
    615611
    616   if (!EFI_ERROR (Status) && *SrcPort == 0) {
     612  if (!EFI_ERROR (Status) && (*SrcPort == 0)) {
    617613    Udp6->GetModeData (Udp6, &CfgData, NULL, NULL, NULL);
    618614    *SrcPort = CfgData.StationPort;
    … …  
    621617  return Status;
    622618}
    623 
    624619
    625620/**
    … …  
    643638EFI_STATUS
    644639PxeBcUdp4Write (
    645   IN EFI_UDP4_PROTOCOL       *Udp4,
    646   IN EFI_UDP4_SESSION_DATA   *Session,
    647   IN EFI_EVENT               TimeoutEvent,
    648   IN EFI_IPv4_ADDRESS        *Gateway      OPTIONAL,
    649   IN UINTN                   *HeaderSize   OPTIONAL,
    650   IN VOID                    *HeaderPtr    OPTIONAL,
    651   IN UINTN                   *BufferSize,
    652   IN VOID                    *BufferPtr
    653   )
    654 {
    655   EFI_UDP4_COMPLETION_TOKEN Token;
    656   EFI_UDP4_TRANSMIT_DATA    *TxData;
    657   UINT32                    TxLength;
    658   UINT32                    FragCount;
    659   UINT32                    DataLength;
    660   BOOLEAN                   IsDone;
    661   EFI_STATUS                Status;
     640  IN EFI_UDP4_PROTOCOL      *Udp4,
     641  IN EFI_UDP4_SESSION_DATA  *Session,
     642  IN EFI_EVENT              TimeoutEvent,
     643  IN EFI_IPv4_ADDRESS       *Gateway      OPTIONAL,
     644  IN UINTN                  *HeaderSize   OPTIONAL,
     645  IN VOID                   *HeaderPtr    OPTIONAL,
     646  IN UINTN                  *BufferSize,
     647  IN VOID                   *BufferPtr
     648  )
     649{
     650  EFI_UDP4_COMPLETION_TOKEN  Token;
     651  EFI_UDP4_TRANSMIT_DATA     *TxData;
     652  UINT32                     TxLength;
     653  UINT32                     FragCount;
     654  UINT32                     DataLength;
     655  BOOLEAN                    IsDone;
     656  EFI_STATUS                 Status;
    662657
    663658  //
    … …  
    666661  FragCount = (HeaderSize != NULL) ? 2 : 1;
    667662  TxLength  = sizeof (EFI_UDP4_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA);
    668   TxData    = (EFI_UDP4_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
     663  TxData    = (EFI_UDP4_TRANSMIT_DATA *)AllocateZeroPool (TxLength);
    669664  if (TxData == NULL) {
    670665    return EFI_OUT_OF_RESOURCES;
    … …  
    672667
    673668  TxData->FragmentCount                               = FragCount;
    674   TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
     669  TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32)*BufferSize;
    675670  TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
    676   DataLength                                          = (UINT32) *BufferSize;
     671  DataLength                                          = (UINT32)*BufferSize;
    677672
    678673  if (HeaderSize != NULL) {
    679     TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
     674    TxData->FragmentTable[0].FragmentLength = (UINT32)*HeaderSize;
    680675    TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
    681     DataLength                             += (UINT32) *HeaderSize;
     676    DataLength                             += (UINT32)*HeaderSize;
    682677  }
    683678
    684679  if (Gateway != NULL) {
    685     TxData->GatewayAddress  = Gateway;
    686   }
    687 
    688   TxData->UdpSessionData  = Session;
    689   TxData->DataLength      = DataLength;
    690   Token.Packet.TxData     = TxData;
    691   Token.Status            = EFI_NOT_READY;
    692   IsDone                  = FALSE;
     680    TxData->GatewayAddress = Gateway;
     681  }
     682
     683  TxData->UdpSessionData = Session;
     684  TxData->DataLength     = DataLength;
     685  Token.Packet.TxData    = TxData;
     686  Token.Status           = EFI_NOT_READY;
     687  IsDone                 = FALSE;
    693688
    694689  Status = gBS->CreateEvent (
    … …  
    713708  while (!IsDone &&
    714709         Token.Status == EFI_NOT_READY &&
    715          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
     710         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))
     711  {
    716712    Udp4->Poll (Udp4);
    717713  }
    … …  
    723719    gBS->CloseEvent (Token.Event);
    724720  }
     721
    725722  FreePool (TxData);
    726723
    727724  return Status;
    728725}
    729 
    730726
    731727/**
    … …  
    748744EFI_STATUS
    749745PxeBcUdp6Write (
    750   IN EFI_UDP6_PROTOCOL       *Udp6,
    751   IN EFI_UDP6_SESSION_DATA   *Session,
    752   IN EFI_EVENT               TimeoutEvent,
    753   IN UINTN                   *HeaderSize   OPTIONAL,
    754   IN VOID                    *HeaderPtr    OPTIONAL,
    755   IN UINTN                   *BufferSize,
    756   IN VOID                    *BufferPtr
    757   )
    758 {
    759   EFI_UDP6_COMPLETION_TOKEN Token;
    760   EFI_UDP6_TRANSMIT_DATA    *TxData;
    761   UINT32                    TxLength;
    762   UINT32                    FragCount;
    763   UINT32                    DataLength;
    764   BOOLEAN                   IsDone;
    765   EFI_STATUS                Status;
     746  IN EFI_UDP6_PROTOCOL      *Udp6,
     747  IN EFI_UDP6_SESSION_DATA  *Session,
     748  IN EFI_EVENT              TimeoutEvent,
     749  IN UINTN                  *HeaderSize   OPTIONAL,
     750  IN VOID                   *HeaderPtr    OPTIONAL,
     751  IN UINTN                  *BufferSize,
     752  IN VOID                   *BufferPtr
     753  )
     754{
     755  EFI_UDP6_COMPLETION_TOKEN  Token;
     756  EFI_UDP6_TRANSMIT_DATA     *TxData;
     757  UINT32                     TxLength;
     758  UINT32                     FragCount;
     759  UINT32                     DataLength;
     760  BOOLEAN                    IsDone;
     761  EFI_STATUS                 Status;
    766762
    767763  //
    … …  
    770766  FragCount = (HeaderSize != NULL) ? 2 : 1;
    771767  TxLength  = sizeof (EFI_UDP6_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP6_FRAGMENT_DATA);
    772   TxData    = (EFI_UDP6_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
     768  TxData    = (EFI_UDP6_TRANSMIT_DATA *)AllocateZeroPool (TxLength);
    773769  if (TxData == NULL) {
    774770    return EFI_OUT_OF_RESOURCES;
    … …  
    776772
    777773  TxData->FragmentCount                               = FragCount;
    778   TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
     774  TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32)*BufferSize;
    779775  TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
    780   DataLength                                          = (UINT32) *BufferSize;
     776  DataLength                                          = (UINT32)*BufferSize;
    781777
    782778  if (HeaderSize != NULL) {
    783     TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
     779    TxData->FragmentTable[0].FragmentLength = (UINT32)*HeaderSize;
    784780    TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
    785     DataLength                             += (UINT32) *HeaderSize;
    786   }
    787 
    788   TxData->UdpSessionData  = Session;
    789   TxData->DataLength      = DataLength;
    790   Token.Packet.TxData     = TxData;
    791   Token.Status            = EFI_NOT_READY;
    792   IsDone                  = FALSE;
     781    DataLength                             += (UINT32)*HeaderSize;
     782  }
     783
     784  TxData->UdpSessionData = Session;
     785  TxData->DataLength     = DataLength;
     786  Token.Packet.TxData    = TxData;
     787  Token.Status           = EFI_NOT_READY;
     788  IsDone                 = FALSE;
    793789
    794790  Status = gBS->CreateEvent (
    … …  
    813809  while (!IsDone &&
    814810         Token.Status == EFI_NOT_READY &&
    815          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
     811         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))
     812  {
    816813    Udp6->Poll (Udp6);
    817814  }
    … …  
    823820    gBS->CloseEvent (Token.Event);
    824821  }
     822
    825823  FreePool (TxData);
    826824
    827825  return Status;
    828826}
    829 
    830827
    831828/**
    … …  
    842839BOOLEAN
    843840PxeBcCheckByIpFilter (
    844   IN EFI_PXE_BASE_CODE_MODE    *Mode,
    845   IN VOID                      *Session,
    846   IN UINT16                    OpFlags
    847   )
    848 {
    849   EFI_IP_ADDRESS               DestinationIp;
    850   UINTN                        Index;
     841  IN EFI_PXE_BASE_CODE_MODE  *Mode,
     842  IN VOID                    *Session,
     843  IN UINT16                  OpFlags
     844  )
     845{
     846  EFI_IP_ADDRESS  DestinationIp;
     847  UINTN           Index;
    851848
    852849  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER) == 0) {
    … …  
    864861    CopyMem (
    865862      &DestinationIp,
    866       &((EFI_UDP6_SESSION_DATA *) Session)->DestinationAddress,
     863      &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,
    867864      sizeof (EFI_IPv6_ADDRESS)
    868865      );
    … …  
    872869    CopyMem (
    873870      &DestinationIp,
    874       &((EFI_UDP4_SESSION_DATA *) Session)->DestinationAddress,
     871      &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,
    875872      sizeof (EFI_IPv4_ADDRESS)
    876873      );
    … …  
    878875  }
    879876
    880   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST) != 0 &&
     877  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST) != 0) &&
    881878      (IP4_IS_MULTICAST (DestinationIp.Addr[0]) ||
    882        IP6_IS_MULTICAST (&DestinationIp))) {
     879       IP6_IS_MULTICAST (&DestinationIp)))
     880  {
    883881    return TRUE;
    884882  }
    885883
    886   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST) != 0 &&
    887       IP4_IS_LOCAL_BROADCAST (DestinationIp.Addr[0])) {
     884  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST) != 0) &&
     885      IP4_IS_LOCAL_BROADCAST (DestinationIp.Addr[0]))
     886  {
    888887    ASSERT (!Mode->UsingIpv6);
    889888    return TRUE;
    890889  }
    891890
    892   if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP) != 0 &&
     891  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP) != 0) &&
    893892      (EFI_IP4_EQUAL (&Mode->StationIp.v4, &DestinationIp) ||
    894        EFI_IP6_EQUAL (&Mode->StationIp.v6, &DestinationIp))) {
     893       EFI_IP6_EQUAL (&Mode->StationIp.v6, &DestinationIp)))
     894  {
    895895    //
    896896    // Matched if the dest address is equal to the station address.
    … …  
    902902    ASSERT (Index < EFI_PXE_BASE_CODE_MAX_IPCNT);
    903903    if (EFI_IP4_EQUAL (&Mode->IpFilter.IpList[Index].v4, &DestinationIp) ||
    904         EFI_IP6_EQUAL (&Mode->IpFilter.IpList[Index].v6, &DestinationIp)) {
     904        EFI_IP6_EQUAL (&Mode->IpFilter.IpList[Index].v6, &DestinationIp))
     905    {
    905906      //
    906907      // Matched if the dest address is equal to any of address in the filter list.
    … …  
    913914}
    914915
    915 
    916916/**
    917917  Filter the received packet using the destination Ip.
    … …  
    928928BOOLEAN
    929929PxeBcCheckByDestIp (
    930   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
    931   IN     VOID                      *Session,
    932   IN OUT EFI_IP_ADDRESS            *DestIp,
    933   IN     UINT16                    OpFlags
     930  IN     EFI_PXE_BASE_CODE_MODE  *Mode,
     931  IN     VOID                    *Session,
     932  IN OUT EFI_IP_ADDRESS          *DestIp,
     933  IN     UINT16                  OpFlags
    934934  )
    935935{
    … …  
    953953          );
    954954      }
    955 
    956     }
     955    }
     956
    957957    return TRUE;
    958   } else if (DestIp != NULL &&
     958  } else if ((DestIp != NULL) &&
    959959             (EFI_IP4_EQUAL (DestIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
    960               EFI_IP6_EQUAL (DestIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress))) {
     960              EFI_IP6_EQUAL (DestIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress)))
     961  {
    961962    //
    962963    // The destination address in the received packet is matched if present.
    … …  
    964965    return TRUE;
    965966  } else if (EFI_IP4_EQUAL (&Mode->StationIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
    966              EFI_IP6_EQUAL (&Mode->StationIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress)) {
     967             EFI_IP6_EQUAL (&Mode->StationIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress))
     968  {
    967969    //
    968970    // The destination address in the received packet is equal to the host address.
    … …  
    973975  return FALSE;
    974976}
    975 
    976977
    977978/**
    … …  
    989990BOOLEAN
    990991PxeBcCheckByDestPort (
    991   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
    992   IN     VOID                      *Session,
    993   IN OUT UINT16                    *DestPort,
    994   IN     UINT16                    OpFlags
    995   )
    996 {
    997   UINT16       Port;
     992  IN     EFI_PXE_BASE_CODE_MODE  *Mode,
     993  IN     VOID                    *Session,
     994  IN OUT UINT16                  *DestPort,
     995  IN     UINT16                  OpFlags
     996  )
     997{
     998  UINT16  Port;
    998999
    9991000  if (Mode->UsingIpv6) {
    1000     Port = ((EFI_UDP6_SESSION_DATA *) Session)->DestinationPort;
     1001    Port = ((EFI_UDP6_SESSION_DATA *)Session)->DestinationPort;
    10011002  } else {
    1002     Port = ((EFI_UDP4_SESSION_DATA *) Session)->DestinationPort;
     1003    Port = ((EFI_UDP4_SESSION_DATA *)Session)->DestinationPort;
    10031004  }
    10041005
    … …  
    10101011      *DestPort = Port;
    10111012    }
     1013
    10121014    return TRUE;
    1013   } else if (DestPort != NULL && *DestPort == Port) {
     1015  } else if ((DestPort != NULL) && (*DestPort == Port)) {
    10141016    //
    10151017    // The destination port in the received packet is matched if present.
    … …  
    10201022  return FALSE;
    10211023}
    1022 
    10231024
    10241025/**
    … …  
    10361037BOOLEAN
    10371038PxeBcFilterBySrcIp (
    1038   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
    1039   IN     VOID                      *Session,
    1040   IN OUT EFI_IP_ADDRESS            *SrcIp,
    1041   IN     UINT16                    OpFlags
     1039  IN     EFI_PXE_BASE_CODE_MODE  *Mode,
     1040  IN     VOID                    *Session,
     1041  IN OUT EFI_IP_ADDRESS          *SrcIp,
     1042  IN     UINT16                  OpFlags
    10421043  )
    10431044{
    … …  
    10611062          );
    10621063      }
    1063 
    1064     }
     1064    }
     1065
    10651066    return TRUE;
    1066   } else if (SrcIp != NULL &&
     1067  } else if ((SrcIp != NULL) &&
    10671068             (EFI_IP4_EQUAL (SrcIp, &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress) ||
    1068               EFI_IP6_EQUAL (SrcIp, &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress))) {
     1069              EFI_IP6_EQUAL (SrcIp, &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress)))
     1070  {
    10691071    //
    10701072    // The source address in the received packet is matched if present.
    … …  
    10751077  return FALSE;
    10761078}
    1077 
    10781079
    10791080/**
    … …  
    10911092BOOLEAN
    10921093PxeBcFilterBySrcPort (
    1093   IN     EFI_PXE_BASE_CODE_MODE    *Mode,
    1094   IN     VOID                      *Session,
    1095   IN OUT UINT16                    *SrcPort,
    1096   IN     UINT16                    OpFlags
    1097   )
    1098 {
    1099   UINT16       Port;
     1094  IN     EFI_PXE_BASE_CODE_MODE  *Mode,
     1095  IN     VOID                    *Session,
     1096  IN OUT UINT16                  *SrcPort,
     1097  IN     UINT16                  OpFlags
     1098  )
     1099{
     1100  UINT16  Port;
    11001101
    11011102  if (Mode->UsingIpv6) {
    1102     Port = ((EFI_UDP6_SESSION_DATA *) Session)->SourcePort;
     1103    Port = ((EFI_UDP6_SESSION_DATA *)Session)->SourcePort;
    11031104  } else {
    1104     Port = ((EFI_UDP4_SESSION_DATA *) Session)->SourcePort;
     1105    Port = ((EFI_UDP4_SESSION_DATA *)Session)->SourcePort;
    11051106  }
    11061107
    … …  
    11121113      *SrcPort = Port;
    11131114    }
     1115
    11141116    return TRUE;
    1115   } else if (SrcPort != NULL && *SrcPort == Port) {
     1117  } else if ((SrcPort != NULL) && (*SrcPort == Port)) {
    11161118    //
    11171119    // The source port in the received packet is matched if present.
    … …  
    11221124  return FALSE;
    11231125}
    1124 
    11251126
    11261127/**
    … …  
    11451146EFI_STATUS
    11461147PxeBcUdp4Read (
    1147   IN     EFI_UDP4_PROTOCOL            *Udp4,
    1148   IN     EFI_UDP4_COMPLETION_TOKEN    *Token,
    1149   IN     EFI_PXE_BASE_CODE_MODE       *Mode,
    1150   IN     EFI_EVENT                    TimeoutEvent,
    1151   IN     UINT16                       OpFlags,
    1152   IN     BOOLEAN                      *IsDone,
    1153      OUT BOOLEAN                      *IsMatched,
    1154   IN OUT EFI_IP_ADDRESS               *DestIp      OPTIONAL,
    1155   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *DestPort    OPTIONAL,
    1156   IN OUT EFI_IP_ADDRESS               *SrcIp       OPTIONAL,
    1157   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *SrcPort     OPTIONAL
    1158   )
    1159 {
    1160   EFI_UDP4_RECEIVE_DATA     *RxData;
    1161   EFI_UDP4_SESSION_DATA     *Session;
    1162   EFI_STATUS                Status;
     1148  IN     EFI_UDP4_PROTOCOL           *Udp4,
     1149  IN     EFI_UDP4_COMPLETION_TOKEN   *Token,
     1150  IN     EFI_PXE_BASE_CODE_MODE      *Mode,
     1151  IN     EFI_EVENT                   TimeoutEvent,
     1152  IN     UINT16                      OpFlags,
     1153  IN     BOOLEAN                     *IsDone,
     1154  OUT BOOLEAN                        *IsMatched,
     1155  IN OUT EFI_IP_ADDRESS              *DestIp      OPTIONAL,
     1156  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *DestPort    OPTIONAL,
     1157  IN OUT EFI_IP_ADDRESS              *SrcIp       OPTIONAL,
     1158  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *SrcPort     OPTIONAL
     1159  )
     1160{
     1161  EFI_UDP4_RECEIVE_DATA  *RxData;
     1162  EFI_UDP4_SESSION_DATA  *Session;
     1163  EFI_STATUS             Status;
    11631164
    11641165  Token->Status = EFI_NOT_READY;
    … …  
    11751176  while (!(*IsDone) &&
    11761177         Token->Status == EFI_NOT_READY &&
    1177          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
     1178         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))
     1179  {
    11781180    //
    11791181    // Poll the token until reply/ICMPv6 error message received or timeout.
    11801182    //
    11811183    Udp4->Poll (Udp4);
    1182     if (Token->Status == EFI_ICMP_ERROR ||
    1183         Token->Status == EFI_NETWORK_UNREACHABLE ||
    1184         Token->Status == EFI_HOST_UNREACHABLE ||
    1185         Token->Status == EFI_PROTOCOL_UNREACHABLE ||
    1186         Token->Status == EFI_PORT_UNREACHABLE) {
     1184    if ((Token->Status == EFI_ICMP_ERROR) ||
     1185        (Token->Status == EFI_NETWORK_UNREACHABLE) ||
     1186        (Token->Status == EFI_HOST_UNREACHABLE) ||
     1187        (Token->Status == EFI_PROTOCOL_UNREACHABLE) ||
     1188        (Token->Status == EFI_PORT_UNREACHABLE))
     1189    {
    11871190      break;
    11881191    }
    … …  
    11951198    // check whether this packet matches the filters
    11961199    //
    1197     RxData    = Token->Packet.RxData;
    1198     Session   = &RxData->UdpSession;
     1200    RxData  = Token->Packet.RxData;
     1201    Session = &RxData->UdpSession;
    11991202
    12001203    *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
    … …  
    12261229  return Status;
    12271230}
    1228 
    12291231
    12301232/**
    … …  
    12491251EFI_STATUS
    12501252PxeBcUdp6Read (
    1251   IN     EFI_UDP6_PROTOCOL            *Udp6,
    1252   IN     EFI_UDP6_COMPLETION_TOKEN    *Token,
    1253   IN     EFI_PXE_BASE_CODE_MODE       *Mode,
    1254   IN     EFI_EVENT                    TimeoutEvent,
    1255   IN     UINT16                       OpFlags,
    1256   IN     BOOLEAN                      *IsDone,
    1257      OUT BOOLEAN                      *IsMatched,
    1258   IN OUT EFI_IP_ADDRESS               *DestIp      OPTIONAL,
    1259   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *DestPort    OPTIONAL,
    1260   IN OUT EFI_IP_ADDRESS               *SrcIp       OPTIONAL,
    1261   IN OUT EFI_PXE_BASE_CODE_UDP_PORT   *SrcPort     OPTIONAL
    1262   )
    1263 {
    1264   EFI_UDP6_RECEIVE_DATA     *RxData;
    1265   EFI_UDP6_SESSION_DATA     *Session;
    1266   EFI_STATUS                Status;
     1253  IN     EFI_UDP6_PROTOCOL           *Udp6,
     1254  IN     EFI_UDP6_COMPLETION_TOKEN   *Token,
     1255  IN     EFI_PXE_BASE_CODE_MODE      *Mode,
     1256  IN     EFI_EVENT                   TimeoutEvent,
     1257  IN     UINT16                      OpFlags,
     1258  IN     BOOLEAN                     *IsDone,
     1259  OUT BOOLEAN                        *IsMatched,
     1260  IN OUT EFI_IP_ADDRESS              *DestIp      OPTIONAL,
     1261  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *DestPort    OPTIONAL,
     1262  IN OUT EFI_IP_ADDRESS              *SrcIp       OPTIONAL,
     1263  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *SrcPort     OPTIONAL
     1264  )
     1265{
     1266  EFI_UDP6_RECEIVE_DATA  *RxData;
     1267  EFI_UDP6_SESSION_DATA  *Session;
     1268  EFI_STATUS             Status;
    12671269
    12681270  Token->Status = EFI_NOT_READY;
    … …  
    12791281  while (!(*IsDone) &&
    12801282         Token->Status == EFI_NOT_READY &&
    1281          EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
     1283         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))
     1284  {
    12821285    //
    12831286    // Poll the token until reply/ICMPv6 error message received or timeout.
    12841287    //
    12851288    Udp6->Poll (Udp6);
    1286     if (Token->Status == EFI_ICMP_ERROR ||
    1287         Token->Status == EFI_NETWORK_UNREACHABLE ||
    1288         Token->Status == EFI_HOST_UNREACHABLE ||
    1289         Token->Status == EFI_PROTOCOL_UNREACHABLE ||
    1290         Token->Status == EFI_PORT_UNREACHABLE) {
     1289    if ((Token->Status == EFI_ICMP_ERROR) ||
     1290        (Token->Status == EFI_NETWORK_UNREACHABLE) ||
     1291        (Token->Status == EFI_HOST_UNREACHABLE) ||
     1292        (Token->Status == EFI_PROTOCOL_UNREACHABLE) ||
     1293        (Token->Status == EFI_PORT_UNREACHABLE))
     1294    {
    12911295      break;
    12921296    }
    … …  
    12991303    // check whether this packet matches the filters
    13001304    //
    1301     RxData    = Token->Packet.RxData;
    1302     Session   = &RxData->UdpSession;
     1305    RxData  = Token->Packet.RxData;
     1306    Session = &RxData->UdpSession;
    13031307
    13041308    *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
    … …  
    13311335}
    13321336
    1333 
    13341337/**
    13351338  This function is to display the IPv4 address.
    … …  
    13401343VOID
    13411344PxeBcShowIp4Addr (
    1342   IN EFI_IPv4_ADDRESS   *Ip
    1343   )
    1344 {
    1345   UINTN                 Index;
     1345  IN EFI_IPv4_ADDRESS  *Ip
     1346  )
     1347{
     1348  UINTN  Index;
    13461349
    13471350  for (Index = 0; Index < 4; Index++) {
    … …  
    13531356}
    13541357
    1355 
    13561358/**
    13571359  This function is to display the IPv6 address.
    … …  
    13621364VOID
    13631365PxeBcShowIp6Addr (
    1364   IN EFI_IPv6_ADDRESS   *Ip
    1365   )
    1366 {
    1367   UINTN                 Index;
     1366  IN EFI_IPv6_ADDRESS  *Ip
     1367  )
     1368{
     1369  UINTN  Index;
    13681370
    13691371  for (Index = 0; Index < 16; Index++) {
    1370 
    13711372    if (Ip->Addr[Index] != 0) {
    13721373      AsciiPrint ("%x", Ip->Addr[Index]);
    13731374    }
     1375
    13741376    Index++;
    13751377    if (Index > 15) {
    13761378      return;
    13771379    }
     1380
    13781381    if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {
    13791382      AsciiPrint ("0");
    13801383    }
     1384
    13811385    AsciiPrint ("%x", Ip->Addr[Index]);
    13821386    if (Index < 15) {
    … …  
    13861390}
    13871391
    1388 
    13891392/**
    13901393  This function is to convert UINTN to ASCII string with the required formatting.
    … …  
    13971400VOID
    13981401PxeBcUintnToAscDecWithFormat (
    1399   IN UINTN                       Number,
    1400   IN UINT8                       *Buffer,
    1401   IN INTN                        Length
    1402   )
    1403 {
    1404   UINTN                          Remainder;
    1405 
    1406   for (; Length > 0; Length--) {
    1407     Remainder      = Number % 10;
    1408     Number        /= 10;
    1409     Buffer[Length - 1] = (UINT8) ('0' + Remainder);
    1410   }
    1411 }
    1412 
     1402  IN UINTN  Number,
     1403  IN UINT8  *Buffer,
     1404  IN INTN   Length
     1405  )
     1406{
     1407  UINTN  Remainder;
     1408
     1409  for ( ; Length > 0; Length--) {
     1410    Remainder          = Number % 10;
     1411    Number            /= 10;
     1412    Buffer[Length - 1] = (UINT8)('0' + Remainder);
     1413  }
     1414}
    14131415
    14141416/**
    … …  
    14251427UINTN
    14261428PxeBcUintnToAscDec (
    1427   IN UINTN               Number,
    1428   IN UINT8               *Buffer,
    1429   IN UINTN               BufferSize
    1430   )
    1431 {
    1432   UINTN           Index;
    1433   UINTN           Length;
    1434   CHAR8           TempStr[64];
    1435 
    1436   Index           = 63;
    1437   TempStr[Index]  = 0;
     1429  IN UINTN  Number,
     1430  IN UINT8  *Buffer,
     1431  IN UINTN  BufferSize
     1432  )
     1433{
     1434  UINTN  Index;
     1435  UINTN  Length;
     1436  CHAR8  TempStr[64];
     1437
     1438  Index          = 63;
     1439  TempStr[Index] = 0;
    14381440
    14391441  do {
    14401442    Index--;
    1441     TempStr[Index] = (CHAR8) ('0' + (Number % 10));
    1442     Number         = (UINTN) (Number / 10);
     1443    TempStr[Index] = (CHAR8)('0' + (Number % 10));
     1444    Number         = (UINTN)(Number / 10);
    14431445  } while (Number != 0);
    14441446
    1445   AsciiStrCpyS ((CHAR8 *) Buffer, BufferSize, &TempStr[Index]);
    1446 
    1447   Length = AsciiStrLen ((CHAR8 *) Buffer);
     1447  AsciiStrCpyS ((CHAR8 *)Buffer, BufferSize, &TempStr[Index]);
     1448
     1449  Length = AsciiStrLen ((CHAR8 *)Buffer);
    14481450
    14491451  return Length;
    14501452}
    1451 
    14521453
    14531454/**
    … …  
    14631464EFI_STATUS
    14641465PxeBcUniHexToUint8 (
    1465   OUT UINT8                *Digit,
    1466   IN  CHAR16               Char
     1466  OUT UINT8   *Digit,
     1467  IN  CHAR16  Char
    14671468  )
    14681469{
    14691470  if ((Char >= L'0') && (Char <= L'9')) {
    1470     *Digit = (UINT8) (Char - L'0');
     1471    *Digit = (UINT8)(Char - L'0');
    14711472    return EFI_SUCCESS;
    14721473  }
    14731474
    14741475  if ((Char >= L'A') && (Char <= L'F')) {
    1475     *Digit = (UINT8) (Char - L'A' + 0x0A);
     1476    *Digit = (UINT8)(Char - L'A' + 0x0A);
    14761477    return EFI_SUCCESS;
    14771478  }
    14781479
    14791480  if ((Char >= L'a') && (Char <= L'f')) {
    1480     *Digit = (UINT8) (Char - L'a' + 0x0A);
     1481    *Digit = (UINT8)(Char - L'a' + 0x0A);
    14811482    return EFI_SUCCESS;
    14821483  }
    … …  
    14931494VOID
    14941495CalcElapsedTime (
    1495   IN     PXEBC_PRIVATE_DATA     *Private
    1496   )
    1497 {
    1498   EFI_TIME          Time;
    1499   UINT64            CurrentStamp;
    1500   UINT64            ElapsedTimeValue;
     1496  IN     PXEBC_PRIVATE_DATA  *Private
     1497  )
     1498{
     1499  EFI_TIME  Time;
     1500  UINT64    CurrentStamp;
     1501  UINT64    ElapsedTimeValue;
    15011502
    15021503  //
    … …  
    15301531      ElapsedTimeValue = 0xffff;
    15311532    }
     1533
    15321534    //
    15331535    // Save the elapsed time
    … …  
    15361538  }
    15371539}
    1538 
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