VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156854
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/DxeHttpLib/DxeHttpLib.c

    r89983 r99404  
    1010
    1111#include "DxeHttpLib.h"
    12 
    13 
    1412
    1513/**
    … …  
    3230EFIAPI
    3331UriPercentDecode (
    34   IN      CHAR8            *Buffer,
    35   IN      UINT32            BufferLength,
    36      OUT  CHAR8            *ResultBuffer,
    37      OUT  UINT32           *ResultLength
    38   )
    39 {
    40   UINTN           Index;
    41   UINTN           Offset;
    42   CHAR8           HexStr[3];
    43 
    44   if (Buffer == NULL || BufferLength == 0 || ResultBuffer == NULL) {
     32  IN      CHAR8   *Buffer,
     33  IN      UINT32  BufferLength,
     34  OUT  CHAR8      *ResultBuffer,
     35  OUT  UINT32     *ResultLength
     36  )
     37{
     38  UINTN  Index;
     39  UINTN  Offset;
     40  CHAR8  HexStr[3];
     41
     42  if ((Buffer == NULL) || (BufferLength == 0) || (ResultBuffer == NULL)) {
    4543    return EFI_INVALID_PARAMETER;
    4644  }
    4745
    48   Index = 0;
    49   Offset = 0;
     46  Index     = 0;
     47  Offset    = 0;
    5048  HexStr[2] = '\0';
    5149  while (Index < BufferLength) {
    5250    if (Buffer[Index] == '%') {
    53       if (Index + 1 >= BufferLength || Index + 2 >= BufferLength ||
    54           !NET_IS_HEX_CHAR (Buffer[Index+1]) || !NET_IS_HEX_CHAR (Buffer[Index+2])) {
     51      if ((Index + 1 >= BufferLength) || (Index + 2 >= BufferLength) ||
     52          !NET_IS_HEX_CHAR (Buffer[Index+1]) || !NET_IS_HEX_CHAR (Buffer[Index+2]))
     53      {
    5554        return EFI_INVALID_PARAMETER;
    5655      }
    57       HexStr[0] = Buffer[Index+1];
    58       HexStr[1] = Buffer[Index+2];
    59       ResultBuffer[Offset] = (CHAR8) AsciiStrHexToUintn (HexStr);
    60       Index += 3;
     56
     57      HexStr[0]            = Buffer[Index+1];
     58      HexStr[1]            = Buffer[Index+2];
     59      ResultBuffer[Offset] = (CHAR8)AsciiStrHexToUintn (HexStr);
     60      Index               += 3;
    6161    } else {
    6262      ResultBuffer[Offset] = Buffer[Index];
    6363      Index++;
    6464    }
     65
    6566    Offset++;
    6667  }
    6768
    68   *ResultLength = (UINT32) Offset;
     69  *ResultLength = (UINT32)Offset;
    6970
    7071  return EFI_SUCCESS;
    … …  
    8485HTTP_URL_PARSE_STATE
    8586NetHttpParseAuthorityChar (
    86   IN  CHAR8                  Char,
    87   IN  HTTP_URL_PARSE_STATE   State,
    88   IN  BOOLEAN                *IsRightBracket
    89   )
    90 {
    91 
     87  IN  CHAR8                 Char,
     88  IN  HTTP_URL_PARSE_STATE  State,
     89  IN  BOOLEAN               *IsRightBracket
     90  )
     91{
    9292  //
    9393  // RFC 3986:
    … …  
    9696  // sign ("#") character, or by the end of the URI.
    9797  //
    98   if (Char == ' ' || Char == '\r' || Char == '\n') {
     98  if ((Char == ' ') || (Char == '\r') || (Char == '\n')) {
    9999    return UrlParserStateMax;
    100100  }
    … …  
    104104  //
    105105  switch (State) {
    106   case UrlParserUserInfo:
    107     if (Char == '@') {
    108       return UrlParserHostStart;
    109     }
    110     break;
    111 
    112   case UrlParserHost:
    113   case UrlParserHostStart:
    114     if (Char == '[') {
     106    case UrlParserUserInfo:
     107      if (Char == '@') {
     108        return UrlParserHostStart;
     109      }
     110
     111      break;
     112
     113    case UrlParserHost:
     114    case UrlParserHostStart:
     115      if (Char == '[') {
     116        return UrlParserHostIpv6;
     117      }
     118
     119      if (Char == ':') {
     120        return UrlParserPortStart;
     121      }
     122
     123      return UrlParserHost;
     124
     125    case UrlParserHostIpv6:
     126      if (Char == ']') {
     127        *IsRightBracket = TRUE;
     128      }
     129
     130      if ((Char == ':') && *IsRightBracket) {
     131        return UrlParserPortStart;
     132      }
     133
    115134      return UrlParserHostIpv6;
    116     }
    117 
    118     if (Char == ':') {
    119       return UrlParserPortStart;
    120     }
    121 
    122     return UrlParserHost;
    123 
    124   case UrlParserHostIpv6:
    125     if (Char == ']') {
    126       *IsRightBracket = TRUE;
    127     }
    128 
    129     if (Char == ':' && *IsRightBracket) {
    130       return UrlParserPortStart;
    131     }
    132     return UrlParserHostIpv6;
    133 
    134   case UrlParserPort:
    135   case UrlParserPortStart:
    136     return UrlParserPort;
    137 
    138   default:
    139     break;
     135
     136    case UrlParserPort:
     137    case UrlParserPortStart:
     138      return UrlParserPort;
     139
     140    default:
     141      break;
    140142  }
    141143
    … …  
    156158EFI_STATUS
    157159NetHttpParseAuthority (
    158   IN      CHAR8              *Url,
    159   IN      BOOLEAN            FoundAt,
    160   IN OUT  HTTP_URL_PARSER    *UrlParser
     160  IN      CHAR8            *Url,
     161  IN      BOOLEAN          FoundAt,
     162  IN OUT  HTTP_URL_PARSER  *UrlParser
    161163  )
    162164{
    … …  
    181183
    182184  IsrightBracket = FALSE;
    183   Field = HTTP_URI_FIELD_MAX;
    184   OldField = Field;
    185   Authority = Url + UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Offset;
    186   Length = UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Length;
     185  Field          = HTTP_URI_FIELD_MAX;
     186  OldField       = Field;
     187  Authority      = Url + UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Offset;
     188  Length         = UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Length;
    187189  for (Char = Authority; Char < Authority + Length; Char++) {
    188190    State = NetHttpParseAuthorityChar (*Char, State, &IsrightBracket);
    189191    switch (State) {
    190     case UrlParserStateMax:
    191       return EFI_INVALID_PARAMETER;
    192 
    193     case UrlParserHostStart:
    194     case UrlParserPortStart:
    195       continue;
    196 
    197     case UrlParserUserInfo:
    198       Field = HTTP_URI_FIELD_USERINFO;
    199       break;
    200 
    201     case UrlParserHost:
    202       Field = HTTP_URI_FIELD_HOST;
    203       break;
    204 
    205     case UrlParserHostIpv6:
    206       Field = HTTP_URI_FIELD_HOST;
    207       break;
    208 
    209     case UrlParserPort:
    210       Field = HTTP_URI_FIELD_PORT;
    211       break;
    212 
    213     default:
    214       ASSERT (FALSE);
     192      case UrlParserStateMax:
     193        return EFI_INVALID_PARAMETER;
     194
     195      case UrlParserHostStart:
     196      case UrlParserPortStart:
     197        continue;
     198
     199      case UrlParserUserInfo:
     200        Field = HTTP_URI_FIELD_USERINFO;
     201        break;
     202
     203      case UrlParserHost:
     204        Field = HTTP_URI_FIELD_HOST;
     205        break;
     206
     207      case UrlParserHostIpv6:
     208        Field = HTTP_URI_FIELD_HOST;
     209        break;
     210
     211      case UrlParserPort:
     212        Field = HTTP_URI_FIELD_PORT;
     213        break;
     214
     215      default:
     216        ASSERT (FALSE);
    215217    }
    216218
    … …  
    227229    // New field start
    228230    //
    229     UrlParser->FieldBitMap |= BIT (Field);
    230     UrlParser->FieldData[Field].Offset = (UINT32) (Char - Url);
     231    UrlParser->FieldBitMap            |= BIT (Field);
     232    UrlParser->FieldData[Field].Offset = (UINT32)(Char - Url);
    231233    UrlParser->FieldData[Field].Length = 1;
    232     OldField = Field;
     234    OldField                           = Field;
    233235  }
    234236
    … …  
    247249HTTP_URL_PARSE_STATE
    248250NetHttpParseUrlChar (
    249   IN  CHAR8                  Char,
    250   IN  HTTP_URL_PARSE_STATE   State
    251   )
    252 {
    253   if (Char == ' ' || Char == '\r' || Char == '\n') {
     251  IN  CHAR8                 Char,
     252  IN  HTTP_URL_PARSE_STATE  State
     253  )
     254{
     255  if ((Char == ' ') || (Char == '\r') || (Char == '\n')) {
    254256    return UrlParserStateMax;
    255257  }
    … …  
    265267  //
    266268  switch (State) {
    267   case UrlParserUrlStart:
    268     if (Char == '*' || Char == '/') {
    269       return UrlParserPath;
    270     }
    271     return UrlParserScheme;
    272 
    273   case UrlParserScheme:
    274     if (Char == ':') {
    275       return UrlParserSchemeColon;
    276     }
    277     break;
    278 
    279   case UrlParserSchemeColon:
    280     if (Char == '/') {
    281       return UrlParserSchemeColonSlash;
    282     }
    283     break;
    284 
    285   case UrlParserSchemeColonSlash:
    286     if (Char == '/') {
    287       return UrlParserSchemeColonSlashSlash;
    288     }
    289     break;
    290 
    291   case UrlParserAtInAuthority:
    292     if (Char == '@') {
    293       return UrlParserStateMax;
    294     }
    295 
    296   case UrlParserAuthority:
    297   case UrlParserSchemeColonSlashSlash:
    298     if (Char == '@') {
    299       return UrlParserAtInAuthority;
    300     }
    301     if (Char == '/') {
    302       return UrlParserPath;
    303     }
    304     if (Char == '?') {
    305       return UrlParserQueryStart;
    306     }
    307     if (Char == '#') {
    308       return UrlParserFragmentStart;
    309     }
    310     return UrlParserAuthority;
    311 
    312   case UrlParserPath:
    313     if (Char == '?') {
    314       return UrlParserQueryStart;
    315     }
    316     if (Char == '#') {
    317       return UrlParserFragmentStart;
    318     }
    319     break;
    320 
    321   case UrlParserQuery:
    322   case UrlParserQueryStart:
    323     if (Char == '#') {
    324       return UrlParserFragmentStart;
    325     }
    326     return UrlParserQuery;
    327 
    328   case UrlParserFragmentStart:
    329     return UrlParserFragment;
    330 
    331   default:
    332     break;
     269    case UrlParserUrlStart:
     270      if ((Char == '*') || (Char == '/')) {
     271        return UrlParserPath;
     272      }
     273
     274      return UrlParserScheme;
     275
     276    case UrlParserScheme:
     277      if (Char == ':') {
     278        return UrlParserSchemeColon;
     279      }
     280
     281      break;
     282
     283    case UrlParserSchemeColon:
     284      if (Char == '/') {
     285        return UrlParserSchemeColonSlash;
     286      }
     287
     288      break;
     289
     290    case UrlParserSchemeColonSlash:
     291      if (Char == '/') {
     292        return UrlParserSchemeColonSlashSlash;
     293      }
     294
     295      break;
     296
     297    case UrlParserAtInAuthority:
     298      if (Char == '@') {
     299        return UrlParserStateMax;
     300      }
     301
     302    case UrlParserAuthority:
     303    case UrlParserSchemeColonSlashSlash:
     304      if (Char == '@') {
     305        return UrlParserAtInAuthority;
     306      }
     307
     308      if (Char == '/') {
     309        return UrlParserPath;
     310      }
     311
     312      if (Char == '?') {
     313        return UrlParserQueryStart;
     314      }
     315
     316      if (Char == '#') {
     317        return UrlParserFragmentStart;
     318      }
     319
     320      return UrlParserAuthority;
     321
     322    case UrlParserPath:
     323      if (Char == '?') {
     324        return UrlParserQueryStart;
     325      }
     326
     327      if (Char == '#') {
     328        return UrlParserFragmentStart;
     329      }
     330
     331      break;
     332
     333    case UrlParserQuery:
     334    case UrlParserQueryStart:
     335      if (Char == '#') {
     336        return UrlParserFragmentStart;
     337      }
     338
     339      return UrlParserQuery;
     340
     341    case UrlParserFragmentStart:
     342      return UrlParserFragment;
     343
     344    default:
     345      break;
    333346  }
    334347
    335348  return State;
    336349}
     350
    337351/**
    338352  Create a URL parser for the input URL string.
    … …  
    355369EFIAPI
    356370HttpParseUrl (
    357   IN      CHAR8              *Url,
    358   IN      UINT32             Length,
    359   IN      BOOLEAN            IsConnectMethod,
    360      OUT  VOID               **UrlParser
     371  IN      CHAR8    *Url,
     372  IN      UINT32   Length,
     373  IN      BOOLEAN  IsConnectMethod,
     374  OUT  VOID        **UrlParser
    361375  )
    362376{
    … …  
    371385  Parser = NULL;
    372386
    373   if (Url == NULL || Length == 0 || UrlParser == NULL) {
     387  if ((Url == NULL) || (Length == 0) || (UrlParser == NULL)) {
    374388    return EFI_INVALID_PARAMETER;
    375389  }
    … …  
    389403  }
    390404
    391   Field = HTTP_URI_FIELD_MAX;
     405  Field    = HTTP_URI_FIELD_MAX;
    392406  OldField = Field;
    393   FoundAt = FALSE;
     407  FoundAt  = FALSE;
    394408  for (Char = Url; Char < Url + Length; Char++) {
    395409    //
    … …  
    399413
    400414    switch (State) {
    401     case UrlParserStateMax:
    402       FreePool (Parser);
    403       return EFI_INVALID_PARAMETER;
    404 
    405     case UrlParserSchemeColon:
    406     case UrlParserSchemeColonSlash:
    407     case UrlParserSchemeColonSlashSlash:
    408     case UrlParserQueryStart:
    409     case UrlParserFragmentStart:
    410       //
    411       // Skip all the delimiting char: "://" "?" "@"
    412       //
    413       continue;
    414 
    415     case UrlParserScheme:
    416       Field = HTTP_URI_FIELD_SCHEME;
    417       break;
    418 
    419     case UrlParserAtInAuthority:
    420       FoundAt = TRUE;
    421     case UrlParserAuthority:
    422       Field = HTTP_URI_FIELD_AUTHORITY;
    423       break;
    424 
    425     case UrlParserPath:
    426       Field = HTTP_URI_FIELD_PATH;
    427       break;
    428 
    429     case UrlParserQuery:
    430       Field = HTTP_URI_FIELD_QUERY;
    431       break;
    432 
    433     case UrlParserFragment:
    434       Field = HTTP_URI_FIELD_FRAGMENT;
    435       break;
    436 
    437     default:
    438       ASSERT (FALSE);
     415      case UrlParserStateMax:
     416        FreePool (Parser);
     417        return EFI_INVALID_PARAMETER;
     418
     419      case UrlParserSchemeColon:
     420      case UrlParserSchemeColonSlash:
     421      case UrlParserSchemeColonSlashSlash:
     422      case UrlParserQueryStart:
     423      case UrlParserFragmentStart:
     424        //
     425        // Skip all the delimiting char: "://" "?" "@"
     426        //
     427        continue;
     428
     429      case UrlParserScheme:
     430        Field = HTTP_URI_FIELD_SCHEME;
     431        break;
     432
     433      case UrlParserAtInAuthority:
     434        FoundAt = TRUE;
     435      case UrlParserAuthority:
     436        Field = HTTP_URI_FIELD_AUTHORITY;
     437        break;
     438
     439      case UrlParserPath:
     440        Field = HTTP_URI_FIELD_PATH;
     441        break;
     442
     443      case UrlParserQuery:
     444        Field = HTTP_URI_FIELD_QUERY;
     445        break;
     446
     447      case UrlParserFragment:
     448        Field = HTTP_URI_FIELD_FRAGMENT;
     449        break;
     450
     451      default:
     452        ASSERT (FALSE);
    439453    }
    440454
    … …  
    451465    // New field start
    452466    //
    453     Parser->FieldBitMap |= BIT (Field);
    454     Parser->FieldData[Field].Offset = (UINT32) (Char - Url);
     467    Parser->FieldBitMap            |= BIT (Field);
     468    Parser->FieldData[Field].Offset = (UINT32)(Char - Url);
    455469    Parser->FieldData[Field].Length = 1;
    456     OldField = Field;
     470    OldField                        = Field;
    457471  }
    458472
    … …  
    491505EFIAPI
    492506HttpUrlGetHostName (
    493   IN      CHAR8              *Url,
    494   IN      VOID               *UrlParser,
    495      OUT  CHAR8              **HostName
    496   )
    497 {
    498   CHAR8                *Name;
    499   EFI_STATUS           Status;
    500   UINT32               ResultLength;
    501   HTTP_URL_PARSER      *Parser;
    502 
    503   if (Url == NULL || UrlParser == NULL || HostName == NULL) {
     507  IN      CHAR8  *Url,
     508  IN      VOID   *UrlParser,
     509  OUT  CHAR8     **HostName
     510  )
     511{
     512  CHAR8            *Name;
     513  EFI_STATUS       Status;
     514  UINT32           ResultLength;
     515  HTTP_URL_PARSER  *Parser;
     516
     517  if ((Url == NULL) || (UrlParser == NULL) || (HostName == NULL)) {
    504518    return EFI_INVALID_PARAMETER;
    505519  }
    506520
    507   Parser = (HTTP_URL_PARSER *) UrlParser;
     521  Parser = (HTTP_URL_PARSER *)UrlParser;
    508522
    509523  if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
    … …  
    528542
    529543  Name[ResultLength] = '\0';
    530   *HostName = Name;
     544  *HostName          = Name;
    531545  return EFI_SUCCESS;
    532546}
    533 
    534547
    535548/**
    … …  
    551564EFIAPI
    552565HttpUrlGetIp4 (
    553   IN      CHAR8              *Url,
    554   IN      VOID               *UrlParser,
    555      OUT  EFI_IPv4_ADDRESS   *Ip4Address
    556   )
    557 {
    558   CHAR8                *Ip4String;
    559   EFI_STATUS           Status;
    560   UINT32               ResultLength;
    561   HTTP_URL_PARSER      *Parser;
    562 
    563   if (Url == NULL || UrlParser == NULL || Ip4Address == NULL) {
     566  IN      CHAR8          *Url,
     567  IN      VOID           *UrlParser,
     568  OUT  EFI_IPv4_ADDRESS  *Ip4Address
     569  )
     570{
     571  CHAR8            *Ip4String;
     572  EFI_STATUS       Status;
     573  UINT32           ResultLength;
     574  HTTP_URL_PARSER  *Parser;
     575
     576  if ((Url == NULL) || (UrlParser == NULL) || (Ip4Address == NULL)) {
    564577    return EFI_INVALID_PARAMETER;
    565578  }
    566579
    567   Parser = (HTTP_URL_PARSER *) UrlParser;
     580  Parser = (HTTP_URL_PARSER *)UrlParser;
    568581
    569582  if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
    … …  
    588601
    589602  Ip4String[ResultLength] = '\0';
    590   Status = NetLibAsciiStrToIp4 (Ip4String, Ip4Address);
     603  Status                  = NetLibAsciiStrToIp4 (Ip4String, Ip4Address);
    591604  FreePool (Ip4String);
    592605
    … …  
    612625EFIAPI
    613626HttpUrlGetIp6 (
    614   IN      CHAR8              *Url,
    615   IN      VOID               *UrlParser,
    616      OUT  EFI_IPv6_ADDRESS   *Ip6Address
    617   )
    618 {
    619   CHAR8                *Ip6String;
    620   CHAR8                *Ptr;
    621   UINT32               Length;
    622   EFI_STATUS           Status;
    623   UINT32               ResultLength;
    624   HTTP_URL_PARSER      *Parser;
    625 
    626   if (Url == NULL || UrlParser == NULL || Ip6Address == NULL) {
     627  IN      CHAR8          *Url,
     628  IN      VOID           *UrlParser,
     629  OUT  EFI_IPv6_ADDRESS  *Ip6Address
     630  )
     631{
     632  CHAR8            *Ip6String;
     633  CHAR8            *Ptr;
     634  UINT32           Length;
     635  EFI_STATUS       Status;
     636  UINT32           ResultLength;
     637  HTTP_URL_PARSER  *Parser;
     638
     639  if ((Url == NULL) || (UrlParser == NULL) || (Ip6Address == NULL)) {
    627640    return EFI_INVALID_PARAMETER;
    628641  }
    629642
    630   Parser = (HTTP_URL_PARSER *) UrlParser;
     643  Parser = (HTTP_URL_PARSER *)UrlParser;
    631644
    632645  if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
    … …  
    642655  }
    643656
    644   Ptr    = Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset;
     657  Ptr = Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset;
    645658  if ((Ptr[0] != '[') || (Ptr[Length - 1] != ']')) {
    646659    return EFI_INVALID_PARAMETER;
    … …  
    664677
    665678  Ip6String[ResultLength] = '\0';
    666   Status = NetLibAsciiStrToIp6 (Ip6String, Ip6Address);
     679  Status                  = NetLibAsciiStrToIp6 (Ip6String, Ip6Address);
    667680  FreePool (Ip6String);
    668681
    … …  
    688701EFIAPI
    689702HttpUrlGetPort (
    690   IN      CHAR8              *Url,
    691   IN      VOID               *UrlParser,
    692      OUT  UINT16             *Port
    693   )
    694 {
    695   CHAR8                *PortString;
    696   EFI_STATUS           Status;
    697   UINTN                Index;
    698   UINTN                Data;
    699   UINT32               ResultLength;
    700   HTTP_URL_PARSER      *Parser;
    701 
    702   if (Url == NULL || UrlParser == NULL || Port == NULL) {
     703  IN      CHAR8  *Url,
     704  IN      VOID   *UrlParser,
     705  OUT  UINT16    *Port
     706  )
     707{
     708  CHAR8            *PortString;
     709  EFI_STATUS       Status;
     710  UINTN            Index;
     711  UINTN            Data;
     712  UINT32           ResultLength;
     713  HTTP_URL_PARSER  *Parser;
     714
     715  if ((Url == NULL) || (UrlParser == NULL) || (Port == NULL)) {
    703716    return EFI_INVALID_PARAMETER;
    704717  }
    … …  
    707720  Index = 0;
    708721
    709   Parser = (HTTP_URL_PARSER *) UrlParser;
     722  Parser = (HTTP_URL_PARSER *)UrlParser;
    710723
    711724  if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PORT)) == 0) {
    … …  
    735748      goto ON_EXIT;
    736749    }
    737     Index ++;
    738   }
    739 
    740   Status =  AsciiStrDecimalToUintnS (Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset, (CHAR8 **) NULL, &Data);
     750
     751    Index++;
     752  }
     753
     754  Status =  AsciiStrDecimalToUintnS (Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset, (CHAR8 **)NULL, &Data);
    741755
    742756  if (Data > HTTP_URI_PORT_MAX_NUM) {
    … …  
    745759  }
    746760
    747   *Port = (UINT16) Data;
     761  *Port = (UINT16)Data;
    748762
    749763ON_EXIT:
    … …  
    771785EFIAPI
    772786HttpUrlGetPath (
    773   IN      CHAR8              *Url,
    774   IN      VOID               *UrlParser,
    775      OUT  CHAR8              **Path
    776   )
    777 {
    778   CHAR8                *PathStr;
    779   EFI_STATUS           Status;
    780   UINT32               ResultLength;
    781   HTTP_URL_PARSER      *Parser;
    782 
    783   if (Url == NULL || UrlParser == NULL || Path == NULL) {
     787  IN      CHAR8  *Url,
     788  IN      VOID   *UrlParser,
     789  OUT  CHAR8     **Path
     790  )
     791{
     792  CHAR8            *PathStr;
     793  EFI_STATUS       Status;
     794  UINT32           ResultLength;
     795  HTTP_URL_PARSER  *Parser;
     796
     797  if ((Url == NULL) || (UrlParser == NULL) || (Path == NULL)) {
    784798    return EFI_INVALID_PARAMETER;
    785799  }
    786800
    787   Parser = (HTTP_URL_PARSER *) UrlParser;
     801  Parser = (HTTP_URL_PARSER *)UrlParser;
    788802
    789803  if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PATH)) == 0) {
    … …  
    808822
    809823  PathStr[ResultLength] = '\0';
    810   *Path = PathStr;
     824  *Path                 = PathStr;
    811825  return EFI_SUCCESS;
    812826}
    … …  
    821835EFIAPI
    822836HttpUrlFreeParser (
    823   IN      VOID               *UrlParser
     837  IN      VOID  *UrlParser
    824838  )
    825839{
    … …  
    840854EFIAPI
    841855HttpFindHeader (
    842   IN  UINTN                HeaderCount,
    843   IN  EFI_HTTP_HEADER      *Headers,
    844   IN  CHAR8                *FieldName
    845   )
    846 {
    847   UINTN                 Index;
    848 
    849   if (HeaderCount == 0 || Headers == NULL || FieldName == NULL) {
     856  IN  UINTN            HeaderCount,
     857  IN  EFI_HTTP_HEADER  *Headers,
     858  IN  CHAR8            *FieldName
     859  )
     860{
     861  UINTN  Index;
     862
     863  if ((HeaderCount == 0) || (Headers == NULL) || (FieldName == NULL)) {
    850864    return NULL;
    851865  }
    852866
    853   for (Index = 0; Index < HeaderCount; Index++){
     867  for (Index = 0; Index < HeaderCount; Index++) {
    854868    //
    855869    // Field names are case-insensitive (RFC 2616).
    … …  
    859873    }
    860874  }
     875
    861876  return NULL;
    862877}
    … …  
    880895
    881896typedef struct {
    882   BOOLEAN                       IgnoreBody;    // "MUST NOT" include a message-body
    883   BOOLEAN                       IsChunked;     // "chunked" transfer-coding.
    884   BOOLEAN                       ContentLengthIsValid;
    885   UINTN                         ContentLength; // Entity length (not the message-body length), invalid until ContentLengthIsValid is TRUE
    886 
    887   HTTP_BODY_PARSER_CALLBACK     Callback;
    888   VOID                          *Context;
    889   UINTN                         ParsedBodyLength;
    890   HTTP_BODY_PARSE_STATE         State;
    891   UINTN                         CurrentChunkSize;
    892   UINTN                         CurrentChunkParsedSize;
     897  BOOLEAN                      IgnoreBody;     // "MUST NOT" include a message-body
     898  BOOLEAN                      IsChunked;      // "chunked" transfer-coding.
     899  BOOLEAN                      ContentLengthIsValid;
     900  UINTN                        ContentLength; // Entity length (not the message-body length), invalid until ContentLengthIsValid is TRUE
     901
     902  HTTP_BODY_PARSER_CALLBACK    Callback;
     903  VOID                         *Context;
     904  UINTN                        ParsedBodyLength;
     905  HTTP_BODY_PARSE_STATE        State;
     906  UINTN                        CurrentChunkSize;
     907  UINTN                        CurrentChunkParsedSize;
    893908} HTTP_BODY_PARSER;
    894909
    … …  
    903918UINTN
    904919HttpIoHexCharToUintn (
    905   IN CHAR8           Char
    906   )
    907 {
    908   if (Char >= '0' && Char <= '9') {
     920  IN CHAR8  Char
     921  )
     922{
     923  if ((Char >= '0') && (Char <= '9')) {
    909924    return Char - '0';
    910925  }
    … …  
    926941EFI_STATUS
    927942HttpIoParseContentLengthHeader (
    928   IN     UINTN                HeaderCount,
    929   IN     EFI_HTTP_HEADER      *Headers,
    930      OUT UINTN                *ContentLength
    931   )
    932 {
    933   EFI_HTTP_HEADER       *Header;
     943  IN     UINTN            HeaderCount,
     944  IN     EFI_HTTP_HEADER  *Headers,
     945  OUT UINTN               *ContentLength
     946  )
     947{
     948  EFI_HTTP_HEADER  *Header;
    934949
    935950  Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_CONTENT_LENGTH);
    … …  
    938953  }
    939954
    940   return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **) NULL, ContentLength);
     955  return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **)NULL, ContentLength);
    941956}
    942957
    … …  
    953968BOOLEAN
    954969HttpIoIsChunked (
    955   IN   UINTN                    HeaderCount,
    956   IN   EFI_HTTP_HEADER          *Headers
    957   )
    958 {
    959   EFI_HTTP_HEADER       *Header;
    960 
     970  IN   UINTN            HeaderCount,
     971  IN   EFI_HTTP_HEADER  *Headers
     972  )
     973{
     974  EFI_HTTP_HEADER  *Header;
    961975
    962976  Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
    … …  
    983997BOOLEAN
    984998HttpIoNoMessageBody (
    985   IN   EFI_HTTP_METHOD          Method,
    986   IN   EFI_HTTP_STATUS_CODE     StatusCode
     999  IN   EFI_HTTP_METHOD       Method,
     1000  IN   EFI_HTTP_STATUS_CODE  StatusCode
    9871001  )
    9881002{
    … …  
    10351049EFIAPI
    10361050HttpInitMsgParser (
    1037   IN     EFI_HTTP_METHOD               Method,
    1038   IN     EFI_HTTP_STATUS_CODE          StatusCode,
    1039   IN     UINTN                         HeaderCount,
    1040   IN     EFI_HTTP_HEADER               *Headers,
    1041   IN     HTTP_BODY_PARSER_CALLBACK     Callback,
    1042   IN     VOID                          *Context,
    1043     OUT  VOID                          **MsgParser
    1044   )
    1045 {
    1046   EFI_STATUS            Status;
    1047   HTTP_BODY_PARSER      *Parser;
    1048 
    1049   if (HeaderCount != 0 && Headers == NULL) {
     1051  IN     EFI_HTTP_METHOD            Method,
     1052  IN     EFI_HTTP_STATUS_CODE       StatusCode,
     1053  IN     UINTN                      HeaderCount,
     1054  IN     EFI_HTTP_HEADER            *Headers,
     1055  IN     HTTP_BODY_PARSER_CALLBACK  Callback,
     1056  IN     VOID                       *Context,
     1057  OUT  VOID                         **MsgParser
     1058  )
     1059{
     1060  EFI_STATUS        Status;
     1061  HTTP_BODY_PARSER  *Parser;
     1062
     1063  if ((HeaderCount != 0) && (Headers == NULL)) {
    10501064    return EFI_INVALID_PARAMETER;
    10511065  }
    … …  
    10701084  // 2. Check whether the message using "chunked" transfer-coding.
    10711085  //
    1072   Parser->IsChunked  = HttpIoIsChunked (HeaderCount, Headers);
     1086  Parser->IsChunked = HttpIoIsChunked (HeaderCount, Headers);
    10731087  //
    10741088  // 3. Check whether the message has a Content-Length header field.
    … …  
    10781092    Parser->ContentLengthIsValid = TRUE;
    10791093  }
     1094
    10801095  //
    10811096  // 4. Range header is not supported now, so we won't meet media type "multipart/byteranges".
    … …  
    11151130EFIAPI
    11161131HttpParseMessageBody (
    1117   IN OUT VOID              *MsgParser,
    1118   IN     UINTN             BodyLength,
    1119   IN     CHAR8             *Body
    1120   )
    1121 {
    1122   CHAR8                 *Char;
    1123   UINTN                 RemainderLengthInThis;
    1124   UINTN                 LengthForCallback;
    1125   UINTN                 PortionLength;
    1126   EFI_STATUS            Status;
    1127   HTTP_BODY_PARSER      *Parser;
    1128 
    1129   if (BodyLength == 0 || Body == NULL) {
     1132  IN OUT VOID   *MsgParser,
     1133  IN     UINTN  BodyLength,
     1134  IN     CHAR8  *Body
     1135  )
     1136{
     1137  CHAR8             *Char;
     1138  UINTN             RemainderLengthInThis;
     1139  UINTN             LengthForCallback;
     1140  UINTN             PortionLength;
     1141  EFI_STATUS        Status;
     1142  HTTP_BODY_PARSER  *Parser;
     1143
     1144  if ((BodyLength == 0) || (Body == NULL)) {
    11301145    return EFI_INVALID_PARAMETER;
    11311146  }
    … …  
    11351150  }
    11361151
    1137   Parser = (HTTP_BODY_PARSER *) MsgParser;
     1152  Parser = (HTTP_BODY_PARSER *)MsgParser;
    11381153
    11391154  if (Parser->IgnoreBody) {
    … …  
    11501165      }
    11511166    }
     1167
    11521168    return EFI_SUCCESS;
    11531169  }
    … …  
    11661182  //
    11671183  for (Char = Body; Char < Body + BodyLength; ) {
    1168 
    11691184    switch (Parser->State) {
    1170     case BodyParserStateMax:
    1171       return EFI_ABORTED;
    1172 
    1173     case BodyParserBodyIdentity:
    1174       //
    1175       // Identity transfer-coding, just notify user to save the body data.
    1176       //
    1177       PortionLength = MIN (
    1178                         BodyLength,
    1179                         Parser->ContentLength - Parser->ParsedBodyLength
    1180                         );
    1181       if (PortionLength == 0) {
     1185      case BodyParserStateMax:
     1186        return EFI_ABORTED;
     1187
     1188      case BodyParserBodyIdentity:
    11821189        //
    1183         // Got BodyLength, but no ContentLength. Use BodyLength.
     1190        // Identity transfer-coding, just notify user to save the body data.
    11841191        //
    1185         PortionLength = BodyLength;
    1186         Parser->ContentLength = PortionLength;
    1187       }
    1188 
    1189       if (Parser->Callback != NULL) {
    1190         Status = Parser->Callback (
    1191                            BodyParseEventOnData,
    1192                            Char,
    1193                            PortionLength,
    1194                            Parser->Context
    1195                            );
    1196         if (EFI_ERROR (Status)) {
    1197           return Status;
     1192        PortionLength = MIN (
     1193                          BodyLength,
     1194                          Parser->ContentLength - Parser->ParsedBodyLength
     1195                          );
     1196        if (PortionLength == 0) {
     1197          //
     1198          // Got BodyLength, but no ContentLength. Use BodyLength.
     1199          //
     1200          PortionLength         = BodyLength;
     1201          Parser->ContentLength = PortionLength;
    11981202        }
    1199       }
    1200       Char += PortionLength;
    1201       Parser->ParsedBodyLength += PortionLength;
    1202       if (Parser->ParsedBodyLength == Parser->ContentLength) {
    1203         Parser->State = BodyParserComplete;
     1203
    12041204        if (Parser->Callback != NULL) {
    12051205          Status = Parser->Callback (
    1206                              BodyParseEventOnComplete,
     1206                             BodyParseEventOnData,
    12071207                             Char,
    1208                              0,
     1208                             PortionLength,
    12091209                             Parser->Context
    12101210                             );
    … …  
    12131213          }
    12141214        }
    1215       }
    1216       break;
    1217 
    1218     case BodyParserChunkSizeStart:
    1219       //
    1220       // First byte of chunk-size, the chunk-size might be truncated.
    1221       //
    1222       Parser->CurrentChunkSize = 0;
    1223       Parser->State = BodyParserChunkSize;
    1224     case BodyParserChunkSize:
    1225       if (!NET_IS_HEX_CHAR (*Char)) {
    1226         if (*Char == ';') {
    1227           Parser->State = BodyParserChunkExtStart;
     1215
     1216        Char                     += PortionLength;
     1217        Parser->ParsedBodyLength += PortionLength;
     1218        if (Parser->ParsedBodyLength == Parser->ContentLength) {
     1219          Parser->State = BodyParserComplete;
     1220          if (Parser->Callback != NULL) {
     1221            Status = Parser->Callback (
     1222                               BodyParseEventOnComplete,
     1223                               Char,
     1224                               0,
     1225                               Parser->Context
     1226                               );
     1227            if (EFI_ERROR (Status)) {
     1228              return Status;
     1229            }
     1230          }
     1231        }
     1232
     1233        break;
     1234
     1235      case BodyParserChunkSizeStart:
     1236        //
     1237        // First byte of chunk-size, the chunk-size might be truncated.
     1238        //
     1239        Parser->CurrentChunkSize = 0;
     1240        Parser->State            = BodyParserChunkSize;
     1241      case BodyParserChunkSize:
     1242        if (!NET_IS_HEX_CHAR (*Char)) {
     1243          if (*Char == ';') {
     1244            Parser->State = BodyParserChunkExtStart;
     1245            Char++;
     1246          } else if (*Char == '\r') {
     1247            Parser->State = BodyParserChunkSizeEndCR;
     1248            Char++;
     1249          } else {
     1250            Parser->State = BodyParserStateMax;
     1251          }
     1252
     1253          break;
     1254        }
     1255
     1256        if (Parser->CurrentChunkSize > (((~((UINTN)0)) - 16) / 16)) {
     1257          return EFI_INVALID_PARAMETER;
     1258        }
     1259
     1260        Parser->CurrentChunkSize = Parser->CurrentChunkSize * 16 + HttpIoHexCharToUintn (*Char);
     1261        Char++;
     1262        break;
     1263
     1264      case BodyParserChunkExtStart:
     1265        //
     1266        // Ignore all the chunk extensions.
     1267        //
     1268        if (*Char == '\r') {
     1269          Parser->State = BodyParserChunkSizeEndCR;
     1270        }
     1271
     1272        Char++;
     1273        break;
     1274
     1275      case BodyParserChunkSizeEndCR:
     1276        if (*Char != '\n') {
     1277          Parser->State = BodyParserStateMax;
     1278          break;
     1279        }
     1280
     1281        Char++;
     1282        if (Parser->CurrentChunkSize == 0) {
     1283          //
     1284          // The last chunk has been parsed and now assumed the state
     1285          // of HttpBodyParse is ParserLastCRLF. So it need to decide
     1286          // whether the rest message is trailer or last CRLF in the next round.
     1287          //
     1288          Parser->ContentLengthIsValid = TRUE;
     1289          Parser->State                = BodyParserLastCRLF;
     1290          break;
     1291        }
     1292
     1293        Parser->State                  = BodyParserChunkDataStart;
     1294        Parser->CurrentChunkParsedSize = 0;
     1295        break;
     1296
     1297      case BodyParserLastCRLF:
     1298        //
     1299        // Judge the byte is belong to the Last CRLF or trailer, and then
     1300        // configure the state of HttpBodyParse to corresponding state.
     1301        //
     1302        if (*Char == '\r') {
    12281303          Char++;
    1229         } else if (*Char == '\r') {
    1230           Parser->State = BodyParserChunkSizeEndCR;
     1304          Parser->State = BodyParserLastCRLFEnd;
     1305          break;
     1306        } else {
     1307          Parser->State = BodyParserTrailer;
     1308          break;
     1309        }
     1310
     1311      case BodyParserLastCRLFEnd:
     1312        if (*Char == '\n') {
     1313          Parser->State = BodyParserComplete;
    12311314          Char++;
     1315          if (Parser->Callback != NULL) {
     1316            Status = Parser->Callback (
     1317                               BodyParseEventOnComplete,
     1318                               Char,
     1319                               0,
     1320                               Parser->Context
     1321                               );
     1322            if (EFI_ERROR (Status)) {
     1323              return Status;
     1324            }
     1325          }
     1326
     1327          break;
    12321328        } else {
    12331329          Parser->State = BodyParserStateMax;
     1330          break;
    12341331        }
    1235         break;
    1236       }
    1237 
    1238       if (Parser->CurrentChunkSize > (((~((UINTN) 0)) - 16) / 16)) {
    1239         return EFI_INVALID_PARAMETER;
    1240       }
    1241       Parser->CurrentChunkSize = Parser->CurrentChunkSize * 16 + HttpIoHexCharToUintn (*Char);
    1242       Char++;
    1243       break;
    1244 
    1245     case BodyParserChunkExtStart:
    1246       //
    1247       // Ignore all the chunk extensions.
    1248       //
    1249       if (*Char == '\r') {
    1250         Parser->State = BodyParserChunkSizeEndCR;
    1251        }
    1252       Char++;
    1253       break;
    1254 
    1255     case BodyParserChunkSizeEndCR:
    1256       if (*Char != '\n') {
    1257         Parser->State = BodyParserStateMax;
    1258         break;
    1259       }
    1260       Char++;
    1261       if (Parser->CurrentChunkSize == 0) {
     1332
     1333      case BodyParserTrailer:
     1334        if (*Char == '\r') {
     1335          Parser->State = BodyParserChunkSizeEndCR;
     1336        }
     1337
     1338        Char++;
     1339        break;
     1340
     1341      case BodyParserChunkDataStart:
    12621342        //
    1263         // The last chunk has been parsed and now assumed the state
    1264         // of HttpBodyParse is ParserLastCRLF. So it need to decide
    1265         // whether the rest message is trailer or last CRLF in the next round.
     1343        // First byte of chunk-data, the chunk data also might be truncated.
    12661344        //
    1267         Parser->ContentLengthIsValid = TRUE;
    1268         Parser->State = BodyParserLastCRLF;
    1269         break;
    1270       }
    1271       Parser->State = BodyParserChunkDataStart;
    1272       Parser->CurrentChunkParsedSize = 0;
    1273       break;
    1274 
    1275     case BodyParserLastCRLF:
    1276       //
    1277       // Judge the byte is belong to the Last CRLF or trailer, and then
    1278       // configure the state of HttpBodyParse to corresponding state.
    1279       //
    1280       if (*Char == '\r') {
    1281         Char++;
    1282         Parser->State = BodyParserLastCRLFEnd;
    1283         break;
    1284       } else {
    1285         Parser->State = BodyParserTrailer;
    1286         break;
    1287       }
    1288 
    1289     case BodyParserLastCRLFEnd:
    1290       if (*Char == '\n') {
    1291         Parser->State = BodyParserComplete;
    1292         Char++;
     1345        RemainderLengthInThis = BodyLength - (Char - Body);
     1346        LengthForCallback     = MIN (Parser->CurrentChunkSize - Parser->CurrentChunkParsedSize, RemainderLengthInThis);
    12931347        if (Parser->Callback != NULL) {
    12941348          Status = Parser->Callback (
    1295                              BodyParseEventOnComplete,
     1349                             BodyParseEventOnData,
    12961350                             Char,
    1297                              0,
     1351                             LengthForCallback,
    12981352                             Parser->Context
    12991353                             );
    … …  
    13021356          }
    13031357        }
    1304         break;
    1305       } else {
    1306         Parser->State = BodyParserStateMax;
    1307         break;
    1308       }
    1309 
    1310     case BodyParserTrailer:
    1311       if (*Char == '\r') {
    1312         Parser->State = BodyParserChunkSizeEndCR;
    1313       }
    1314       Char++;
    1315       break;
    1316 
    1317     case BodyParserChunkDataStart:
    1318       //
    1319       // First byte of chunk-data, the chunk data also might be truncated.
    1320       //
    1321       RemainderLengthInThis = BodyLength - (Char - Body);
    1322       LengthForCallback = MIN (Parser->CurrentChunkSize - Parser->CurrentChunkParsedSize, RemainderLengthInThis);
    1323       if (Parser->Callback != NULL) {
    1324         Status = Parser->Callback (
    1325                            BodyParseEventOnData,
    1326                            Char,
    1327                            LengthForCallback,
    1328                            Parser->Context
    1329                            );
    1330         if (EFI_ERROR (Status)) {
    1331           return Status;
     1358
     1359        Char                           += LengthForCallback;
     1360        Parser->ContentLength          += LengthForCallback;
     1361        Parser->CurrentChunkParsedSize += LengthForCallback;
     1362        if (Parser->CurrentChunkParsedSize == Parser->CurrentChunkSize) {
     1363          Parser->State = BodyParserChunkDataEnd;
    13321364        }
    1333       }
    1334       Char += LengthForCallback;
    1335       Parser->ContentLength += LengthForCallback;
    1336       Parser->CurrentChunkParsedSize += LengthForCallback;
    1337       if (Parser->CurrentChunkParsedSize == Parser->CurrentChunkSize) {
    1338         Parser->State = BodyParserChunkDataEnd;
    1339       }
    1340       break;
    1341 
    1342     case BodyParserChunkDataEnd:
    1343       if (*Char == '\r') {
    1344         Parser->State = BodyParserChunkDataEndCR;
    1345       } else {
    1346         Parser->State = BodyParserStateMax;
    1347       }
    1348       Char++;
    1349       break;
    1350 
    1351     case BodyParserChunkDataEndCR:
    1352       if (*Char != '\n') {
    1353         Parser->State = BodyParserStateMax;
    1354         break;
    1355       }
    1356       Char++;
    1357       Parser->State = BodyParserChunkSizeStart;
    1358       break;
    1359 
    1360     default:
    1361       break;
    1362     }
    1363 
     1365
     1366        break;
     1367
     1368      case BodyParserChunkDataEnd:
     1369        if (*Char == '\r') {
     1370          Parser->State = BodyParserChunkDataEndCR;
     1371        } else {
     1372          Parser->State = BodyParserStateMax;
     1373        }
     1374
     1375        Char++;
     1376        break;
     1377
     1378      case BodyParserChunkDataEndCR:
     1379        if (*Char != '\n') {
     1380          Parser->State = BodyParserStateMax;
     1381          break;
     1382        }
     1383
     1384        Char++;
     1385        Parser->State = BodyParserChunkSizeStart;
     1386        break;
     1387
     1388      default:
     1389        break;
     1390    }
    13641391  }
    13651392
    … …  
    13831410EFIAPI
    13841411HttpIsMessageComplete (
    1385   IN VOID              *MsgParser
    1386   )
    1387 {
    1388   HTTP_BODY_PARSER      *Parser;
     1412  IN VOID  *MsgParser
     1413  )
     1414{
     1415  HTTP_BODY_PARSER  *Parser;
    13891416
    13901417  if (MsgParser == NULL) {
    … …  
    13921419  }
    13931420
    1394   Parser = (HTTP_BODY_PARSER *) MsgParser;
     1421  Parser = (HTTP_BODY_PARSER *)MsgParser;
    13951422
    13961423  if (Parser->State == BodyParserComplete) {
    13971424    return TRUE;
    13981425  }
     1426
    13991427  return FALSE;
    14001428}
    … …  
    14161444EFIAPI
    14171445HttpGetEntityLength (
    1418   IN  VOID              *MsgParser,
    1419   OUT UINTN             *ContentLength
    1420   )
    1421 {
    1422   HTTP_BODY_PARSER      *Parser;
    1423 
    1424   if (MsgParser == NULL || ContentLength == NULL) {
     1446  IN  VOID   *MsgParser,
     1447  OUT UINTN  *ContentLength
     1448  )
     1449{
     1450  HTTP_BODY_PARSER  *Parser;
     1451
     1452  if ((MsgParser == NULL) || (ContentLength == NULL)) {
    14251453    return EFI_INVALID_PARAMETER;
    14261454  }
    14271455
    1428   Parser = (HTTP_BODY_PARSER *) MsgParser;
     1456  Parser = (HTTP_BODY_PARSER *)MsgParser;
    14291457
    14301458  if (!Parser->ContentLengthIsValid) {
    … …  
    14451473EFIAPI
    14461474HttpFreeMsgParser (
    1447   IN  VOID           *MsgParser
     1475  IN  VOID  *MsgParser
    14481476  )
    14491477{
    14501478  FreePool (MsgParser);
    14511479}
    1452 
    14531480
    14541481/**
    … …  
    14651492CHAR8 *
    14661493AsciiStrGetNextToken (
    1467   IN CONST CHAR8 *String,
    1468   IN       CHAR8 Separator
    1469   )
    1470 {
    1471   CONST CHAR8 *Token;
     1494  IN CONST CHAR8  *String,
     1495  IN       CHAR8  Separator
     1496  )
     1497{
     1498  CONST CHAR8  *Token;
    14721499
    14731500  Token = String;
    … …  
    14761503      return NULL;
    14771504    }
     1505
    14781506    if (*Token == Separator) {
    14791507      return (CHAR8 *)(Token + 1);
    14801508    }
     1509
    14811510    Token++;
    14821511  }
    … …  
    14991528EFIAPI
    15001529HttpSetFieldNameAndValue (
    1501   IN  OUT   EFI_HTTP_HEADER       *HttpHeader,
    1502   IN  CONST CHAR8                 *FieldName,
    1503   IN  CONST CHAR8                 *FieldValue
    1504   )
    1505 {
    1506   UINTN                       FieldNameSize;
    1507   UINTN                       FieldValueSize;
    1508 
    1509   if (HttpHeader == NULL || FieldName == NULL || FieldValue == NULL) {
     1530  IN  OUT   EFI_HTTP_HEADER  *HttpHeader,
     1531  IN  CONST CHAR8            *FieldName,
     1532  IN  CONST CHAR8            *FieldValue
     1533  )
     1534{
     1535  UINTN  FieldNameSize;
     1536  UINTN  FieldValueSize;
     1537
     1538  if ((HttpHeader == NULL) || (FieldName == NULL) || (FieldValue == NULL)) {
    15101539    return EFI_INVALID_PARAMETER;
    15111540  }
    … …  
    15141543    FreePool (HttpHeader->FieldName);
    15151544  }
     1545
    15161546  if (HttpHeader->FieldValue != NULL) {
    15171547    FreePool (HttpHeader->FieldValue);
    15181548  }
    15191549
    1520   FieldNameSize = AsciiStrSize (FieldName);
     1550  FieldNameSize         = AsciiStrSize (FieldName);
    15211551  HttpHeader->FieldName = AllocateZeroPool (FieldNameSize);
    15221552  if (HttpHeader->FieldName == NULL) {
    15231553    return EFI_OUT_OF_RESOURCES;
    15241554  }
     1555
    15251556  CopyMem (HttpHeader->FieldName, FieldName, FieldNameSize);
    15261557  HttpHeader->FieldName[FieldNameSize - 1] = 0;
    15271558
    1528   FieldValueSize = AsciiStrSize (FieldValue);
     1559  FieldValueSize         = AsciiStrSize (FieldValue);
    15291560  HttpHeader->FieldValue = AllocateZeroPool (FieldValueSize);
    15301561  if (HttpHeader->FieldValue == NULL) {
    … …  
    15321563    return EFI_OUT_OF_RESOURCES;
    15331564  }
     1565
    15341566  CopyMem (HttpHeader->FieldValue, FieldValue, FieldValueSize);
    15351567  HttpHeader->FieldValue[FieldValueSize - 1] = 0;
    … …  
    15521584EFIAPI
    15531585HttpGetFieldNameAndValue (
    1554   IN     CHAR8   *String,
    1555      OUT CHAR8   **FieldName,
    1556      OUT CHAR8   **FieldValue
     1586  IN     CHAR8  *String,
     1587  OUT CHAR8     **FieldName,
     1588  OUT CHAR8     **FieldValue
    15571589  )
    15581590{
    … …  
    15621594  CHAR8  *EndofHeader;
    15631595
    1564   if (String == NULL || FieldName == NULL || FieldValue == NULL) {
     1596  if ((String == NULL) || (FieldName == NULL) || (FieldValue == NULL)) {
    15651597    return NULL;
    15661598  }
    … …  
    15731605  EndofHeader   = NULL;
    15741606
    1575 
    15761607  //
    15771608  // Check whether the raw HTTP header string is valid or not.
    … …  
    15971628  //       HT   = '\t' (Tab).
    15981629  //
    1599   FieldNameStr = String;
     1630  FieldNameStr  = String;
    16001631  FieldValueStr = AsciiStrGetNextToken (FieldNameStr, ':');
    16011632  if (FieldValueStr == NULL) {
    … …  
    16121643  //
    16131644  while (TRUE) {
    1614     if (*FieldValueStr == ' ' || *FieldValueStr == '\t') {
     1645    if ((*FieldValueStr == ' ') || (*FieldValueStr == '\t')) {
    16151646      //
    16161647      // Boundary condition check.
    16171648      //
    1618       if ((UINTN) EndofHeader - (UINTN) FieldValueStr < 1) {
     1649      if ((UINTN)EndofHeader - (UINTN)FieldValueStr < 1) {
    16191650        //
    16201651        // Wrong String format!
    … …  
    16231654      }
    16241655
    1625       FieldValueStr ++;
     1656      FieldValueStr++;
    16261657    } else if (*FieldValueStr == '\r') {
    16271658      //
    16281659      // Boundary condition check.
    16291660      //
    1630       if ((UINTN) EndofHeader - (UINTN) FieldValueStr < 3) {
     1661      if ((UINTN)EndofHeader - (UINTN)FieldValueStr < 3) {
    16311662        //
    16321663        // No more preceded LWS, so break here.
    … …  
    16361667
    16371668      if (*(FieldValueStr + 1) == '\n' ) {
    1638         if (*(FieldValueStr + 2) == ' ' || *(FieldValueStr + 2) == '\t') {
     1669        if ((*(FieldValueStr + 2) == ' ') || (*(FieldValueStr + 2) == '\t')) {
    16391670          FieldValueStr = FieldValueStr + 3;
    16401671        } else {
    … …  
    16641695    //
    16651696    StrPtr = AsciiStrGetNextToken (StrPtr, '\r');
    1666     if (StrPtr == NULL || *StrPtr != '\n') {
     1697    if ((StrPtr == NULL) || (*StrPtr != '\n')) {
    16671698      //
    16681699      // Wrong String format!
    … …  
    16821713  // Get FieldName and FieldValue.
    16831714  //
    1684   *FieldName = FieldNameStr;
     1715  *FieldName  = FieldNameStr;
    16851716  *FieldValue = FieldValueStr;
    16861717
    … …  
    17021733  )
    17031734{
    1704   UINTN                       Index;
     1735  UINTN  Index;
    17051736
    17061737  if (HeaderFields != NULL) {
    … …  
    17091740        FreePool (HeaderFields[Index].FieldName);
    17101741      }
     1742
    17111743      if (HeaderFields[Index].FieldValue != NULL) {
    17121744        FreePool (HeaderFields[Index].FieldValue);
    … …  
    17421774EFIAPI
    17431775HttpGenRequestMessage (
    1744   IN     CONST EFI_HTTP_MESSAGE        *Message,
    1745   IN     CONST CHAR8                   *Url,
    1746      OUT CHAR8                         **RequestMsg,
    1747      OUT UINTN                         *RequestMsgSize
    1748   )
    1749 {
    1750   EFI_STATUS                       Status;
    1751   UINTN                            StrLength;
    1752   CHAR8                            *RequestPtr;
    1753   UINTN                            HttpHdrSize;
    1754   UINTN                            MsgSize;
    1755   BOOLEAN                          Success;
    1756   VOID                             *HttpHdr;
    1757   EFI_HTTP_HEADER                  **AppendList;
    1758   UINTN                            Index;
    1759   EFI_HTTP_UTILITIES_PROTOCOL      *HttpUtilitiesProtocol;
     1776  IN     CONST EFI_HTTP_MESSAGE  *Message,
     1777  IN     CONST CHAR8             *Url,
     1778  OUT CHAR8                      **RequestMsg,
     1779  OUT UINTN                      *RequestMsgSize
     1780  )
     1781{
     1782  EFI_STATUS                   Status;
     1783  UINTN                        StrLength;
     1784  CHAR8                        *RequestPtr;
     1785  UINTN                        HttpHdrSize;
     1786  UINTN                        MsgSize;
     1787  BOOLEAN                      Success;
     1788  VOID                         *HttpHdr;
     1789  EFI_HTTP_HEADER              **AppendList;
     1790  UINTN                        Index;
     1791  EFI_HTTP_UTILITIES_PROTOCOL  *HttpUtilitiesProtocol;
    17601792
    17611793  Status                = EFI_SUCCESS;
    … …  
    17731805  // 4. If we do not have Request and Headers, we need at least a message-body
    17741806  //
    1775   if ((Message == NULL || RequestMsg == NULL || RequestMsgSize == NULL) ||
    1776       (Message->Data.Request != NULL && Url == NULL) ||
    1777       (Message->Data.Request != NULL && Message->HeaderCount == 0) ||
    1778       (Message->Data.Request == NULL && Message->HeaderCount != 0) ||
    1779       (Message->Data.Request == NULL && Message->HeaderCount == 0 && Message->BodyLength == 0)) {
     1807  if (((Message == NULL) || (RequestMsg == NULL) || (RequestMsgSize == NULL)) ||
     1808      ((Message->Data.Request != NULL) && (Url == NULL)) ||
     1809      ((Message->Data.Request != NULL) && (Message->HeaderCount == 0)) ||
     1810      ((Message->Data.Request == NULL) && (Message->HeaderCount != 0)) ||
     1811      ((Message->Data.Request == NULL) && (Message->HeaderCount == 0) && (Message->BodyLength == 0)))
     1812  {
    17801813    return EFI_INVALID_PARAMETER;
    17811814  }
    … …  
    17881821                    &gEfiHttpUtilitiesProtocolGuid,
    17891822                    NULL,
    1790                     (VOID **) &HttpUtilitiesProtocol
     1823                    (VOID **)&HttpUtilitiesProtocol
    17911824                    );
    17921825
    17931826    if (EFI_ERROR (Status)) {
    1794       DEBUG ((DEBUG_ERROR,"Failed to locate Http Utilities protocol. Status = %r.\n", Status));
     1827      DEBUG ((DEBUG_ERROR, "Failed to locate Http Utilities protocol. Status = %r.\n", Status));
    17951828      return Status;
    17961829    }
    … …  
    18041837    }
    18051838
    1806     for(Index = 0; Index < Message->HeaderCount; Index++){
     1839    for (Index = 0; Index < Message->HeaderCount; Index++) {
    18071840      AppendList[Index] = &Message->Headers[Index];
    18081841    }
    … …  
    18251858    FreePool (AppendList);
    18261859
    1827     if (EFI_ERROR (Status) || HttpHdr == NULL){
     1860    if (EFI_ERROR (Status) || (HttpHdr == NULL)) {
    18281861      return Status;
    18291862    }
    … …  
    18431876    MsgSize += HTTP_METHOD_MAXIMUM_LEN + AsciiStrLen (HTTP_VERSION_CRLF_STR) + AsciiStrLen (Url);
    18441877  }
    1845 
    18461878
    18471879  //
    … …  
    18661898  if (Message->Data.Request != NULL) {
    18671899    switch (Message->Data.Request->Method) {
    1868     case HttpMethodGet:
    1869       StrLength = sizeof (HTTP_METHOD_GET) - 1;
    1870       CopyMem (RequestPtr, HTTP_METHOD_GET, StrLength);
    1871       RequestPtr += StrLength;
    1872       break;
    1873     case HttpMethodPut:
    1874       StrLength = sizeof (HTTP_METHOD_PUT) - 1;
    1875       CopyMem (RequestPtr, HTTP_METHOD_PUT, StrLength);
    1876       RequestPtr += StrLength;
    1877       break;
    1878     case HttpMethodPatch:
    1879       StrLength = sizeof (HTTP_METHOD_PATCH) - 1;
    1880       CopyMem (RequestPtr, HTTP_METHOD_PATCH, StrLength);
    1881       RequestPtr += StrLength;
    1882       break;
    1883     case HttpMethodPost:
    1884       StrLength = sizeof (HTTP_METHOD_POST) - 1;
    1885       CopyMem (RequestPtr, HTTP_METHOD_POST, StrLength);
    1886       RequestPtr += StrLength;
    1887       break;
    1888     case HttpMethodHead:
    1889       StrLength = sizeof (HTTP_METHOD_HEAD) - 1;
    1890       CopyMem (RequestPtr, HTTP_METHOD_HEAD, StrLength);
    1891       RequestPtr += StrLength;
    1892       break;
    1893     case HttpMethodDelete:
    1894       StrLength = sizeof (HTTP_METHOD_DELETE) - 1;
    1895       CopyMem (RequestPtr, HTTP_METHOD_DELETE, StrLength);
    1896       RequestPtr += StrLength;
    1897       break;
    1898     default:
    1899       ASSERT (FALSE);
    1900       Status = EFI_INVALID_PARAMETER;
    1901       goto Exit;
    1902     }
    1903 
    1904     StrLength = AsciiStrLen(EMPTY_SPACE);
     1900      case HttpMethodGet:
     1901        StrLength = sizeof (HTTP_METHOD_GET) - 1;
     1902        CopyMem (RequestPtr, HTTP_METHOD_GET, StrLength);
     1903        RequestPtr += StrLength;
     1904        break;
     1905      case HttpMethodPut:
     1906        StrLength = sizeof (HTTP_METHOD_PUT) - 1;
     1907        CopyMem (RequestPtr, HTTP_METHOD_PUT, StrLength);
     1908        RequestPtr += StrLength;
     1909        break;
     1910      case HttpMethodPatch:
     1911        StrLength = sizeof (HTTP_METHOD_PATCH) - 1;
     1912        CopyMem (RequestPtr, HTTP_METHOD_PATCH, StrLength);
     1913        RequestPtr += StrLength;
     1914        break;
     1915      case HttpMethodPost:
     1916        StrLength = sizeof (HTTP_METHOD_POST) - 1;
     1917        CopyMem (RequestPtr, HTTP_METHOD_POST, StrLength);
     1918        RequestPtr += StrLength;
     1919        break;
     1920      case HttpMethodHead:
     1921        StrLength = sizeof (HTTP_METHOD_HEAD) - 1;
     1922        CopyMem (RequestPtr, HTTP_METHOD_HEAD, StrLength);
     1923        RequestPtr += StrLength;
     1924        break;
     1925      case HttpMethodDelete:
     1926        StrLength = sizeof (HTTP_METHOD_DELETE) - 1;
     1927        CopyMem (RequestPtr, HTTP_METHOD_DELETE, StrLength);
     1928        RequestPtr += StrLength;
     1929        break;
     1930      default:
     1931        ASSERT (FALSE);
     1932        Status = EFI_INVALID_PARAMETER;
     1933        goto Exit;
     1934    }
     1935
     1936    StrLength = AsciiStrLen (EMPTY_SPACE);
    19051937    CopyMem (RequestPtr, EMPTY_SPACE, StrLength);
    19061938    RequestPtr += StrLength;
    … …  
    19351967  //
    19361968  (*RequestMsgSize) = (UINTN)(RequestPtr) - (UINTN)(*RequestMsg);
    1937   Success     = TRUE;
     1969  Success           = TRUE;
    19381970
    19391971Exit:
    … …  
    19431975      FreePool (*RequestMsg);
    19441976    }
     1977
    19451978    *RequestMsg = NULL;
    19461979    return Status;
    … …  
    19661999EFIAPI
    19672000HttpMappingToStatusCode (
    1968   IN UINTN                  StatusCode
     2001  IN UINTN  StatusCode
    19692002  )
    19702003{
    19712004  switch (StatusCode) {
    1972   case 100:
    1973     return HTTP_STATUS_100_CONTINUE;
    1974   case 101:
    1975     return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
    1976   case 200:
    1977     return HTTP_STATUS_200_OK;
    1978   case 201:
    1979     return HTTP_STATUS_201_CREATED;
    1980   case 202:
    1981     return HTTP_STATUS_202_ACCEPTED;
    1982   case 203:
    1983     return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
    1984   case 204:
    1985     return HTTP_STATUS_204_NO_CONTENT;
    1986   case 205:
    1987     return HTTP_STATUS_205_RESET_CONTENT;
    1988   case 206:
    1989     return HTTP_STATUS_206_PARTIAL_CONTENT;
    1990   case 300:
    1991     return HTTP_STATUS_300_MULTIPLE_CHOICES;
    1992   case 301:
    1993     return HTTP_STATUS_301_MOVED_PERMANENTLY;
    1994   case 302:
    1995     return HTTP_STATUS_302_FOUND;
    1996   case 303:
    1997     return HTTP_STATUS_303_SEE_OTHER;
    1998   case 304:
    1999     return HTTP_STATUS_304_NOT_MODIFIED;
    2000   case 305:
    2001     return HTTP_STATUS_305_USE_PROXY;
    2002   case 307:
    2003     return HTTP_STATUS_307_TEMPORARY_REDIRECT;
    2004   case 308:
    2005     return HTTP_STATUS_308_PERMANENT_REDIRECT;
    2006   case 400:
    2007     return HTTP_STATUS_400_BAD_REQUEST;
    2008   case 401:
    2009     return HTTP_STATUS_401_UNAUTHORIZED;
    2010   case 402:
    2011     return HTTP_STATUS_402_PAYMENT_REQUIRED;
    2012   case 403:
    2013     return HTTP_STATUS_403_FORBIDDEN;
    2014   case 404:
    2015     return HTTP_STATUS_404_NOT_FOUND;
    2016   case 405:
    2017     return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
    2018   case 406:
    2019     return HTTP_STATUS_406_NOT_ACCEPTABLE;
    2020   case 407:
    2021     return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
    2022   case 408:
    2023     return HTTP_STATUS_408_REQUEST_TIME_OUT;
    2024   case 409:
    2025     return HTTP_STATUS_409_CONFLICT;
    2026   case 410:
    2027     return HTTP_STATUS_410_GONE;
    2028   case 411:
    2029     return HTTP_STATUS_411_LENGTH_REQUIRED;
    2030   case 412:
    2031     return HTTP_STATUS_412_PRECONDITION_FAILED;
    2032   case 413:
    2033     return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
    2034   case 414:
    2035     return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
    2036   case 415:
    2037     return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE;
    2038   case 416:
    2039     return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
    2040   case 417:
    2041     return HTTP_STATUS_417_EXPECTATION_FAILED;
    2042   case 500:
    2043     return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
    2044   case 501:
    2045     return HTTP_STATUS_501_NOT_IMPLEMENTED;
    2046   case 502:
    2047     return HTTP_STATUS_502_BAD_GATEWAY;
    2048   case 503:
    2049     return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
    2050   case 504:
    2051     return HTTP_STATUS_504_GATEWAY_TIME_OUT;
    2052   case 505:
    2053     return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
    2054 
    2055   default:
    2056     return HTTP_STATUS_UNSUPPORTED_STATUS;
     2005    case 100:
     2006      return HTTP_STATUS_100_CONTINUE;
     2007    case 101:
     2008      return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
     2009    case 200:
     2010      return HTTP_STATUS_200_OK;
     2011    case 201:
     2012      return HTTP_STATUS_201_CREATED;
     2013    case 202:
     2014      return HTTP_STATUS_202_ACCEPTED;
     2015    case 203:
     2016      return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
     2017    case 204:
     2018      return HTTP_STATUS_204_NO_CONTENT;
     2019    case 205:
     2020      return HTTP_STATUS_205_RESET_CONTENT;
     2021    case 206:
     2022      return HTTP_STATUS_206_PARTIAL_CONTENT;
     2023    case 300:
     2024      return HTTP_STATUS_300_MULTIPLE_CHOICES;
     2025    case 301:
     2026      return HTTP_STATUS_301_MOVED_PERMANENTLY;
     2027    case 302:
     2028      return HTTP_STATUS_302_FOUND;
     2029    case 303:
     2030      return HTTP_STATUS_303_SEE_OTHER;
     2031    case 304:
     2032      return HTTP_STATUS_304_NOT_MODIFIED;
     2033    case 305:
     2034      return HTTP_STATUS_305_USE_PROXY;
     2035    case 307:
     2036      return HTTP_STATUS_307_TEMPORARY_REDIRECT;
     2037    case 308:
     2038      return HTTP_STATUS_308_PERMANENT_REDIRECT;
     2039    case 400:
     2040      return HTTP_STATUS_400_BAD_REQUEST;
     2041    case 401:
     2042      return HTTP_STATUS_401_UNAUTHORIZED;
     2043    case 402:
     2044      return HTTP_STATUS_402_PAYMENT_REQUIRED;
     2045    case 403:
     2046      return HTTP_STATUS_403_FORBIDDEN;
     2047    case 404:
     2048      return HTTP_STATUS_404_NOT_FOUND;
     2049    case 405:
     2050      return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
     2051    case 406:
     2052      return HTTP_STATUS_406_NOT_ACCEPTABLE;
     2053    case 407:
     2054      return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
     2055    case 408:
     2056      return HTTP_STATUS_408_REQUEST_TIME_OUT;
     2057    case 409:
     2058      return HTTP_STATUS_409_CONFLICT;
     2059    case 410:
     2060      return HTTP_STATUS_410_GONE;
     2061    case 411:
     2062      return HTTP_STATUS_411_LENGTH_REQUIRED;
     2063    case 412:
     2064      return HTTP_STATUS_412_PRECONDITION_FAILED;
     2065    case 413:
     2066      return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
     2067    case 414:
     2068      return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
     2069    case 415:
     2070      return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE;
     2071    case 416:
     2072      return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
     2073    case 417:
     2074      return HTTP_STATUS_417_EXPECTATION_FAILED;
     2075    case 500:
     2076      return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
     2077    case 501:
     2078      return HTTP_STATUS_501_NOT_IMPLEMENTED;
     2079    case 502:
     2080      return HTTP_STATUS_502_BAD_GATEWAY;
     2081    case 503:
     2082      return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
     2083    case 504:
     2084      return HTTP_STATUS_504_GATEWAY_TIME_OUT;
     2085    case 505:
     2086      return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
     2087
     2088    default:
     2089      return HTTP_STATUS_UNSUPPORTED_STATUS;
    20572090  }
    20582091}
    … …  
    20722105EFIAPI
    20732106HttpIsValidHttpHeader (
    2074   IN  CHAR8            *DeleteList[],
    2075   IN  UINTN            DeleteCount,
    2076   IN  CHAR8            *FieldName
    2077   )
    2078 {
    2079   UINTN                       Index;
     2107  IN  CHAR8  *DeleteList[],
     2108  IN  UINTN  DeleteCount,
     2109  IN  CHAR8  *FieldName
     2110  )
     2111{
     2112  UINTN  Index;
    20802113
    20812114  if (FieldName == NULL) {
    … …  
    20962129}
    20972130
    2098 
    20992131/**
    21002132  Create a HTTP_IO_HEADER to hold the HTTP header items.
    … …  
    21072139HTTP_IO_HEADER *
    21082140HttpIoCreateHeader (
    2109   UINTN                     MaxHeaderCount
    2110   )
    2111 {
    2112   HTTP_IO_HEADER        *HttpIoHeader;
     2141  UINTN  MaxHeaderCount
     2142  )
     2143{
     2144  HTTP_IO_HEADER  *HttpIoHeader;
    21132145
    21142146  if (MaxHeaderCount == 0) {
    … …  
    21222154
    21232155  HttpIoHeader->MaxHeaderCount = MaxHeaderCount;
    2124   HttpIoHeader->Headers = (EFI_HTTP_HEADER *) (HttpIoHeader + 1);
     2156  HttpIoHeader->Headers        = (EFI_HTTP_HEADER *)(HttpIoHeader + 1);
    21252157
    21262158  return HttpIoHeader;
    … …  
    21352167VOID
    21362168HttpIoFreeHeader (
    2137   IN  HTTP_IO_HEADER       *HttpIoHeader
    2138   )
    2139 {
    2140   UINTN      Index;
     2169  IN  HTTP_IO_HEADER  *HttpIoHeader
     2170  )
     2171{
     2172  UINTN  Index;
    21412173
    21422174  if (HttpIoHeader != NULL) {
    … …  
    21482180      }
    21492181    }
     2182
    21502183    FreePool (HttpIoHeader);
    21512184  }
    … …  
    21672200EFI_STATUS
    21682201HttpIoSetHeader (
    2169   IN  HTTP_IO_HEADER       *HttpIoHeader,
    2170   IN  CHAR8                *FieldName,
    2171   IN  CHAR8                *FieldValue
    2172   )
    2173 {
    2174   EFI_HTTP_HEADER       *Header;
    2175   UINTN                 StrSize;
    2176   CHAR8                 *NewFieldValue;
    2177 
    2178   if (HttpIoHeader == NULL || FieldName == NULL || FieldValue == NULL) {
     2202  IN  HTTP_IO_HEADER  *HttpIoHeader,
     2203  IN  CHAR8           *FieldName,
     2204  IN  CHAR8           *FieldValue
     2205  )
     2206{
     2207  EFI_HTTP_HEADER  *Header;
     2208  UINTN            StrSize;
     2209  CHAR8            *NewFieldValue;
     2210
     2211  if ((HttpIoHeader == NULL) || (FieldName == NULL) || (FieldValue == NULL)) {
    21792212    return EFI_INVALID_PARAMETER;
    21802213  }
    … …  
    21882221      return EFI_OUT_OF_RESOURCES;
    21892222    }
     2223
    21902224    Header = &HttpIoHeader->Headers[HttpIoHeader->HeaderCount];
    21912225
    2192     StrSize = AsciiStrSize (FieldName);
     2226    StrSize           = AsciiStrSize (FieldName);
    21932227    Header->FieldName = AllocatePool (StrSize);
    21942228    if (Header->FieldName == NULL) {
    21952229      return EFI_OUT_OF_RESOURCES;
    21962230    }
     2231
    21972232    CopyMem (Header->FieldName, FieldName, StrSize);
    21982233    Header->FieldName[StrSize -1] = '\0';
    21992234
    2200     StrSize = AsciiStrSize (FieldValue);
     2235    StrSize            = AsciiStrSize (FieldValue);
    22012236    Header->FieldValue = AllocatePool (StrSize);
    22022237    if (Header->FieldValue == NULL) {
    … …  
    22042239      return EFI_OUT_OF_RESOURCES;
    22052240    }
     2241
    22062242    CopyMem (Header->FieldValue, FieldValue, StrSize);
    22072243    Header->FieldValue[StrSize -1] = '\0';
    … …  
    22122248    // Update an existing one.
    22132249    //
    2214     StrSize = AsciiStrSize (FieldValue);
     2250    StrSize       = AsciiStrSize (FieldValue);
    22152251    NewFieldValue = AllocatePool (StrSize);
    22162252    if (NewFieldValue == NULL) {
    22172253      return EFI_OUT_OF_RESOURCES;
    22182254    }
     2255
    22192256    CopyMem (NewFieldValue, FieldValue, StrSize);
    22202257    NewFieldValue[StrSize -1] = '\0';
    … …  
    22232260      FreePool (Header->FieldValue);
    22242261    }
     2262
    22252263    Header->FieldValue = NewFieldValue;
    22262264  }
Note: See TracChangeset for help on using the changeset viewer.

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