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/Library/DxeIpIoLib/DxeIpIoLib.c

    r85718 r99404  
    1919#include <Library/DpcLib.h>
    2020
    21 
    2221GLOBAL_REMOVE_IF_UNREFERENCED LIST_ENTRY  mActiveIpIoList = {
    2322  &mActiveIpIoList,
    … …  
    3231  FALSE,
    3332  FALSE,
    34   {{0, 0, 0, 0}},
    35   {{0, 0, 0, 0}},
     33  {
     34    { 0,           0,  0, 0 }
     35  },
     36  {
     37    { 0,           0,  0, 0 }
     38  },
    3639  0,
    3740  255,
    … …  
    4750  TRUE,
    4851  FALSE,
    49   {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
    50   {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
     52  {
     53    { 0,           0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
     54  },
     55  {
     56    { 0,           0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
     57  },
    5158  0,
    5259  255,
    … …  
    5764
    5865GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO  mIcmpErrMap[10] = {
    59   {FALSE, TRUE }, // ICMP_ERR_UNREACH_NET
    60   {FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST
    61   {TRUE,  TRUE }, // ICMP_ERR_UNREACH_PROTOCOL
    62   {TRUE,  TRUE }, // ICMP_ERR_UNREACH_PORT
    63   {TRUE,  TRUE }, // ICMP_ERR_MSGSIZE
    64   {FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL
    65   {FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS
    66   {FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS
    67   {FALSE, FALSE}, // ICMP_ERR_QUENCH
    68   {FALSE, TRUE } // ICMP_ERR_PARAMPROB
     66  { FALSE, TRUE }, // ICMP_ERR_UNREACH_NET
     67  { FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST
     68  { TRUE,  TRUE }, // ICMP_ERR_UNREACH_PROTOCOL
     69  { TRUE,  TRUE }, // ICMP_ERR_UNREACH_PORT
     70  { TRUE,  TRUE }, // ICMP_ERR_MSGSIZE
     71  { FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL
     72  { FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS
     73  { FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS
     74  { FALSE, FALSE }, // ICMP_ERR_QUENCH
     75  { FALSE, TRUE  } // ICMP_ERR_PARAMPROB
    6976};
    7077
    7178GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO  mIcmp6ErrMap[10] = {
    72   {FALSE, TRUE}, // ICMP6_ERR_UNREACH_NET
    73   {FALSE, TRUE}, // ICMP6_ERR_UNREACH_HOST
    74   {TRUE,  TRUE}, // ICMP6_ERR_UNREACH_PROTOCOL
    75   {TRUE,  TRUE}, // ICMP6_ERR_UNREACH_PORT
    76   {TRUE,  TRUE}, // ICMP6_ERR_PACKAGE_TOOBIG
    77   {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_HOPLIMIT
    78   {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_REASS
    79   {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_HEADER
    80   {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_NEXHEADER
    81   {FALSE, TRUE}  // ICMP6_ERR_PARAMPROB_IPV6OPTION
     79  { FALSE, TRUE }, // ICMP6_ERR_UNREACH_NET
     80  { FALSE, TRUE }, // ICMP6_ERR_UNREACH_HOST
     81  { TRUE,  TRUE }, // ICMP6_ERR_UNREACH_PROTOCOL
     82  { TRUE,  TRUE }, // ICMP6_ERR_UNREACH_PORT
     83  { TRUE,  TRUE }, // ICMP6_ERR_PACKAGE_TOOBIG
     84  { FALSE, TRUE }, // ICMP6_ERR_TIMXCEED_HOPLIMIT
     85  { FALSE, TRUE }, // ICMP6_ERR_TIMXCEED_REASS
     86  { FALSE, TRUE }, // ICMP6_ERR_PARAMPROB_HEADER
     87  { FALSE, TRUE }, // ICMP6_ERR_PARAMPROB_NEXHEADER
     88  { FALSE, TRUE }  // ICMP6_ERR_PARAMPROB_IPV6OPTION
    8289};
    83 
    8490
    8591/**
    … …  
    9298EFIAPI
    9399IpIoTransmitHandlerDpc (
    94   IN VOID      *Context
     100  IN VOID  *Context
    95101  );
    96 
    97102
    98103/**
    … …  
    106111EFIAPI
    107112IpIoTransmitHandler (
    108   IN EFI_EVENT Event,
    109   IN VOID      *Context
     113  IN EFI_EVENT  Event,
     114  IN VOID       *Context
    110115  );
    111 
    112116
    113117/**
    … …  
    144148    ServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;
    145149    IpProtocolGuid     = &gEfiIp4ProtocolGuid;
    146   } else if (IpVersion == IP_VERSION_6){
     150  } else if (IpVersion == IP_VERSION_6) {
    147151    ServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;
    148152    IpProtocolGuid     = &gEfiIp6ProtocolGuid;
    … …  
    190194}
    191195
    192 
    193196/**
    194197  This function close the previously opened IP protocol and destroy the IP child.
    … …  
    266269EFI_STATUS
    267270IpIoIcmpv4Handler (
    268   IN     IP_IO                *IpIo,
    269   IN OUT NET_BUF              *Pkt,
    270   IN     EFI_NET_SESSION_DATA *Session
     271  IN     IP_IO                 *IpIo,
     272  IN OUT NET_BUF               *Pkt,
     273  IN     EFI_NET_SESSION_DATA  *Session
    271274  )
    272275{
    … …  
    292295
    293296  IcmpHdr = NET_PROTO_HDR (Pkt, IP4_ICMP_ERROR_HEAD);
    294   IpHdr   = (EFI_IP4_HEADER *) (&IcmpHdr->IpHead);
     297  IpHdr   = (EFI_IP4_HEADER *)(&IcmpHdr->IpHead);
    295298
    296299  if (Pkt->TotalSize < ICMP_ERRLEN (IpHdr)) {
    297 
    298300    return EFI_ABORTED;
    299301  }
    … …  
    306308  //
    307309  switch (Type) {
    308   case ICMP_TYPE_UNREACH:
    309     switch (Code) {
    310     case ICMP_CODE_UNREACH_NET:
    311     case ICMP_CODE_UNREACH_HOST:
    312     case ICMP_CODE_UNREACH_PROTOCOL:
    313     case ICMP_CODE_UNREACH_PORT:
    314     case ICMP_CODE_UNREACH_SRCFAIL:
    315       IcmpErr = (UINT8) (ICMP_ERR_UNREACH_NET + Code);
     310    case ICMP_TYPE_UNREACH:
     311      switch (Code) {
     312        case ICMP_CODE_UNREACH_NET:
     313        case ICMP_CODE_UNREACH_HOST:
     314        case ICMP_CODE_UNREACH_PROTOCOL:
     315        case ICMP_CODE_UNREACH_PORT:
     316        case ICMP_CODE_UNREACH_SRCFAIL:
     317          IcmpErr = (UINT8)(ICMP_ERR_UNREACH_NET + Code);
     318
     319          break;
     320
     321        case ICMP_CODE_UNREACH_NEEDFRAG:
     322          IcmpErr = ICMP_ERR_MSGSIZE;
     323
     324          break;
     325
     326        case ICMP_CODE_UNREACH_NET_UNKNOWN:
     327        case ICMP_CODE_UNREACH_NET_PROHIB:
     328        case ICMP_CODE_UNREACH_TOSNET:
     329          IcmpErr = ICMP_ERR_UNREACH_NET;
     330
     331          break;
     332
     333        case ICMP_CODE_UNREACH_HOST_UNKNOWN:
     334        case ICMP_CODE_UNREACH_ISOLATED:
     335        case ICMP_CODE_UNREACH_HOST_PROHIB:
     336        case ICMP_CODE_UNREACH_TOSHOST:
     337          IcmpErr = ICMP_ERR_UNREACH_HOST;
     338
     339          break;
     340
     341        default:
     342          return EFI_ABORTED;
     343      }
    316344
    317345      break;
    318346
    319     case ICMP_CODE_UNREACH_NEEDFRAG:
    320       IcmpErr = ICMP_ERR_MSGSIZE;
     347    case ICMP_TYPE_TIMXCEED:
     348      if (Code > 1) {
     349        return EFI_ABORTED;
     350      }
     351
     352      IcmpErr = (UINT8)(Code + ICMP_ERR_TIMXCEED_INTRANS);
    321353
    322354      break;
    323355
    324     case ICMP_CODE_UNREACH_NET_UNKNOWN:
    325     case ICMP_CODE_UNREACH_NET_PROHIB:
    326     case ICMP_CODE_UNREACH_TOSNET:
    327       IcmpErr = ICMP_ERR_UNREACH_NET;
     356    case ICMP_TYPE_PARAMPROB:
     357      if (Code > 1) {
     358        return EFI_ABORTED;
     359      }
     360
     361      IcmpErr = ICMP_ERR_PARAMPROB;
    328362
    329363      break;
    330364
    331     case ICMP_CODE_UNREACH_HOST_UNKNOWN:
    332     case ICMP_CODE_UNREACH_ISOLATED:
    333     case ICMP_CODE_UNREACH_HOST_PROHIB:
    334     case ICMP_CODE_UNREACH_TOSHOST:
    335       IcmpErr = ICMP_ERR_UNREACH_HOST;
     365    case ICMP_TYPE_SOURCEQUENCH:
     366      if (Code != 0) {
     367        return EFI_ABORTED;
     368      }
     369
     370      IcmpErr = ICMP_ERR_QUENCH;
    336371
    337372      break;
    … …  
    339374    default:
    340375      return EFI_ABORTED;
    341     }
    342 
    343     break;
    344 
    345   case ICMP_TYPE_TIMXCEED:
    346     if (Code > 1) {
    347       return EFI_ABORTED;
    348     }
    349 
    350     IcmpErr = (UINT8) (Code + ICMP_ERR_TIMXCEED_INTRANS);
    351 
    352     break;
    353 
    354   case ICMP_TYPE_PARAMPROB:
    355     if (Code > 1) {
    356       return EFI_ABORTED;
    357     }
    358 
    359     IcmpErr = ICMP_ERR_PARAMPROB;
    360 
    361     break;
    362 
    363   case ICMP_TYPE_SOURCEQUENCH:
    364     if (Code != 0) {
    365       return EFI_ABORTED;
    366     }
    367 
    368     IcmpErr = ICMP_ERR_QUENCH;
    369 
    370     break;
    371 
    372   default:
    373     return EFI_ABORTED;
    374376  }
    375377
    … …  
    378380  // IP and ICMP header
    379381  //
    380   PayLoadHdr = (UINT8 *) ((UINT8 *) IpHdr + EFI_IP4_HEADER_LEN (IpHdr));
    381   TrimBytes  = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
     382  PayLoadHdr = (UINT8 *)((UINT8 *)IpHdr + EFI_IP4_HEADER_LEN (IpHdr));
     383  TrimBytes  = (UINT32)(PayLoadHdr - (UINT8 *)IcmpHdr);
    382384
    383385  NetbufTrim (Pkt, TrimBytes, TRUE);
    … …  
    408410EFI_STATUS
    409411IpIoIcmpv6Handler (
    410   IN     IP_IO                *IpIo,
    411   IN OUT NET_BUF              *Pkt,
    412   IN     EFI_NET_SESSION_DATA *Session
     412  IN     IP_IO                 *IpIo,
     413  IN OUT NET_BUF               *Pkt,
     414  IN     EFI_NET_SESSION_DATA  *Session
    413415  )
    414416{
    … …  
    432434  //
    433435  if (Pkt->TotalSize < sizeof (IP6_ICMP_ERROR_HEAD)) {
    434 
    435436    return EFI_ABORTED;
    436437  }
    … …  
    444445  //
    445446  switch (Type) {
    446   case ICMP_V6_DEST_UNREACHABLE:
    447     switch (Code) {
    448     case ICMP_V6_NO_ROUTE_TO_DEST:
    449     case ICMP_V6_BEYOND_SCOPE:
    450     case ICMP_V6_ROUTE_REJECTED:
    451       IcmpErr = ICMP6_ERR_UNREACH_NET;
     447    case ICMP_V6_DEST_UNREACHABLE:
     448      switch (Code) {
     449        case ICMP_V6_NO_ROUTE_TO_DEST:
     450        case ICMP_V6_BEYOND_SCOPE:
     451        case ICMP_V6_ROUTE_REJECTED:
     452          IcmpErr = ICMP6_ERR_UNREACH_NET;
     453
     454          break;
     455
     456        case ICMP_V6_COMM_PROHIBITED:
     457        case ICMP_V6_ADDR_UNREACHABLE:
     458        case ICMP_V6_SOURCE_ADDR_FAILED:
     459          IcmpErr = ICMP6_ERR_UNREACH_HOST;
     460
     461          break;
     462
     463        case ICMP_V6_PORT_UNREACHABLE:
     464          IcmpErr = ICMP6_ERR_UNREACH_PORT;
     465
     466          break;
     467
     468        default:
     469          return EFI_ABORTED;
     470      }
    452471
    453472      break;
    454473
    455     case ICMP_V6_COMM_PROHIBITED:
    456     case ICMP_V6_ADDR_UNREACHABLE:
    457     case ICMP_V6_SOURCE_ADDR_FAILED:
    458       IcmpErr = ICMP6_ERR_UNREACH_HOST;
     474    case ICMP_V6_PACKET_TOO_BIG:
     475      if (Code >= 1) {
     476        return EFI_ABORTED;
     477      }
     478
     479      IcmpErr = ICMP6_ERR_PACKAGE_TOOBIG;
    459480
    460481      break;
    461482
    462     case ICMP_V6_PORT_UNREACHABLE:
    463       IcmpErr = ICMP6_ERR_UNREACH_PORT;
     483    case ICMP_V6_TIME_EXCEEDED:
     484      if (Code > 1) {
     485        return EFI_ABORTED;
     486      }
     487
     488      IcmpErr = (UINT8)(ICMP6_ERR_TIMXCEED_HOPLIMIT + Code);
    464489
    465490      break;
    466491
    467      default:
     492    case ICMP_V6_PARAMETER_PROBLEM:
     493      if (Code > 3) {
     494        return EFI_ABORTED;
     495      }
     496
     497      IcmpErr = (UINT8)(ICMP6_ERR_PARAMPROB_HEADER + Code);
     498
     499      break;
     500
     501    default:
     502
    468503      return EFI_ABORTED;
    469     }
    470 
    471     break;
    472 
    473   case ICMP_V6_PACKET_TOO_BIG:
    474     if (Code >= 1) {
    475       return EFI_ABORTED;
    476     }
    477 
    478     IcmpErr = ICMP6_ERR_PACKAGE_TOOBIG;
    479 
    480     break;
    481 
    482   case ICMP_V6_TIME_EXCEEDED:
    483     if (Code > 1) {
    484       return EFI_ABORTED;
    485     }
    486 
    487     IcmpErr = (UINT8) (ICMP6_ERR_TIMXCEED_HOPLIMIT + Code);
    488 
    489     break;
    490 
    491   case ICMP_V6_PARAMETER_PROBLEM:
    492     if (Code > 3) {
    493       return EFI_ABORTED;
    494     }
    495 
    496     IcmpErr = (UINT8) (ICMP6_ERR_PARAMPROB_HEADER + Code);
    497 
    498     break;
    499 
    500    default:
    501 
    502      return EFI_ABORTED;
    503    }
     504  }
    504505
    505506  //
    … …  
    508509  //
    509510
    510   IpHdr      = (EFI_IP6_HEADER *) (&IcmpHdr->IpHead);
     511  IpHdr      = (EFI_IP6_HEADER *)(&IcmpHdr->IpHead);
    511512  NextHeader = IpHdr->NextHeader;
    512   PayLoadHdr = (UINT8 *) ((UINT8 *) IcmpHdr + sizeof (IP6_ICMP_ERROR_HEAD));
     513  PayLoadHdr = (UINT8 *)((UINT8 *)IcmpHdr + sizeof (IP6_ICMP_ERROR_HEAD));
    513514  Flag       = TRUE;
    514515
    515516  do {
    516517    switch (NextHeader) {
    517     case EFI_IP_PROTO_UDP:
    518     case EFI_IP_PROTO_TCP:
    519     case EFI_IP_PROTO_ICMP:
    520     case IP6_NO_NEXT_HEADER:
    521       Flag = FALSE;
    522 
    523       break;
    524 
    525     case IP6_HOP_BY_HOP:
    526     case IP6_DESTINATION:
    527       //
    528       // The Hdr Ext Len is 8-bit unsigned integer in 8-octet units, not including
    529       // the first 8 octets.
    530       //
    531       NextHeader = *(PayLoadHdr);
    532       PayLoadHdr = (UINT8 *) (PayLoadHdr + (*(PayLoadHdr + 1) + 1) * 8);
    533 
    534       break;
    535 
    536     case IP6_FRAGMENT:
    537       //
    538       // The Fragment Header Length is 8 octets.
    539       //
    540       NextHeader = *(PayLoadHdr);
    541       PayLoadHdr = (UINT8 *) (PayLoadHdr + 8);
    542 
    543       break;
    544 
    545     default:
    546 
    547       return EFI_ABORTED;
     518      case EFI_IP_PROTO_UDP:
     519      case EFI_IP_PROTO_TCP:
     520      case EFI_IP_PROTO_ICMP:
     521      case IP6_NO_NEXT_HEADER:
     522        Flag = FALSE;
     523
     524        break;
     525
     526      case IP6_HOP_BY_HOP:
     527      case IP6_DESTINATION:
     528        //
     529        // The Hdr Ext Len is 8-bit unsigned integer in 8-octet units, not including
     530        // the first 8 octets.
     531        //
     532        NextHeader = *(PayLoadHdr);
     533        PayLoadHdr = (UINT8 *)(PayLoadHdr + (*(PayLoadHdr + 1) + 1) * 8);
     534
     535        break;
     536
     537      case IP6_FRAGMENT:
     538        //
     539        // The Fragment Header Length is 8 octets.
     540        //
     541        NextHeader = *(PayLoadHdr);
     542        PayLoadHdr = (UINT8 *)(PayLoadHdr + 8);
     543
     544        break;
     545
     546      default:
     547
     548        return EFI_ABORTED;
    548549    }
    549550  } while (Flag);
    550551
    551   TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
     552  TrimBytes = (UINT32)(PayLoadHdr - (UINT8 *)IcmpHdr);
    552553
    553554  NetbufTrim (Pkt, TrimBytes, TRUE);
    … …  
    578579EFI_STATUS
    579580IpIoIcmpHandler (
    580   IN     IP_IO                *IpIo,
    581   IN OUT NET_BUF              *Pkt,
    582   IN     EFI_NET_SESSION_DATA *Session
    583   )
    584 {
    585 
     581  IN     IP_IO                 *IpIo,
     582  IN OUT NET_BUF               *Pkt,
     583  IN     EFI_NET_SESSION_DATA  *Session
     584  )
     585{
    586586  if (IpIo->IpVersion == IP_VERSION_4) {
    587 
    588587    return IpIoIcmpv4Handler (IpIo, Pkt, Session);
    589 
    590588  } else if (IpIo->IpVersion == IP_VERSION_6) {
    591 
    592589    return IpIoIcmpv6Handler (IpIo, Pkt, Session);
    593 
    594   } else {
    595 
     590  } else {
    596591    return EFI_UNSUPPORTED;
    597592  }
    598593}
    599 
    600594
    601595/**
    … …  
    613607  )
    614608{
    615   gBS->SignalEvent ((EFI_EVENT) Event);
    616 }
    617 
     609  gBS->SignalEvent ((EFI_EVENT)Event);
     610}
    618611
    619612/**
    … …  
    635628IP_IO_SEND_ENTRY *
    636629IpIoCreateSndEntry (
    637   IN OUT IP_IO             *IpIo,
    638   IN OUT NET_BUF           *Pkt,
    639   IN     IP_IO_IP_PROTOCOL Sender,
    640   IN     VOID              *Context    OPTIONAL,
    641   IN     VOID              *NotifyData OPTIONAL,
    642   IN     EFI_IP_ADDRESS    *Dest       OPTIONAL,
    643   IN     IP_IO_OVERRIDE    *Override
    644   )
    645 {
    646   IP_IO_SEND_ENTRY          *SndEntry;
    647   EFI_EVENT                 Event;
    648   EFI_STATUS                Status;
    649   NET_FRAGMENT              *ExtFragment;
    650   UINT32                    FragmentCount;
    651   IP_IO_OVERRIDE            *OverrideData;
    652   IP_IO_IP_TX_DATA          *TxData;
    653   EFI_IP4_TRANSMIT_DATA     *Ip4TxData;
    654   EFI_IP6_TRANSMIT_DATA     *Ip6TxData;
     630  IN OUT IP_IO              *IpIo,
     631  IN OUT NET_BUF            *Pkt,
     632  IN     IP_IO_IP_PROTOCOL  Sender,
     633  IN     VOID               *Context    OPTIONAL,
     634  IN     VOID               *NotifyData OPTIONAL,
     635  IN     EFI_IP_ADDRESS     *Dest       OPTIONAL,
     636  IN     IP_IO_OVERRIDE     *Override
     637  )
     638{
     639  IP_IO_SEND_ENTRY       *SndEntry;
     640  EFI_EVENT              Event;
     641  EFI_STATUS             Status;
     642  NET_FRAGMENT           *ExtFragment;
     643  UINT32                 FragmentCount;
     644  IP_IO_OVERRIDE         *OverrideData;
     645  IP_IO_IP_TX_DATA       *TxData;
     646  EFI_IP4_TRANSMIT_DATA  *Ip4TxData;
     647  EFI_IP6_TRANSMIT_DATA  *Ip6TxData;
    655648
    656649  if ((IpIo->IpVersion != IP_VERSION_4) && (IpIo->IpVersion != IP_VERSION_6)) {
    … …  
    686679  // Allocate resource for TxData
    687680  //
    688   TxData = (IP_IO_IP_TX_DATA *) AllocatePool (
    689     sizeof (IP_IO_IP_TX_DATA) + sizeof (NET_FRAGMENT) * (FragmentCount - 1)
    690     );
     681  TxData = (IP_IO_IP_TX_DATA *)AllocatePool (
     682                                 sizeof (IP_IO_IP_TX_DATA) + sizeof (NET_FRAGMENT) * (FragmentCount - 1)
     683                                 );
    691684
    692685  if (NULL == TxData) {
    … …  
    698691  //
    699692  if (IpIo->IpVersion == IP_VERSION_4) {
    700     ExtFragment = (NET_FRAGMENT *) TxData->Ip4TxData.FragmentTable;
    701   } else {
    702     ExtFragment = (NET_FRAGMENT *) TxData->Ip6TxData.FragmentTable;
     693    ExtFragment = (NET_FRAGMENT *)TxData->Ip4TxData.FragmentTable;
     694  } else {
     695    ExtFragment = (NET_FRAGMENT *)TxData->Ip6TxData.FragmentTable;
    703696  }
    704697
    705698  NetbufBuildExt (Pkt, ExtFragment, &FragmentCount);
    706699
    707 
    708700  //
    709701  // Allocate resource for OverrideData if needed
    710702  //
    711703  if (NULL != Override) {
    712 
    713704    OverrideData = AllocateCopyPool (sizeof (IP_IO_OVERRIDE), Override);
    714705    if (NULL == OverrideData) {
    … …  
    721712  //
    722713  if (IpIo->IpVersion == IP_VERSION_4) {
    723 
    724714    Ip4TxData = &TxData->Ip4TxData;
    725715
    … …  
    738728    SndEntry->SndToken.Ip4Token.Packet.TxData = Ip4TxData;
    739729  } else {
    740 
    741730    Ip6TxData = &TxData->Ip6TxData;
    742731
    … …  
    763752  // Set the fields of SndEntry
    764753  //
    765   SndEntry->IpIo        = IpIo;
    766   SndEntry->Ip          = Sender;
    767   SndEntry->Context     = Context;
    768   SndEntry->NotifyData  = NotifyData;
    769 
    770   SndEntry->Pkt         = Pkt;
     754  SndEntry->IpIo       = IpIo;
     755  SndEntry->Ip         = Sender;
     756  SndEntry->Context    = Context;
     757  SndEntry->NotifyData = NotifyData;
     758
     759  SndEntry->Pkt = Pkt;
    771760  NET_GET_REF (Pkt);
    772761
    … …  
    795784  return NULL;
    796785}
    797 
    798786
    799787/**
    … …  
    815803
    816804  if (SndEntry->IpIo->IpVersion == IP_VERSION_4) {
    817     Event              = SndEntry->SndToken.Ip4Token.Event;
    818     TxData             = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip4Token.Packet.TxData;
    819     Override           = (IP_IO_OVERRIDE *) TxData->Ip4TxData.OverrideData;
     805    Event    = SndEntry->SndToken.Ip4Token.Event;
     806    TxData   = (IP_IO_IP_TX_DATA *)SndEntry->SndToken.Ip4Token.Packet.TxData;
     807    Override = (IP_IO_OVERRIDE *)TxData->Ip4TxData.OverrideData;
    820808  } else if (SndEntry->IpIo->IpVersion == IP_VERSION_6) {
    821     Event              = SndEntry->SndToken.Ip6Token.Event;
    822     TxData             = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip6Token.Packet.TxData;
    823     Override           = (IP_IO_OVERRIDE *) TxData->Ip6TxData.OverrideData;
    824   } else {
    825     return ;
     809    Event    = SndEntry->SndToken.Ip6Token.Event;
     810    TxData   = (IP_IO_IP_TX_DATA *)SndEntry->SndToken.Ip6Token.Packet.TxData;
     811    Override = (IP_IO_OVERRIDE *)TxData->Ip6TxData.OverrideData;
     812  } else {
     813    return;
    826814  }
    827815
    … …  
    840828  FreePool (SndEntry);
    841829}
    842 
    843830
    844831/**
    … …  
    851838EFIAPI
    852839IpIoTransmitHandlerDpc (
    853   IN VOID      *Context
     840  IN VOID  *Context
    854841  )
    855842{
    … …  
    858845  EFI_STATUS        Status;
    859846
    860   SndEntry  = (IP_IO_SEND_ENTRY *) Context;
    861 
    862   IpIo      = SndEntry->IpIo;
     847  SndEntry = (IP_IO_SEND_ENTRY *)Context;
     848
     849  IpIo = SndEntry->IpIo;
    863850
    864851  if (IpIo->IpVersion == IP_VERSION_4) {
    865852    Status = SndEntry->SndToken.Ip4Token.Status;
    866   } else if (IpIo->IpVersion == IP_VERSION_6){
     853  } else if (IpIo->IpVersion == IP_VERSION_6) {
    867854    Status = SndEntry->SndToken.Ip6Token.Status;
    868855  } else {
    869     return ;
     856    return;
    870857  }
    871858
    … …  
    882869}
    883870
    884 
    885871/**
    886872  Notify function for IP transmit token.
    … …  
    893879EFIAPI
    894880IpIoTransmitHandler (
    895   IN EFI_EVENT Event,
    896   IN VOID      *Context
     881  IN EFI_EVENT  Event,
     882  IN VOID       *Context
    897883  )
    898884{
    … …  
    902888  QueueDpc (TPL_CALLBACK, IpIoTransmitHandlerDpc, Context);
    903889}
    904 
    905890
    906891/**
    … …  
    913898EFIAPI
    914899IpIoDummyHandlerDpc (
    915   IN VOID      *Context
    916   )
    917 {
    918   IP_IO_IP_INFO             *IpInfo;
    919   EFI_STATUS                 Status;
    920   EFI_EVENT                  RecycleEvent;
    921 
    922   IpInfo      = (IP_IO_IP_INFO *) Context;
     900  IN VOID  *Context
     901  )
     902{
     903  IP_IO_IP_INFO  *IpInfo;
     904  EFI_STATUS     Status;
     905  EFI_EVENT      RecycleEvent;
     906
     907  IpInfo = (IP_IO_IP_INFO *)Context;
    923908
    924909  if ((IpInfo->IpVersion != IP_VERSION_4) && (IpInfo->IpVersion != IP_VERSION_6)) {
    925     return ;
     910    return;
    926911  }
    927912
    … …  
    941926    }
    942927  }
    943 
    944 
    945928
    946929  if (EFI_ABORTED == Status) {
    … …  
    974957}
    975958
    976 
    977959/**
    978960  This function add IpIoDummyHandlerDpc to the end of the DPC queue.
    … …  
    985967EFIAPI
    986968IpIoDummyHandler (
    987   IN EFI_EVENT Event,
    988   IN VOID      *Context
     969  IN EFI_EVENT  Event,
     970  IN VOID       *Context
    989971  )
    990972{
    … …  
    994976  QueueDpc (TPL_CALLBACK, IpIoDummyHandlerDpc, Context);
    995977}
    996 
    997978
    998979/**
    … …  
    1006987EFIAPI
    1007988IpIoListenHandlerDpc (
    1008   IN VOID      *Context
     989  IN VOID  *Context
    1009990  )
    1010991{
    … …  
    1015996  NET_BUF               *Pkt;
    1016997
    1017   IpIo = (IP_IO *) Context;
     998  IpIo = (IP_IO *)Context;
    1018999
    10191000  if (IpIo->IpVersion == IP_VERSION_4) {
    10201001    Status = IpIo->RcvToken.Ip4Token.Status;
    1021     RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip4Token.Packet.RxData;
     1002    RxData = (IP_IO_IP_RX_DATA *)IpIo->RcvToken.Ip4Token.Packet.RxData;
    10221003  } else if (IpIo->IpVersion == IP_VERSION_6) {
    10231004    Status = IpIo->RcvToken.Ip6Token.Status;
    1024     RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip6Token.Packet.RxData;
     1005    RxData = (IP_IO_IP_RX_DATA *)IpIo->RcvToken.Ip6Token.Packet.RxData;
    10251006  } else {
    10261007    return;
    … …  
    10651046      goto CleanUp;
    10661047    }
     1048
    10671049    if ((EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress) != 0) &&
    10681050        (IpIo->SubnetMask != 0) &&
    1069         IP4_NET_EQUAL (IpIo->StationIp, EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *) RxData)->Header->SourceAddress), IpIo->SubnetMask) &&
    1070         !NetIp4IsUnicast (EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *) RxData)->Header->SourceAddress), IpIo->SubnetMask)) {
     1051        IP4_NET_EQUAL (IpIo->StationIp, EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *)RxData)->Header->SourceAddress), IpIo->SubnetMask) &&
     1052        !NetIp4IsUnicast (EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *)RxData)->Header->SourceAddress), IpIo->SubnetMask))
     1053    {
    10711054      //
    10721055      // The source address doesn't match StationIp and it's not a unicast IP address, discard it.
    … …  
    10911074    //
    10921075    Pkt = NetbufFromExt (
    1093             (NET_FRAGMENT *) RxData->Ip4RxData.FragmentTable,
     1076            (NET_FRAGMENT *)RxData->Ip4RxData.FragmentTable,
    10941077            RxData->Ip4RxData.FragmentCount,
    10951078            0,
    … …  
    11121095  } else {
    11131096    ASSERT (RxData->Ip6RxData.Header != NULL);
    1114     if (!NetIp6IsValidUnicast(&RxData->Ip6RxData.Header->SourceAddress)) {
     1097    if (!NetIp6IsValidUnicast (&RxData->Ip6RxData.Header->SourceAddress)) {
    11151098      goto CleanUp;
    11161099    }
    … …  
    11321115    //
    11331116    Pkt = NetbufFromExt (
    1134             (NET_FRAGMENT *) RxData->Ip6RxData.FragmentTable,
     1117            (NET_FRAGMENT *)RxData->Ip6RxData.FragmentTable,
    11351118            RxData->Ip6RxData.FragmentCount,
    11361119            0,
    … …  
    11491132      &Session.Source,
    11501133      &RxData->Ip6RxData.Header->SourceAddress,
    1151       sizeof(EFI_IPv6_ADDRESS)
     1134      sizeof (EFI_IPv6_ADDRESS)
    11521135      );
    11531136    CopyMem (
    11541137      &Session.Dest,
    11551138      &RxData->Ip6RxData.Header->DestinationAddress,
    1156       sizeof(EFI_IPv6_ADDRESS)
     1139      sizeof (EFI_IPv6_ADDRESS)
    11571140      );
    11581141    Session.IpHdr.Ip6Hdr = RxData->Ip6RxData.Header;
    … …  
    11621145
    11631146  if (EFI_SUCCESS == Status) {
    1164 
    11651147    IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);
    11661148  } else {
    … …  
    11781160CleanUp:
    11791161
    1180   if (IpIo->IpVersion == IP_VERSION_4){
     1162  if (IpIo->IpVersion == IP_VERSION_4) {
    11811163    gBS->SignalEvent (RxData->Ip4RxData.RecycleSignal);
    11821164  } else {
    … …  
    11861168Resume:
    11871169
    1188   if (IpIo->IpVersion == IP_VERSION_4){
     1170  if (IpIo->IpVersion == IP_VERSION_4) {
    11891171    IpIo->Ip.Ip4->Receive (IpIo->Ip.Ip4, &(IpIo->RcvToken.Ip4Token));
    11901172  } else {
    … …  
    12031185EFIAPI
    12041186IpIoListenHandler (
    1205   IN EFI_EVENT Event,
    1206   IN VOID      *Context
     1187  IN EFI_EVENT  Event,
     1188  IN VOID       *Context
    12071189  )
    12081190{
    … …  
    12121194  QueueDpc (TPL_CALLBACK, IpIoListenHandlerDpc, Context);
    12131195}
    1214 
    12151196
    12161197/**
    … …  
    12351216EFIAPI
    12361217IpIoCreate (
    1237   IN EFI_HANDLE Image,
    1238   IN EFI_HANDLE Controller,
    1239   IN UINT8      IpVersion
     1218  IN EFI_HANDLE  Image,
     1219  IN EFI_HANDLE  Controller,
     1220  IN UINT8       IpVersion
    12401221  )
    12411222{
    … …  
    12531234  InitializeListHead (&(IpIo->PendingSndList));
    12541235  InitializeListHead (&(IpIo->IpList));
    1255   IpIo->Controller  = Controller;
    1256   IpIo->Image       = Image;
    1257   IpIo->IpVersion   = IpVersion;
    1258   Event             = NULL;
     1236  IpIo->Controller = Controller;
     1237  IpIo->Image      = Image;
     1238  IpIo->IpVersion  = IpVersion;
     1239  Event            = NULL;
    12591240
    12601241  Status = gBS->CreateEvent (
    … …  
    12831264             &IpIo->ChildHandle,
    12841265             IpVersion,
    1285              (VOID **) & (IpIo->Ip)
     1266             (VOID **)&(IpIo->Ip)
    12861267             );
    12871268  if (EFI_ERROR (Status)) {
    … …  
    13011282  return NULL;
    13021283}
    1303 
    13041284
    13051285/**
    … …  
    13291309EFIAPI
    13301310IpIoOpen (
    1331   IN OUT IP_IO           *IpIo,
    1332   IN     IP_IO_OPEN_DATA *OpenData
    1333   )
    1334 {
    1335   EFI_STATUS        Status;
    1336   UINT8             IpVersion;
    1337 
    1338   if (IpIo == NULL || OpenData == NULL) {
     1311  IN OUT IP_IO            *IpIo,
     1312  IN     IP_IO_OPEN_DATA  *OpenData
     1313  )
     1314{
     1315  EFI_STATUS  Status;
     1316  UINT8       IpVersion;
     1317
     1318  if ((IpIo == NULL) || (OpenData == NULL)) {
    13391319    return EFI_INVALID_PARAMETER;
    13401320  }
    … …  
    13511331  // configure ip
    13521332  //
    1353   if (IpVersion == IP_VERSION_4){
     1333  if (IpVersion == IP_VERSION_4) {
    13541334    //
    13551335    // RawData mode is no supported.
    … …  
    13611341
    13621342    if (!OpenData->IpConfigData.Ip4CfgData.UseDefaultAddress) {
    1363       IpIo->StationIp = EFI_NTOHL (OpenData->IpConfigData.Ip4CfgData.StationAddress);
     1343      IpIo->StationIp  = EFI_NTOHL (OpenData->IpConfigData.Ip4CfgData.StationAddress);
    13641344      IpIo->SubnetMask = EFI_NTOHL (OpenData->IpConfigData.Ip4CfgData.SubnetMask);
    13651345    }
    … …  
    13701350                             );
    13711351  } else {
    1372 
    13731352    Status = IpIo->Ip.Ip6->Configure (
    13741353                             IpIo->Ip.Ip6,
    … …  
    13861365  // @bug its code
    13871366  //
    1388   if (IpVersion == IP_VERSION_4){
     1367  if (IpVersion == IP_VERSION_4) {
    13891368    Status = IpIo->Ip.Ip4->Routes (
    13901369                             IpIo->Ip.Ip4,
    … …  
    14031382  IpIo->PktSentNotify = OpenData->PktSentNotify;
    14041383
    1405   IpIo->RcvdContext   = OpenData->RcvdContext;
    1406   IpIo->SndContext    = OpenData->SndContext;
    1407 
    1408   if (IpVersion == IP_VERSION_4){
     1384  IpIo->RcvdContext = OpenData->RcvdContext;
     1385  IpIo->SndContext  = OpenData->SndContext;
     1386
     1387  if (IpVersion == IP_VERSION_4) {
    14091388    IpIo->Protocol = OpenData->IpConfigData.Ip4CfgData.DefaultProtocol;
    14101389
    … …  
    14201399      return Status;
    14211400    }
    1422 
    1423   } else {
    1424 
     1401  } else {
    14251402    IpIo->Protocol = OpenData->IpConfigData.Ip6CfgData.DefaultProtocol;
    1426     Status = IpIo->Ip.Ip6->Receive (
    1427                              IpIo->Ip.Ip6,
    1428                              &(IpIo->RcvToken.Ip6Token)
    1429                              );
     1403    Status         = IpIo->Ip.Ip6->Receive (
     1404                                     IpIo->Ip.Ip6,
     1405                                     &(IpIo->RcvToken.Ip6Token)
     1406                                     );
    14301407    if (EFI_ERROR (Status)) {
    14311408      IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);
    … …  
    14401417}
    14411418
    1442 
    14431419/**
    14441420  Stop an IP_IO instance.
    … …  
    14591435EFIAPI
    14601436IpIoStop (
    1461   IN OUT IP_IO *IpIo
    1462   )
    1463 {
    1464   EFI_STATUS        Status;
    1465   IP_IO_IP_INFO     *IpInfo;
    1466   UINT8             IpVersion;
     1437  IN OUT IP_IO  *IpIo
     1438  )
     1439{
     1440  EFI_STATUS     Status;
     1441  IP_IO_IP_INFO  *IpInfo;
     1442  UINT8          IpVersion;
    14671443
    14681444  if (IpIo == NULL) {
    … …  
    14911467    Status = IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);
    14921468  }
     1469
    14931470  if (EFI_ERROR (Status)) {
    14941471    return Status;
    … …  
    15151492  // Close the receive event.
    15161493  //
    1517   if (IpVersion == IP_VERSION_4){
     1494  if (IpVersion == IP_VERSION_4) {
    15181495    gBS->CloseEvent (IpIo->RcvToken.Ip4Token.Event);
    15191496  } else {
    … …  
    15231500  return EFI_SUCCESS;
    15241501}
    1525 
    15261502
    15271503/**
    … …  
    15411517EFIAPI
    15421518IpIoDestroy (
    1543   IN OUT IP_IO *IpIo
    1544   )
    1545 {
    1546   EFI_STATUS    Status;
     1519  IN OUT IP_IO  *IpIo
     1520  )
     1521{
     1522  EFI_STATUS  Status;
    15471523
    15481524  //
    … …  
    15711547  return EFI_SUCCESS;
    15721548}
    1573 
    15741549
    15751550/**
    … …  
    16021577EFIAPI
    16031578IpIoSend (
    1604   IN OUT IP_IO          *IpIo,
    1605   IN OUT NET_BUF        *Pkt,
    1606   IN     IP_IO_IP_INFO  *Sender        OPTIONAL,
    1607   IN     VOID           *Context       OPTIONAL,
    1608   IN     VOID           *NotifyData    OPTIONAL,
    1609   IN     EFI_IP_ADDRESS *Dest          OPTIONAL,
    1610   IN     IP_IO_OVERRIDE *OverrideData  OPTIONAL
    1611   )
    1612 {
    1613   EFI_STATUS        Status;
    1614   IP_IO_IP_PROTOCOL Ip;
    1615   IP_IO_SEND_ENTRY  *SndEntry;
     1579  IN OUT IP_IO           *IpIo,
     1580  IN OUT NET_BUF         *Pkt,
     1581  IN     IP_IO_IP_INFO   *Sender        OPTIONAL,
     1582  IN     VOID            *Context       OPTIONAL,
     1583  IN     VOID            *NotifyData    OPTIONAL,
     1584  IN     EFI_IP_ADDRESS  *Dest          OPTIONAL,
     1585  IN     IP_IO_OVERRIDE  *OverrideData  OPTIONAL
     1586  )
     1587{
     1588  EFI_STATUS         Status;
     1589  IP_IO_IP_PROTOCOL  Ip;
     1590  IP_IO_SEND_ENTRY   *SndEntry;
    16161591
    16171592  if ((IpIo == NULL) || (Pkt == NULL)) {
    … …  
    16401615  // Send this Packet
    16411616  //
    1642   if (IpIo->IpVersion == IP_VERSION_4){
     1617  if (IpIo->IpVersion == IP_VERSION_4) {
    16431618    Status = Ip.Ip4->Transmit (
    16441619                       Ip.Ip4,
    … …  
    16581633  return Status;
    16591634}
    1660 
    16611635
    16621636/**
    … …  
    16771651  )
    16781652{
    1679   LIST_ENTRY        *Node;
    1680   IP_IO_SEND_ENTRY  *SndEntry;
    1681   IP_IO_IP_PROTOCOL Ip;
     1653  LIST_ENTRY         *Node;
     1654  IP_IO_SEND_ENTRY   *SndEntry;
     1655  IP_IO_IP_PROTOCOL  Ip;
    16821656
    16831657  ASSERT ((IpIo != NULL) && (Packet != NULL));
    16841658
    16851659  NET_LIST_FOR_EACH (Node, &IpIo->PendingSndList) {
    1686 
    16871660    SndEntry = NET_LIST_USER_STRUCT (Node, IP_IO_SEND_ENTRY, Entry);
    16881661
    16891662    if (SndEntry->Pkt == Packet) {
    1690 
    16911663      Ip = SndEntry->Ip;
    16921664
    … …  
    17061678    }
    17071679  }
    1708 
    1709 }
    1710 
     1680}
    17111681
    17121682/**
    … …  
    17641734             &IpInfo->ChildHandle,
    17651735             IpInfo->IpVersion,
    1766              (VOID **) &IpInfo->Ip
     1736             (VOID **)&IpInfo->Ip
    17671737             );
    17681738  if (EFI_ERROR (Status)) {
    … …  
    18131783}
    18141784
    1815 
    18161785/**
    18171786  Configure the IP instance of this IpInfo and start the receiving if IpConfigData
    … …  
    18361805EFIAPI
    18371806IpIoConfigIp (
    1838   IN OUT IP_IO_IP_INFO        *IpInfo,
    1839   IN OUT VOID                 *IpConfigData OPTIONAL
     1807  IN OUT IP_IO_IP_INFO  *IpInfo,
     1808  IN OUT VOID           *IpConfigData OPTIONAL
    18401809  )
    18411810{
    … …  
    18751844  if (IpConfigData != NULL) {
    18761845    if (IpInfo->IpVersion == IP_VERSION_4) {
    1877 
    1878       if (((EFI_IP4_CONFIG_DATA *) IpConfigData)->UseDefaultAddress) {
     1846      if (((EFI_IP4_CONFIG_DATA *)IpConfigData)->UseDefaultAddress) {
    18791847        Status = Ip.Ip4->GetModeData (
    18801848                           Ip.Ip4,
    … …  
    18881856        }
    18891857
    1890         IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->StationAddress, &Ip4ModeData.ConfigData.StationAddress);
    1891         IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->SubnetMask, &Ip4ModeData.ConfigData.SubnetMask);
     1858        IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA *)IpConfigData)->StationAddress, &Ip4ModeData.ConfigData.StationAddress);
     1859        IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA *)IpConfigData)->SubnetMask, &Ip4ModeData.ConfigData.SubnetMask);
    18921860      }
    18931861
    18941862      CopyMem (
    18951863        &IpInfo->Addr.Addr,
    1896         &((EFI_IP4_CONFIG_DATA *) IpConfigData)->StationAddress,
     1864        &((EFI_IP4_CONFIG_DATA *)IpConfigData)->StationAddress,
    18971865        sizeof (IP4_ADDR)
    18981866        );
    18991867      CopyMem (
    19001868        &IpInfo->PreMask.SubnetMask,
    1901         &((EFI_IP4_CONFIG_DATA *) IpConfigData)->SubnetMask,
     1869        &((EFI_IP4_CONFIG_DATA *)IpConfigData)->SubnetMask,
    19021870        sizeof (IP4_ADDR)
    19031871        );
    … …  
    19241892      if (Ip6ModeData.IsConfigured) {
    19251893        CopyMem (
    1926           &((EFI_IP6_CONFIG_DATA *) IpConfigData)->StationAddress,
     1894          &((EFI_IP6_CONFIG_DATA *)IpConfigData)->StationAddress,
    19271895          &Ip6ModeData.ConfigData.StationAddress,
    19281896          sizeof (EFI_IPv6_ADDRESS)
    … …  
    19521920          FreePool (Ip6ModeData.IcmpTypeList);
    19531921        }
    1954 
    19551922      } else {
    19561923        Status = EFI_NO_MAPPING;
    … …  
    19831950}
    19841951
    1985 
    19861952/**
    19871953  Destroy an IP instance maintained in IpIo->IpList for
    … …  
    20011967EFIAPI
    20021968IpIoRemoveIp (
    2003   IN IP_IO            *IpIo,
    2004   IN IP_IO_IP_INFO    *IpInfo
    2005   )
    2006 {
    2007 
    2008   UINT8               IpVersion;
    2009 
    2010   if (IpIo == NULL || IpInfo == NULL) {
     1969  IN IP_IO          *IpIo,
     1970  IN IP_IO_IP_INFO  *IpInfo
     1971  )
     1972{
     1973  UINT8  IpVersion;
     1974
     1975  if ((IpIo == NULL) || (IpInfo == NULL)) {
    20111976    return;
    20121977  }
    … …  
    20171982
    20181983  if (IpInfo->RefCnt > 0) {
    2019 
    20201984    return;
    20211985  }
    … …  
    20271991  RemoveEntryList (&IpInfo->Entry);
    20281992
    2029   if (IpVersion == IP_VERSION_4){
     1993  if (IpVersion == IP_VERSION_4) {
    20301994    IpInfo->Ip.Ip4->Configure (
    20311995                      IpInfo->Ip.Ip4,
    … …  
    20402004
    20412005    gBS->CloseEvent (IpInfo->DummyRcvToken.Ip4Token.Event);
    2042 
    2043   } else {
    2044 
     2006  } else {
    20452007    IpInfo->Ip.Ip6->Configure (
    20462008                      IpInfo->Ip.Ip6,
    … …  
    20612023}
    20622024
    2063 
    20642025/**
    20652026  Find the first IP protocol maintained in IpIo whose local
    … …  
    20862047  )
    20872048{
    2088   LIST_ENTRY      *IpIoEntry;
    2089   IP_IO           *IpIoPtr;
    2090   LIST_ENTRY      *IpInfoEntry;
    2091   IP_IO_IP_INFO   *IpInfo;
    2092 
    2093   if (IpIo == NULL || Src == NULL) {
     2049  LIST_ENTRY     *IpIoEntry;
     2050  IP_IO          *IpIoPtr;
     2051  LIST_ENTRY     *IpInfoEntry;
     2052  IP_IO_IP_INFO  *IpInfo;
     2053
     2054  if ((IpIo == NULL) || (Src == NULL)) {
    20942055    return NULL;
    20952056  }
    … …  
    21082069    NET_LIST_FOR_EACH (IpInfoEntry, &IpIoPtr->IpList) {
    21092070      IpInfo = NET_LIST_USER_STRUCT (IpInfoEntry, IP_IO_IP_INFO, Entry);
    2110       if (IpInfo->IpVersion == IP_VERSION_4){
    2111 
     2071      if (IpInfo->IpVersion == IP_VERSION_4) {
    21122072        if (EFI_IP4_EQUAL (&IpInfo->Addr.v4, &Src->v4)) {
    21132073          *IpIo = IpIoPtr;
    21142074          return IpInfo;
    21152075        }
    2116 
    21172076      } else {
    2118 
    21192077        if (EFI_IP6_EQUAL (&IpInfo->Addr.v6, &Src->v6)) {
    21202078          *IpIo = IpIoPtr;
    … …  
    21312089}
    21322090
    2133 
    21342091/**
    21352092  Get the ICMP error map information.
    … …  
    21512108EFIAPI
    21522109IpIoGetIcmpErrStatus (
    2153   IN  UINT8       IcmpError,
    2154   IN  UINT8       IpVersion,
    2155   OUT BOOLEAN     *IsHard  OPTIONAL,
    2156   OUT BOOLEAN     *Notify  OPTIONAL
     2110  IN  UINT8    IcmpError,
     2111  IN  UINT8    IpVersion,
     2112  OUT BOOLEAN  *IsHard  OPTIONAL,
     2113  OUT BOOLEAN  *Notify  OPTIONAL
    21572114  )
    21582115{
    … …  
    21692126
    21702127    switch (IcmpError) {
    2171     case ICMP_ERR_UNREACH_NET:
    2172       return  EFI_NETWORK_UNREACHABLE;
    2173 
    2174     case ICMP_ERR_TIMXCEED_INTRANS:
    2175     case ICMP_ERR_TIMXCEED_REASS:
    2176     case ICMP_ERR_UNREACH_HOST:
    2177       return  EFI_HOST_UNREACHABLE;
    2178 
    2179     case ICMP_ERR_UNREACH_PROTOCOL:
    2180       return  EFI_PROTOCOL_UNREACHABLE;
    2181 
    2182     case ICMP_ERR_UNREACH_PORT:
    2183       return  EFI_PORT_UNREACHABLE;
    2184 
    2185     case ICMP_ERR_MSGSIZE:
    2186     case ICMP_ERR_UNREACH_SRCFAIL:
    2187     case ICMP_ERR_QUENCH:
    2188     case ICMP_ERR_PARAMPROB:
    2189       return  EFI_ICMP_ERROR;
    2190 
    2191     default:
    2192       ASSERT (FALSE);
    2193       return EFI_UNSUPPORTED;
    2194     }
    2195 
     2128      case ICMP_ERR_UNREACH_NET:
     2129        return EFI_NETWORK_UNREACHABLE;
     2130
     2131      case ICMP_ERR_TIMXCEED_INTRANS:
     2132      case ICMP_ERR_TIMXCEED_REASS:
     2133      case ICMP_ERR_UNREACH_HOST:
     2134        return EFI_HOST_UNREACHABLE;
     2135
     2136      case ICMP_ERR_UNREACH_PROTOCOL:
     2137        return EFI_PROTOCOL_UNREACHABLE;
     2138
     2139      case ICMP_ERR_UNREACH_PORT:
     2140        return EFI_PORT_UNREACHABLE;
     2141
     2142      case ICMP_ERR_MSGSIZE:
     2143      case ICMP_ERR_UNREACH_SRCFAIL:
     2144      case ICMP_ERR_QUENCH:
     2145      case ICMP_ERR_PARAMPROB:
     2146        return EFI_ICMP_ERROR;
     2147
     2148      default:
     2149        ASSERT (FALSE);
     2150        return EFI_UNSUPPORTED;
     2151    }
    21962152  } else if (IpVersion == IP_VERSION_6) {
    2197 
    21982153    ASSERT (IcmpError <= ICMP6_ERR_PARAMPROB_IPV6OPTION);
    21992154
    … …  
    22072162
    22082163    switch (IcmpError) {
    2209     case ICMP6_ERR_UNREACH_NET:
    2210       return EFI_NETWORK_UNREACHABLE;
    2211 
    2212     case ICMP6_ERR_UNREACH_HOST:
    2213     case ICMP6_ERR_TIMXCEED_HOPLIMIT:
    2214     case ICMP6_ERR_TIMXCEED_REASS:
    2215       return EFI_HOST_UNREACHABLE;
    2216 
    2217     case ICMP6_ERR_UNREACH_PROTOCOL:
    2218       return EFI_PROTOCOL_UNREACHABLE;
    2219 
    2220     case ICMP6_ERR_UNREACH_PORT:
    2221       return EFI_PORT_UNREACHABLE;
    2222 
    2223     case ICMP6_ERR_PACKAGE_TOOBIG:
    2224     case ICMP6_ERR_PARAMPROB_HEADER:
    2225     case ICMP6_ERR_PARAMPROB_NEXHEADER:
    2226     case ICMP6_ERR_PARAMPROB_IPV6OPTION:
    2227       return EFI_ICMP_ERROR;
    2228 
    2229     default:
    2230       ASSERT (FALSE);
    2231       return EFI_UNSUPPORTED;
    2232     }
    2233 
     2164      case ICMP6_ERR_UNREACH_NET:
     2165        return EFI_NETWORK_UNREACHABLE;
     2166
     2167      case ICMP6_ERR_UNREACH_HOST:
     2168      case ICMP6_ERR_TIMXCEED_HOPLIMIT:
     2169      case ICMP6_ERR_TIMXCEED_REASS:
     2170        return EFI_HOST_UNREACHABLE;
     2171
     2172      case ICMP6_ERR_UNREACH_PROTOCOL:
     2173        return EFI_PROTOCOL_UNREACHABLE;
     2174
     2175      case ICMP6_ERR_UNREACH_PORT:
     2176        return EFI_PORT_UNREACHABLE;
     2177
     2178      case ICMP6_ERR_PACKAGE_TOOBIG:
     2179      case ICMP6_ERR_PARAMPROB_HEADER:
     2180      case ICMP6_ERR_PARAMPROB_NEXHEADER:
     2181      case ICMP6_ERR_PARAMPROB_IPV6OPTION:
     2182        return EFI_ICMP_ERROR;
     2183
     2184      default:
     2185        ASSERT (FALSE);
     2186        return EFI_UNSUPPORTED;
     2187    }
    22342188  } else {
    22352189    //
    … …  
    22402194  }
    22412195}
    2242 
    22432196
    22442197/**
    … …  
    22892242  return Ip->Neighbors (Ip, FALSE, &Neighbor->v6, NULL, Timeout, TRUE);
    22902243}
    2291 
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