MdeModulePkg/Library/DxeHttpLib/DxeHttpLib.c

   1 /** @file
   2   This library is used to share code between UEFI network stack modules.
   3   It provides the helper routines to parse the HTTP message byte stream.
   4
   5 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
   6 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   7 This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at<BR>
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "DxeHttpLib.h"
  18
  19
  20
  21 /**
  22   Decode a percent-encoded URI component to the ASCII character.
  23
  24   Decode the input component in Buffer according to RFC 3986. The caller is responsible to make
  25   sure ResultBuffer points to a buffer with size equal or greater than ((AsciiStrSize (Buffer))
  26   in bytes.
  27
  28   @param[in]    Buffer           The pointer to a percent-encoded URI component.
  29   @param[in]    BufferLength     Length of Buffer in bytes.
  30   @param[out]   ResultBuffer     Point to the buffer to store the decode result.
  31   @param[out]   ResultLength     Length of decoded string in ResultBuffer in bytes.
  32
  33   @retval EFI_SUCCESS            Successfully decoded the URI.
  34   @retval EFI_INVALID_PARAMETER  Buffer is not a valid percent-encoded string.
  35
  36 **/
  37 EFI_STATUS
  38 EFIAPI
  39 UriPercentDecode (
  40   IN      CHAR8            *Buffer,
  41   IN      UINT32            BufferLength,
  42      OUT  CHAR8            *ResultBuffer,
  43      OUT  UINT32           *ResultLength
  44   )
  45 {
  46   UINTN           Index;
  47   UINTN           Offset;
  48   CHAR8           HexStr[3];
  49
  50   if (Buffer == NULL || BufferLength == 0 || ResultBuffer == NULL) {
  51     return EFI_INVALID_PARAMETER;
  52   }
  53
  54   Index = 0;
  55   Offset = 0;
  56   HexStr[2] = '\0';
  57   while (Index < BufferLength) {
  58     if (Buffer[Index] == '%') {
  59       if (!NET_IS_HEX_CHAR (Buffer[Index+1]) || !NET_IS_HEX_CHAR (Buffer[Index+2])) {
  60         return EFI_INVALID_PARAMETER;
  61       }
  62       HexStr[0] = Buffer[Index+1];
  63       HexStr[1] = Buffer[Index+2];
  64       ResultBuffer[Offset] = (CHAR8) AsciiStrHexToUintn (HexStr);
  65       Index += 3;
  66     } else {
  67       ResultBuffer[Offset] = Buffer[Index];
  68       Index++;
  69     }
  70     Offset++;
  71   }
  72
  73   *ResultLength = (UINT32) Offset;
  74
  75   return EFI_SUCCESS;
  76 }
  77
  78 /**
  79   This function return the updated state according to the input state and next character of
  80   the authority.
  81
  82   @param[in]       Char           Next character.
  83   @param[in]       State          Current value of the parser state machine.
  84   @param[in]       IsRightBracket TRUE if there is an sign ']' in the authority component and
  85                                   indicates the next part is ':' before Port.
  86
  87   @return          Updated state value.
  88 **/
  89 HTTP_URL_PARSE_STATE
  90 NetHttpParseAuthorityChar (
  91   IN  CHAR8                  Char,
  92   IN  HTTP_URL_PARSE_STATE   State,
  93   IN  BOOLEAN                *IsRightBracket
  94   )
  95 {
  96
  97   //
  98   // RFC 3986:
  99   // The authority component is preceded by a double slash ("//") and is
 100   // terminated by the next slash ("/"), question mark ("?"), or number
 101   // sign ("#") character, or by the end of the URI.
 102   //
 103   if (Char == ' ' || Char == '\r' || Char == '\n') {
 104     return UrlParserStateMax;
 105   }
 106
 107   //
 108   // authority   = [ userinfo "@" ] host [ ":" port ]
 109   //
 110   switch (State) {
 111   case UrlParserUserInfo:
 112     if (Char == '@') {
 113       return UrlParserHostStart;
 114     }
 115     break;
 116
 117   case UrlParserHost:
 118   case UrlParserHostStart:
 119     if (Char == '[') {
 120       return UrlParserHostIpv6;
 121     }
 122
 123     if (Char == ':') {
 124       return UrlParserPortStart;
 125     }
 126
 127     return UrlParserHost;
 128
 129   case UrlParserHostIpv6:
 130     if (Char == ']') {
 131       *IsRightBracket = TRUE;
 132     }
 133
 134     if (Char == ':' && *IsRightBracket) {
 135       return UrlParserPortStart;
 136     }
 137     return UrlParserHostIpv6;
 138
 139   case UrlParserPort:
 140   case UrlParserPortStart:
 141     return UrlParserPort;
 142
 143   default:
 144     break;
 145   }
 146
 147   return State;
 148 }
 149
 150 /**
 151   This function parse the authority component of the input URL and update the parser.
 152
 153   @param[in]       Url            The pointer to a HTTP URL string.
 154   @param[in]       FoundAt        TRUE if there is an at sign ('@') in the authority component.
 155   @param[in, out]  UrlParser      Pointer to the buffer of the parse result.
 156
 157   @retval EFI_SUCCESS             Successfully parse the authority.
 158   @retval Other                   Error happened.
 159
 160 **/
 161 EFI_STATUS
 162 NetHttpParseAuthority (
 163   IN      CHAR8              *Url,
 164   IN      BOOLEAN            FoundAt,
 165   IN OUT  HTTP_URL_PARSER    *UrlParser
 166   )
 167 {
 168   CHAR8                 *Char;
 169   CHAR8                 *Authority;
 170   UINT32                Length;
 171   HTTP_URL_PARSE_STATE  State;
 172   UINT32                Field;
 173   UINT32                OldField;
 174   BOOLEAN               IsrightBracket;
 175
 176   ASSERT ((UrlParser->FieldBitMap & BIT (HTTP_URI_FIELD_AUTHORITY)) != 0);
 177
 178   //
 179   // authority   = [ userinfo "@" ] host [ ":" port ]
 180   //
 181   if (FoundAt) {
 182     State = UrlParserUserInfo;
 183   } else {
 184     State = UrlParserHost;
 185   }
 186
 187   IsrightBracket = FALSE;
 188   Field = HTTP_URI_FIELD_MAX;
 189   OldField = Field;
 190   Authority = Url + UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Offset;
 191   Length = UrlParser->FieldData[HTTP_URI_FIELD_AUTHORITY].Length;
 192   for (Char = Authority; Char < Authority + Length; Char++) {
 193     State = NetHttpParseAuthorityChar (*Char, State, &IsrightBracket);
 194     switch (State) {
 195     case UrlParserStateMax:
 196       return EFI_INVALID_PARAMETER;
 197
 198     case UrlParserHostStart:
 199     case UrlParserPortStart:
 200       continue;
 201
 202     case UrlParserUserInfo:
 203       Field = HTTP_URI_FIELD_USERINFO;
 204       break;
 205
 206     case UrlParserHost:
 207       Field = HTTP_URI_FIELD_HOST;
 208       break;
 209
 210     case UrlParserHostIpv6:
 211       Field = HTTP_URI_FIELD_HOST;
 212       break;
 213
 214     case UrlParserPort:
 215       Field = HTTP_URI_FIELD_PORT;
 216       break;
 217
 218     default:
 219       ASSERT (FALSE);
 220     }
 221
 222     //
 223     // Field not changed, count the length.
 224     //
 225     ASSERT (Field < HTTP_URI_FIELD_MAX);
 226     if (Field == OldField) {
 227       UrlParser->FieldData[Field].Length++;
 228       continue;
 229     }
 230
 231     //
 232     // New field start
 233     //
 234     UrlParser->FieldBitMap |= BIT (Field);
 235     UrlParser->FieldData[Field].Offset = (UINT32) (Char - Url);
 236     UrlParser->FieldData[Field].Length = 1;
 237     OldField = Field;
 238   }
 239
 240   return EFI_SUCCESS;
 241 }
 242
 243 /**
 244   This function return the updated state according to the input state and next character of a URL.
 245
 246   @param[in]       Char           Next character.
 247   @param[in]       State          Current value of the parser state machine.
 248
 249   @return          Updated state value.
 250
 251 **/
 252 HTTP_URL_PARSE_STATE
 253 NetHttpParseUrlChar (
 254   IN  CHAR8                  Char,
 255   IN  HTTP_URL_PARSE_STATE   State
 256   )
 257 {
 258   if (Char == ' ' || Char == '\r' || Char == '\n') {
 259     return UrlParserStateMax;
 260   }
 261
 262   //
 263   // http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
 264   //
 265   // Request-URI    = "*" | absolute-URI | path-absolute | authority
 266   //
 267   // absolute-URI  = scheme ":" hier-part [ "?" query ]
 268   // path-absolute = "/" [ segment-nz *( "/" segment ) ]
 269   // authority   = [ userinfo "@" ] host [ ":" port ]
 270   //
 271   switch (State) {
 272   case UrlParserUrlStart:
 273     if (Char == '*' || Char == '/') {
 274       return UrlParserPath;
 275     }
 276     return UrlParserScheme;
 277
 278   case UrlParserScheme:
 279     if (Char == ':') {
 280       return UrlParserSchemeColon;
 281     }
 282     break;
 283
 284   case UrlParserSchemeColon:
 285     if (Char == '/') {
 286       return UrlParserSchemeColonSlash;
 287     }
 288     break;
 289
 290   case UrlParserSchemeColonSlash:
 291     if (Char == '/') {
 292       return UrlParserSchemeColonSlashSlash;
 293     }
 294     break;
 295
 296   case UrlParserAtInAuthority:
 297     if (Char == '@') {
 298       return UrlParserStateMax;
 299     }
 300
 301   case UrlParserAuthority:
 302   case UrlParserSchemeColonSlashSlash:
 303     if (Char == '@') {
 304       return UrlParserAtInAuthority;
 305     }
 306     if (Char == '/') {
 307       return UrlParserPath;
 308     }
 309     if (Char == '?') {
 310       return UrlParserQueryStart;
 311     }
 312     if (Char == '#') {
 313       return UrlParserFragmentStart;
 314     }
 315     return UrlParserAuthority;
 316
 317   case UrlParserPath:
 318     if (Char == '?') {
 319       return UrlParserQueryStart;
 320     }
 321     if (Char == '#') {
 322       return UrlParserFragmentStart;
 323     }
 324     break;
 325
 326   case UrlParserQuery:
 327   case UrlParserQueryStart:
 328     if (Char == '#') {
 329       return UrlParserFragmentStart;
 330     }
 331     return UrlParserQuery;
 332
 333   case UrlParserFragmentStart:
 334     return UrlParserFragment;
 335
 336   default:
 337     break;
 338   }
 339
 340   return State;
 341 }
 342 /**
 343   Create a URL parser for the input URL string.
 344
 345   This function will parse and dereference the input HTTP URL into it components. The original
 346   content of the URL won't be modified and the result will be returned in UrlParser, which can
 347   be used in other functions like NetHttpUrlGetHostName().
 348
 349   @param[in]    Url                The pointer to a HTTP URL string.
 350   @param[in]    Length             Length of Url in bytes.
 351   @param[in]    IsConnectMethod    Whether the Url is used in HTTP CONNECT method or not.
 352   @param[out]   UrlParser          Pointer to the returned buffer to store the parse result.
 353
 354   @retval EFI_SUCCESS              Successfully dereferenced the HTTP URL.
 355   @retval EFI_INVALID_PARAMETER    UrlParser is NULL or Url is not a valid HTTP URL.
 356   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 357
 358 **/
 359 EFI_STATUS
 360 EFIAPI
 361 HttpParseUrl (
 362   IN      CHAR8              *Url,
 363   IN      UINT32             Length,
 364   IN      BOOLEAN            IsConnectMethod,
 365      OUT  VOID               **UrlParser
 366   )
 367 {
 368   HTTP_URL_PARSE_STATE  State;
 369   CHAR8                 *Char;
 370   UINT32                Field;
 371   UINT32                OldField;
 372   BOOLEAN               FoundAt;
 373   EFI_STATUS            Status;
 374   HTTP_URL_PARSER       *Parser;
 375
 376   if (Url == NULL || Length == 0 || UrlParser == NULL) {
 377     return EFI_INVALID_PARAMETER;
 378   }
 379
 380   Parser = AllocateZeroPool (sizeof (HTTP_URL_PARSER));
 381   if (Parser == NULL) {
 382     return EFI_OUT_OF_RESOURCES;
 383   }
 384
 385   if (IsConnectMethod) {
 386     //
 387     // According to RFC 2616, the authority form is only used by the CONNECT method.
 388     //
 389     State = UrlParserAuthority;
 390   } else {
 391     State = UrlParserUrlStart;
 392   }
 393
 394   Field = HTTP_URI_FIELD_MAX;
 395   OldField = Field;
 396   FoundAt = FALSE;
 397   for (Char = Url; Char < Url + Length; Char++) {
 398     //
 399     // Update state machine according to next char.
 400     //
 401     State = NetHttpParseUrlChar (*Char, State);
 402
 403     switch (State) {
 404     case UrlParserStateMax:
 405       return EFI_INVALID_PARAMETER;
 406
 407     case UrlParserSchemeColon:
 408     case UrlParserSchemeColonSlash:
 409     case UrlParserSchemeColonSlashSlash:
 410     case UrlParserQueryStart:
 411     case UrlParserFragmentStart:
 412       //
 413       // Skip all the delimiting char: "://" "?" "@"
 414       //
 415       continue;
 416
 417     case UrlParserScheme:
 418       Field = HTTP_URI_FIELD_SCHEME;
 419       break;
 420
 421     case UrlParserAtInAuthority:
 422       FoundAt = TRUE;
 423     case UrlParserAuthority:
 424       Field = HTTP_URI_FIELD_AUTHORITY;
 425       break;
 426
 427     case UrlParserPath:
 428       Field = HTTP_URI_FIELD_PATH;
 429       break;
 430
 431     case UrlParserQuery:
 432       Field = HTTP_URI_FIELD_QUERY;
 433       break;
 434
 435     case UrlParserFragment:
 436       Field = HTTP_URI_FIELD_FRAGMENT;
 437       break;
 438
 439     default:
 440       ASSERT (FALSE);
 441     }
 442
 443     //
 444     // Field not changed, count the length.
 445     //
 446     ASSERT (Field < HTTP_URI_FIELD_MAX);
 447     if (Field == OldField) {
 448       Parser->FieldData[Field].Length++;
 449       continue;
 450     }
 451
 452     //
 453     // New field start
 454     //
 455     Parser->FieldBitMap |= BIT (Field);
 456     Parser->FieldData[Field].Offset = (UINT32) (Char - Url);
 457     Parser->FieldData[Field].Length = 1;
 458     OldField = Field;
 459   }
 460
 461   //
 462   // If has authority component, continue to parse the username, host and port.
 463   //
 464   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_AUTHORITY)) != 0) {
 465     Status = NetHttpParseAuthority (Url, FoundAt, Parser);
 466     if (EFI_ERROR (Status)) {
 467       return Status;
 468     }
 469   }
 470
 471   *UrlParser = Parser;
 472   return EFI_SUCCESS;
 473 }
 474
 475 /**
 476   Get the Hostname from a HTTP URL.
 477
 478   This function will return the HostName according to the Url and previous parse result ,and
 479   it is the caller's responsibility to free the buffer returned in *HostName.
 480
 481   @param[in]    Url                The pointer to a HTTP URL string.
 482   @param[in]    UrlParser          URL Parse result returned by NetHttpParseUrl().
 483   @param[out]   HostName           Pointer to a buffer to store the HostName.
 484
 485   @retval EFI_SUCCESS              Successfully get the required component.
 486   @retval EFI_INVALID_PARAMETER    Uri is NULL or HostName is NULL or UrlParser is invalid.
 487   @retval EFI_NOT_FOUND            No hostName component in the URL.
 488   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 489
 490 **/
 491 EFI_STATUS
 492 EFIAPI
 493 HttpUrlGetHostName (
 494   IN      CHAR8              *Url,
 495   IN      VOID               *UrlParser,
 496      OUT  CHAR8              **HostName
 497   )
 498 {
 499   CHAR8                *Name;
 500   EFI_STATUS           Status;
 501   UINT32               ResultLength;
 502   HTTP_URL_PARSER      *Parser;
 503
 504   if (Url == NULL || UrlParser == NULL || HostName == NULL) {
 505     return EFI_INVALID_PARAMETER;
 506   }
 507
 508   Parser = (HTTP_URL_PARSER*) UrlParser;
 509
 510   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
 511     return EFI_NOT_FOUND;
 512   }
 513
 514   Name = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_HOST].Length + 1);
 515   if (Name == NULL) {
 516     return EFI_OUT_OF_RESOURCES;
 517   }
 518
 519   Status = UriPercentDecode (
 520              Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset,
 521              Parser->FieldData[HTTP_URI_FIELD_HOST].Length,
 522              Name,
 523              &ResultLength
 524              );
 525   if (EFI_ERROR (Status)) {
 526     return Status;
 527   }
 528
 529   Name[ResultLength] = '\0';
 530   *HostName = Name;
 531   return EFI_SUCCESS;
 532 }
 533
 534
 535 /**
 536   Get the IPv4 address from a HTTP URL.
 537
 538   This function will return the IPv4 address according to the Url and previous parse result.
 539
 540   @param[in]    Url                The pointer to a HTTP URL string.
 541   @param[in]    UrlParser          URL Parse result returned by NetHttpParseUrl().
 542   @param[out]   Ip4Address         Pointer to a buffer to store the IP address.
 543
 544   @retval EFI_SUCCESS              Successfully get the required component.
 545   @retval EFI_INVALID_PARAMETER    Uri is NULL or Ip4Address is NULL or UrlParser is invalid.
 546   @retval EFI_NOT_FOUND            No IPv4 address component in the URL.
 547   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 548
 549 **/
 550 EFI_STATUS
 551 EFIAPI
 552 HttpUrlGetIp4 (
 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) {
 564     return EFI_INVALID_PARAMETER;
 565   }
 566
 567   Parser = (HTTP_URL_PARSER*) UrlParser;
 568
 569   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
 570     return EFI_INVALID_PARAMETER;
 571   }
 572
 573   Ip4String = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_HOST].Length + 1);
 574   if (Ip4String == NULL) {
 575     return EFI_OUT_OF_RESOURCES;
 576   }
 577
 578   Status = UriPercentDecode (
 579              Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset,
 580              Parser->FieldData[HTTP_URI_FIELD_HOST].Length,
 581              Ip4String,
 582              &ResultLength
 583              );
 584   if (EFI_ERROR (Status)) {
 585     return Status;
 586   }
 587
 588   Ip4String[ResultLength] = '\0';
 589   Status = NetLibAsciiStrToIp4 (Ip4String, Ip4Address);
 590   FreePool (Ip4String);
 591
 592   return Status;
 593 }
 594
 595 /**
 596   Get the IPv6 address from a HTTP URL.
 597
 598   This function will return the IPv6 address according to the Url and previous parse result.
 599
 600   @param[in]    Url                The pointer to a HTTP URL string.
 601   @param[in]    UrlParser          URL Parse result returned by NetHttpParseUrl().
 602   @param[out]   Ip6Address         Pointer to a buffer to store the IP address.
 603
 604   @retval EFI_SUCCESS              Successfully get the required component.
 605   @retval EFI_INVALID_PARAMETER    Uri is NULL or Ip6Address is NULL or UrlParser is invalid.
 606   @retval EFI_NOT_FOUND            No IPv6 address component in the URL.
 607   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 608
 609 **/
 610 EFI_STATUS
 611 EFIAPI
 612 HttpUrlGetIp6 (
 613   IN      CHAR8              *Url,
 614   IN      VOID               *UrlParser,
 615      OUT  EFI_IPv6_ADDRESS   *Ip6Address
 616   )
 617 {
 618   CHAR8                *Ip6String;
 619   CHAR8                *Ptr;
 620   UINT32               Length;
 621   EFI_STATUS           Status;
 622   UINT32               ResultLength;
 623   HTTP_URL_PARSER      *Parser;
 624
 625   if (Url == NULL || UrlParser == NULL || Ip6Address == NULL) {
 626     return EFI_INVALID_PARAMETER;
 627   }
 628
 629   Parser = (HTTP_URL_PARSER*) UrlParser;
 630
 631   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
 632     return EFI_INVALID_PARAMETER;
 633   }
 634
 635   //
 636   // IP-literal = "[" ( IPv6address / IPvFuture  ) "]"
 637   //
 638   Length = Parser->FieldData[HTTP_URI_FIELD_HOST].Length;
 639   if (Length < 2) {
 640     return EFI_INVALID_PARAMETER;
 641   }
 642
 643   Ptr    = Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset;
 644   if ((Ptr[0] != '[') || (Ptr[Length - 1] != ']')) {
 645     return EFI_INVALID_PARAMETER;
 646   }
 647
 648   Ip6String = AllocatePool (Length);
 649   if (Ip6String == NULL) {
 650     return EFI_OUT_OF_RESOURCES;
 651   }
 652
 653   Status = UriPercentDecode (
 654              Ptr + 1,
 655              Length - 2,
 656              Ip6String,
 657              &ResultLength
 658              );
 659   if (EFI_ERROR (Status)) {
 660     return Status;
 661   }
 662
 663   Ip6String[ResultLength] = '\0';
 664   Status = NetLibAsciiStrToIp6 (Ip6String, Ip6Address);
 665   FreePool (Ip6String);
 666
 667   return Status;
 668 }
 669
 670 /**
 671   Get the port number from a HTTP URL.
 672
 673   This function will return the port number according to the Url and previous parse result.
 674
 675   @param[in]    Url                The pointer to a HTTP URL string.
 676   @param[in]    UrlParser          URL Parse result returned by NetHttpParseUrl().
 677   @param[out]   Port               Pointer to a buffer to store the port number.
 678
 679   @retval EFI_SUCCESS              Successfully get the required component.
 680   @retval EFI_INVALID_PARAMETER    Uri is NULL or Port is NULL or UrlParser is invalid.
 681   @retval EFI_NOT_FOUND            No port number in the URL.
 682   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 683
 684 **/
 685 EFI_STATUS
 686 EFIAPI
 687 HttpUrlGetPort (
 688   IN      CHAR8              *Url,
 689   IN      VOID               *UrlParser,
 690      OUT  UINT16             *Port
 691   )
 692 {
 693   CHAR8         *PortString;
 694   EFI_STATUS    Status;
 695   UINT32        ResultLength;
 696   HTTP_URL_PARSER      *Parser;
 697
 698   if (Url == NULL || UrlParser == NULL || Port == NULL) {
 699     return EFI_INVALID_PARAMETER;
 700   }
 701
 702   Parser = (HTTP_URL_PARSER*) UrlParser;
 703
 704   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PORT)) == 0) {
 705     return EFI_INVALID_PARAMETER;
 706   }
 707
 708   PortString = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PORT].Length + 1);
 709   if (PortString == NULL) {
 710     return EFI_OUT_OF_RESOURCES;
 711   }
 712
 713   Status = UriPercentDecode (
 714              Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset,
 715              Parser->FieldData[HTTP_URI_FIELD_PORT].Length,
 716              PortString,
 717              &ResultLength
 718              );
 719   if (EFI_ERROR (Status)) {
 720     return Status;
 721   }
 722
 723   PortString[ResultLength] = '\0';
 724
 725   return AsciiStrDecimalToUintnS (Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset, (CHAR8 **) NULL, (UINTN *) Port);
 726 }
 727
 728 /**
 729   Get the Path from a HTTP URL.
 730
 731   This function will return the Path according to the Url and previous parse result,and
 732   it is the caller's responsibility to free the buffer returned in *Path.
 733
 734   @param[in]    Url                The pointer to a HTTP URL string.
 735   @param[in]    UrlParser          URL Parse result returned by NetHttpParseUrl().
 736   @param[out]   Path               Pointer to a buffer to store the Path.
 737
 738   @retval EFI_SUCCESS              Successfully get the required component.
 739   @retval EFI_INVALID_PARAMETER    Uri is NULL or HostName is NULL or UrlParser is invalid.
 740   @retval EFI_NOT_FOUND            No hostName component in the URL.
 741   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
 742
 743 **/
 744 EFI_STATUS
 745 EFIAPI
 746 HttpUrlGetPath (
 747   IN      CHAR8              *Url,
 748   IN      VOID               *UrlParser,
 749      OUT  CHAR8              **Path
 750   )
 751 {
 752   CHAR8                *PathStr;
 753   EFI_STATUS           Status;
 754   UINT32               ResultLength;
 755   HTTP_URL_PARSER      *Parser;
 756
 757   if (Url == NULL || UrlParser == NULL || Path == NULL) {
 758     return EFI_INVALID_PARAMETER;
 759   }
 760
 761   Parser = (HTTP_URL_PARSER*) UrlParser;
 762
 763   if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PATH)) == 0) {
 764     return EFI_NOT_FOUND;
 765   }
 766
 767   PathStr = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PATH].Length + 1);
 768   if (PathStr == NULL) {
 769     return EFI_OUT_OF_RESOURCES;
 770   }
 771
 772   Status = UriPercentDecode (
 773              Url + Parser->FieldData[HTTP_URI_FIELD_PATH].Offset,
 774              Parser->FieldData[HTTP_URI_FIELD_PATH].Length,
 775              PathStr,
 776              &ResultLength
 777              );
 778   if (EFI_ERROR (Status)) {
 779     return Status;
 780   }
 781
 782   PathStr[ResultLength] = '\0';
 783   *Path = PathStr;
 784   return EFI_SUCCESS;
 785 }
 786
 787 /**
 788   Release the resource of the URL parser.
 789
 790   @param[in]    UrlParser            Pointer to the parser.
 791
 792 **/
 793 VOID
 794 EFIAPI
 795 HttpUrlFreeParser (
 796   IN      VOID               *UrlParser
 797   )
 798 {
 799   FreePool (UrlParser);
 800 }
 801
 802 /**
 803   Find a specified header field according to the field name.
 804
 805   @param[in]   HeaderCount      Number of HTTP header structures in Headers list.
 806   @param[in]   Headers          Array containing list of HTTP headers.
 807   @param[in]   FieldName        Null terminated string which describes a field name.
 808
 809   @return    Pointer to the found header or NULL.
 810
 811 **/
 812 EFI_HTTP_HEADER *
 813 EFIAPI
 814 HttpFindHeader (
 815   IN  UINTN                HeaderCount,
 816   IN  EFI_HTTP_HEADER      *Headers,
 817   IN  CHAR8                *FieldName
 818   )
 819 {
 820   UINTN                 Index;
 821
 822   if (HeaderCount == 0 || Headers == NULL || FieldName == NULL) {
 823     return NULL;
 824   }
 825
 826   for (Index = 0; Index < HeaderCount; Index++){
 827     //
 828     // Field names are case-insensitive (RFC 2616).
 829     //
 830     if (AsciiStriCmp (Headers[Index].FieldName, FieldName) == 0) {
 831       return &Headers[Index];
 832     }
 833   }
 834   return NULL;
 835 }
 836
 837 typedef enum {
 838   BodyParserBodyStart,
 839   BodyParserBodyIdentity,
 840   BodyParserChunkSizeStart,
 841   BodyParserChunkSize,
 842   BodyParserChunkSizeEndCR,
 843   BodyParserChunkExtStart,
 844   BodyParserChunkDataStart,
 845   BodyParserChunkDataEnd,
 846   BodyParserChunkDataEndCR,
 847   BodyParserTrailer,
 848   BodyParserLastCRLF,
 849   BodyParserLastCRLFEnd,
 850   BodyParserComplete,
 851   BodyParserStateMax
 852 } HTTP_BODY_PARSE_STATE;
 853
 854 typedef struct {
 855   BOOLEAN                       IgnoreBody;    // "MUST NOT" include a message-body
 856   BOOLEAN                       IsChunked;     // "chunked" transfer-coding.
 857   BOOLEAN                       ContentLengthIsValid;
 858   UINTN                         ContentLength; // Entity length (not the message-body length), invalid until ContentLengthIsValid is TRUE
 859
 860   HTTP_BODY_PARSER_CALLBACK     Callback;
 861   VOID                          *Context;
 862   UINTN                         ParsedBodyLength;
 863   HTTP_BODY_PARSE_STATE         State;
 864   UINTN                         CurrentChunkSize;
 865   UINTN                         CurrentChunkParsedSize;
 866 } HTTP_BODY_PARSER;
 867
 868 /**
 869
 870   Convert an Ascii char to its uppercase.
 871
 872   @param[in]       Char           Ascii character.
 873
 874   @return          Uppercase value of the input Char.
 875
 876 **/
 877 CHAR8
 878 HttpIoCharToUpper (
 879   IN      CHAR8                    Char
 880   )
 881 {
 882   if (Char >= 'a' && Char <= 'z') {
 883     return  Char - ('a' - 'A');
 884   }
 885
 886   return Char;
 887 }
 888
 889 /**
 890   Convert an hexadecimal char to a value of type UINTN.
 891
 892   @param[in]       Char           Ascii character.
 893
 894   @return          Value translated from Char.
 895
 896 **/
 897 UINTN
 898 HttpIoHexCharToUintn (
 899   IN CHAR8           Char
 900   )
 901 {
 902   if (Char >= '0' && Char <= '9') {
 903     return Char - '0';
 904   }
 905
 906   return (10 + HttpIoCharToUpper (Char) - 'A');
 907 }
 908
 909 /**
 910   Get the value of the content length if there is a "Content-Length" header.
 911
 912   @param[in]    HeaderCount        Number of HTTP header structures in Headers.
 913   @param[in]    Headers            Array containing list of HTTP headers.
 914   @param[out]   ContentLength      Pointer to save the value of the content length.
 915
 916   @retval EFI_SUCCESS              Successfully get the content length.
 917   @retval EFI_NOT_FOUND            No "Content-Length" header in the Headers.
 918
 919 **/
 920 EFI_STATUS
 921 HttpIoParseContentLengthHeader (
 922   IN     UINTN                HeaderCount,
 923   IN     EFI_HTTP_HEADER      *Headers,
 924      OUT UINTN                *ContentLength
 925   )
 926 {
 927   EFI_HTTP_HEADER       *Header;
 928
 929   Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_CONTENT_LENGTH);
 930   if (Header == NULL) {
 931     return EFI_NOT_FOUND;
 932   }
 933
 934   return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **) NULL, ContentLength);
 935 }
 936
 937 /**
 938
 939   Check whether the HTTP message is using the "chunked" transfer-coding.
 940
 941   @param[in]    HeaderCount        Number of HTTP header structures in Headers.
 942   @param[in]    Headers            Array containing list of HTTP headers.
 943
 944   @return       The message is "chunked" transfer-coding (TRUE) or not (FALSE).
 945
 946 **/
 947 BOOLEAN
 948 HttpIoIsChunked (
 949   IN   UINTN                    HeaderCount,
 950   IN   EFI_HTTP_HEADER          *Headers
 951   )
 952 {
 953   EFI_HTTP_HEADER       *Header;
 954
 955
 956   Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
 957   if (Header == NULL) {
 958     return FALSE;
 959   }
 960
 961   if (AsciiStriCmp (Header->FieldValue, "identity") != 0) {
 962     return TRUE;
 963   }
 964
 965   return FALSE;
 966 }
 967
 968 /**
 969   Check whether the HTTP message should have a message-body.
 970
 971   @param[in]    Method             The HTTP method (e.g. GET, POST) for this HTTP message.
 972   @param[in]    StatusCode         Response status code returned by the remote host.
 973
 974   @return       The message should have a message-body (FALSE) or not (TRUE).
 975
 976 **/
 977 BOOLEAN
 978 HttpIoNoMessageBody (
 979   IN   EFI_HTTP_METHOD          Method,
 980   IN   EFI_HTTP_STATUS_CODE     StatusCode
 981   )
 982 {
 983   //
 984   // RFC 2616:
 985   // All responses to the HEAD request method
 986   // MUST NOT include a message-body, even though the presence of entity-
 987   // header fields might lead one to believe they do. All 1xx
 988   // (informational), 204 (no content), and 304 (not modified) responses
 989   // MUST NOT include a message-body. All other responses do include a
 990   // message-body, although it MAY be of zero length.
 991   //
 992   if (Method == HttpMethodHead) {
 993     return TRUE;
 994   }
 995
 996   if ((StatusCode == HTTP_STATUS_100_CONTINUE) ||
 997       (StatusCode == HTTP_STATUS_101_SWITCHING_PROTOCOLS) ||
 998       (StatusCode == HTTP_STATUS_204_NO_CONTENT) ||
 999       (StatusCode == HTTP_STATUS_304_NOT_MODIFIED))
1000   {
1001     return TRUE;
1002   }
1003
1004   return FALSE;
1005 }
1006
1007 /**
1008   Initialize a HTTP message-body parser.
1009
1010   This function will create and initialize a HTTP message parser according to caller provided HTTP message
1011   header information. It is the caller's responsibility to free the buffer returned in *UrlParser by HttpFreeMsgParser().
1012
1013   @param[in]    Method             The HTTP method (e.g. GET, POST) for this HTTP message.
1014   @param[in]    StatusCode         Response status code returned by the remote host.
1015   @param[in]    HeaderCount        Number of HTTP header structures in Headers.
1016   @param[in]    Headers            Array containing list of HTTP headers.
1017   @param[in]    Callback           Callback function that is invoked when parsing the HTTP message-body,
1018                                    set to NULL to ignore all events.
1019   @param[in]    Context            Pointer to the context that will be passed to Callback.
1020   @param[out]   MsgParser          Pointer to the returned buffer to store the message parser.
1021
1022   @retval EFI_SUCCESS              Successfully initialized the parser.
1023   @retval EFI_OUT_OF_RESOURCES     Could not allocate needed resources.
1024   @retval EFI_INVALID_PARAMETER    MsgParser is NULL or HeaderCount is not NULL but Headers is NULL.
1025   @retval Others                   Failed to initialize the parser.
1026
1027 **/
1028 EFI_STATUS
1029 EFIAPI
1030 HttpInitMsgParser (
1031   IN     EFI_HTTP_METHOD               Method,
1032   IN     EFI_HTTP_STATUS_CODE          StatusCode,
1033   IN     UINTN                         HeaderCount,
1034   IN     EFI_HTTP_HEADER               *Headers,
1035   IN     HTTP_BODY_PARSER_CALLBACK     Callback,
1036   IN     VOID                          *Context,
1037     OUT  VOID                          **MsgParser
1038   )
1039 {
1040   EFI_STATUS            Status;
1041   HTTP_BODY_PARSER      *Parser;
1042
1043   if (HeaderCount != 0 && Headers == NULL) {
1044     return EFI_INVALID_PARAMETER;
1045   }
1046
1047   if (MsgParser == NULL) {
1048     return EFI_INVALID_PARAMETER;
1049   }
1050
1051   Parser = AllocateZeroPool (sizeof (HTTP_BODY_PARSER));
1052   if (Parser == NULL) {
1053     return EFI_OUT_OF_RESOURCES;
1054   }
1055
1056   Parser->State = BodyParserBodyStart;
1057
1058   //
1059   // Determine the message length according to RFC 2616.
1060   // 1. Check whether the message "MUST NOT" have a message-body.
1061   //
1062   Parser->IgnoreBody = HttpIoNoMessageBody (Method, StatusCode);
1063   //
1064   // 2. Check whether the message using "chunked" transfer-coding.
1065   //
1066   Parser->IsChunked  = HttpIoIsChunked (HeaderCount, Headers);
1067   //
1068   // 3. Check whether the message has a Content-Length header field.
1069   //
1070   Status = HttpIoParseContentLengthHeader (HeaderCount, Headers, &Parser->ContentLength);
1071   if (!EFI_ERROR (Status)) {
1072     Parser->ContentLengthIsValid = TRUE;
1073   }
1074   //
1075   // 4. Range header is not supported now, so we won't meet media type "multipart/byteranges".
1076   // 5. By server closing the connection
1077   //
1078
1079   //
1080   // Set state to skip body parser if the message shouldn't have a message body.
1081   //
1082   if (Parser->IgnoreBody) {
1083     Parser->State = BodyParserComplete;
1084   } else {
1085     Parser->Callback = Callback;
1086     Parser->Context  = Context;
1087   }
1088
1089   *MsgParser = Parser;
1090   return EFI_SUCCESS;
1091 }
1092
1093 /**
1094   Parse message body.
1095
1096   Parse BodyLength of message-body. This function can be called repeatedly to parse the message-body partially.
1097
1098   @param[in, out]    MsgParser            Pointer to the message parser.
1099   @param[in]         BodyLength           Length in bytes of the Body.
1100   @param[in]         Body                 Pointer to the buffer of the message-body to be parsed.
1101
1102   @retval EFI_SUCCESS                Successfully parse the message-body.
1103   @retval EFI_INVALID_PARAMETER      MsgParser is NULL or Body is NULL or BodyLength is 0.
1104   @retval Others                     Operation aborted.
1105
1106 **/
1107 EFI_STATUS
1108 EFIAPI
1109 HttpParseMessageBody (
1110   IN OUT VOID              *MsgParser,
1111   IN     UINTN             BodyLength,
1112   IN     CHAR8             *Body
1113   )
1114 {
1115   CHAR8                 *Char;
1116   UINTN                 RemainderLengthInThis;
1117   UINTN                 LengthForCallback;
1118   EFI_STATUS            Status;
1119   HTTP_BODY_PARSER      *Parser;
1120
1121   if (BodyLength == 0 || Body == NULL) {
1122     return EFI_INVALID_PARAMETER;
1123   }
1124
1125   if (MsgParser == NULL) {
1126     return EFI_INVALID_PARAMETER;
1127   }
1128
1129   Parser = (HTTP_BODY_PARSER*) MsgParser;
1130
1131   if (Parser->IgnoreBody) {
1132     Parser->State = BodyParserComplete;
1133     if (Parser->Callback != NULL) {
1134       Status = Parser->Callback (
1135                  BodyParseEventOnComplete,
1136                  Body,
1137                  0,
1138                  Parser->Context
1139                  );
1140       if (EFI_ERROR (Status)) {
1141         return Status;
1142       }
1143     }
1144     return EFI_SUCCESS;
1145   }
1146
1147   if (Parser->State == BodyParserBodyStart) {
1148     Parser->ParsedBodyLength = 0;
1149     if (Parser->IsChunked) {
1150       Parser->State = BodyParserChunkSizeStart;
1151     } else {
1152       Parser->State = BodyParserBodyIdentity;
1153     }
1154   }
1155
1156   //
1157   // The message body might be truncated in anywhere, so we need to parse is byte-by-byte.
1158   //
1159   for (Char = Body; Char < Body + BodyLength; ) {
1160
1161     switch (Parser->State) {
1162     case BodyParserStateMax:
1163       return EFI_ABORTED;
1164
1165     case BodyParserBodyIdentity:
1166       //
1167       // Identity transfer-coding, just notify user to save the body data.
1168       //
1169       if (Parser->Callback != NULL) {
1170         Status = Parser->Callback (
1171                    BodyParseEventOnData,
1172                    Char,
1173                    MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength),
1174                    Parser->Context
1175                    );
1176         if (EFI_ERROR (Status)) {
1177           return Status;
1178         }
1179       }
1180       Char += MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength);
1181       Parser->ParsedBodyLength += MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength);
1182       if (Parser->ParsedBodyLength == Parser->ContentLength) {
1183         Parser->State = BodyParserComplete;
1184         if (Parser->Callback != NULL) {
1185           Status = Parser->Callback (
1186                      BodyParseEventOnComplete,
1187                      Char,
1188                      0,
1189                      Parser->Context
1190                      );
1191           if (EFI_ERROR (Status)) {
1192             return Status;
1193           }
1194         }
1195       }
1196       break;
1197
1198     case BodyParserChunkSizeStart:
1199       //
1200       // First byte of chunk-size, the chunk-size might be truncated.
1201       //
1202       Parser->CurrentChunkSize = 0;
1203       Parser->State = BodyParserChunkSize;
1204     case BodyParserChunkSize:
1205       if (!NET_IS_HEX_CHAR (*Char)) {
1206         if (*Char == ';') {
1207           Parser->State = BodyParserChunkExtStart;
1208           Char++;
1209         } else if (*Char == '\r') {
1210           Parser->State = BodyParserChunkSizeEndCR;
1211           Char++;
1212         } else {
1213           Parser->State = BodyParserStateMax;
1214         }
1215         break;
1216       }
1217
1218       if (Parser->CurrentChunkSize > (((~((UINTN) 0)) - 16) / 16)) {
1219         return EFI_INVALID_PARAMETER;
1220       }
1221       Parser->CurrentChunkSize = Parser->CurrentChunkSize * 16 + HttpIoHexCharToUintn (*Char);
1222       Char++;
1223       break;
1224
1225     case BodyParserChunkExtStart:
1226       //
1227       // Ignore all the chunk extensions.
1228       //
1229       if (*Char == '\r') {
1230         Parser->State = BodyParserChunkSizeEndCR;
1231        }
1232       Char++;
1233       break;
1234
1235     case BodyParserChunkSizeEndCR:
1236       if (*Char != '\n') {
1237         Parser->State = BodyParserStateMax;
1238         break;
1239       }
1240       Char++;
1241       if (Parser->CurrentChunkSize == 0) {
1242         //
1243         // The last chunk has been parsed and now assumed the state
1244         // of HttpBodyParse is ParserLastCRLF. So it need to decide
1245         // whether the rest message is trailer or last CRLF in the next round.
1246         //
1247         Parser->ContentLengthIsValid = TRUE;
1248         Parser->State = BodyParserLastCRLF;
1249         break;
1250       }
1251       Parser->State = BodyParserChunkDataStart;
1252       Parser->CurrentChunkParsedSize = 0;
1253       break;
1254
1255     case BodyParserLastCRLF:
1256       //
1257       // Judge the byte is belong to the Last CRLF or trailer, and then
1258       // configure the state of HttpBodyParse to corresponding state.
1259       //
1260       if (*Char == '\r') {
1261         Char++;
1262         Parser->State = BodyParserLastCRLFEnd;
1263         break;
1264       } else {
1265         Parser->State = BodyParserTrailer;
1266         break;
1267       }
1268
1269     case BodyParserLastCRLFEnd:
1270       if (*Char == '\n') {
1271         Parser->State = BodyParserComplete;
1272         Char++;
1273         if (Parser->Callback != NULL) {
1274           Status = Parser->Callback (
1275                      BodyParseEventOnComplete,
1276                      Char,
1277                      0,
1278                      Parser->Context
1279                      );
1280           if (EFI_ERROR (Status)) {
1281             return Status;
1282           }
1283         }
1284         break;
1285       } else {
1286         Parser->State = BodyParserStateMax;
1287         break;
1288       }
1289
1290     case BodyParserTrailer:
1291       if (*Char == '\r') {
1292         Parser->State = BodyParserChunkSizeEndCR;
1293       }
1294       Char++;
1295       break;
1296
1297     case BodyParserChunkDataStart:
1298       //
1299       // First byte of chunk-data, the chunk data also might be truncated.
1300       //
1301       RemainderLengthInThis = BodyLength - (Char - Body);
1302       LengthForCallback = MIN (Parser->CurrentChunkSize - Parser->CurrentChunkParsedSize, RemainderLengthInThis);
1303       if (Parser->Callback != NULL) {
1304         Status = Parser->Callback (
1305                    BodyParseEventOnData,
1306                    Char,
1307                    LengthForCallback,
1308                    Parser->Context
1309                    );
1310         if (EFI_ERROR (Status)) {
1311           return Status;
1312         }
1313       }
1314       Char += LengthForCallback;
1315       Parser->ContentLength += LengthForCallback;
1316       Parser->CurrentChunkParsedSize += LengthForCallback;
1317       if (Parser->CurrentChunkParsedSize == Parser->CurrentChunkSize) {
1318         Parser->State = BodyParserChunkDataEnd;
1319       }
1320       break;
1321
1322     case BodyParserChunkDataEnd:
1323       if (*Char == '\r') {
1324         Parser->State = BodyParserChunkDataEndCR;
1325       } else {
1326         Parser->State = BodyParserStateMax;
1327       }
1328       Char++;
1329       break;
1330
1331     case BodyParserChunkDataEndCR:
1332       if (*Char != '\n') {
1333         Parser->State = BodyParserStateMax;
1334         break;
1335       }
1336       Char++;
1337       Parser->State = BodyParserChunkSizeStart;
1338       break;
1339
1340     default:
1341       break;
1342     }
1343
1344   }
1345
1346   if (Parser->State == BodyParserStateMax) {
1347     return EFI_ABORTED;
1348   }
1349
1350   return EFI_SUCCESS;
1351 }
1352
1353 /**
1354   Check whether the message-body is complete or not.
1355
1356   @param[in]    MsgParser            Pointer to the message parser.
1357
1358   @retval TRUE                       Message-body is complete.
1359   @retval FALSE                      Message-body is not complete.
1360
1361 **/
1362 BOOLEAN
1363 EFIAPI
1364 HttpIsMessageComplete (
1365   IN VOID              *MsgParser
1366   )
1367 {
1368   HTTP_BODY_PARSER      *Parser;
1369
1370   Parser = (HTTP_BODY_PARSER*) MsgParser;
1371
1372   if (Parser->State == BodyParserComplete) {
1373     return TRUE;
1374   }
1375   return FALSE;
1376 }
1377
1378 /**
1379   Get the content length of the entity.
1380
1381   Note that in trunk transfer, the entity length is not valid until the whole message body is received.
1382
1383   @param[in]    MsgParser            Pointer to the message parser.
1384   @param[out]   ContentLength        Pointer to store the length of the entity.
1385
1386   @retval EFI_SUCCESS                Successfully to get the entity length.
1387   @retval EFI_NOT_READY              Entity length is not valid yet.
1388   @retval EFI_INVALID_PARAMETER      MsgParser is NULL or ContentLength is NULL.
1389
1390 **/
1391 EFI_STATUS
1392 EFIAPI
1393 HttpGetEntityLength (
1394   IN  VOID              *MsgParser,
1395   OUT UINTN             *ContentLength
1396   )
1397 {
1398   HTTP_BODY_PARSER      *Parser;
1399
1400   if (MsgParser == NULL || ContentLength == NULL) {
1401     return EFI_INVALID_PARAMETER;
1402   }
1403
1404   Parser = (HTTP_BODY_PARSER*) MsgParser;
1405
1406   if (!Parser->ContentLengthIsValid) {
1407     return EFI_NOT_READY;
1408   }
1409
1410   *ContentLength = Parser->ContentLength;
1411   return EFI_SUCCESS;
1412 }
1413
1414 /**
1415   Release the resource of the message parser.
1416
1417   @param[in]    MsgParser            Pointer to the message parser.
1418
1419 **/
1420 VOID
1421 EFIAPI
1422 HttpFreeMsgParser (
1423   IN  VOID           *MsgParser
1424   )
1425 {
1426   FreePool (MsgParser);
1427 }
1428
1429
1430 /**
1431   Get the next string, which is distinguished by specified separator.
1432
1433   @param[in]  String             Pointer to the string.
1434   @param[in]  Separator          Specified separator used to distinguish where is the beginning
1435                                  of next string.
1436
1437   @return     Pointer to the next string.
1438   @return     NULL if not find or String is NULL.
1439
1440 **/
1441 CHAR8 *
1442 EFIAPI
1443 AsciiStrGetNextToken (
1444   IN CONST CHAR8 *String,
1445   IN       CHAR8 Separator
1446   )
1447 {
1448   CONST CHAR8 *Token;
1449
1450   Token = String;
1451   while (TRUE) {
1452     if (*Token == 0) {
1453       return NULL;
1454     }
1455     if (*Token == Separator) {
1456       return (CHAR8 *)(Token + 1);
1457     }
1458     Token++;
1459   }
1460 }
1461
1462 /**
1463   Set FieldName and FieldValue into specified HttpHeader.
1464
1465   @param[in,out]  HttpHeader      Specified HttpHeader.
1466   @param[in]  FieldName           FieldName of this HttpHeader, a NULL terminated ASCII string.
1467   @param[in]  FieldValue          FieldValue of this HttpHeader, a NULL terminated ASCII string.
1468
1469
1470   @retval EFI_SUCCESS             The FieldName and FieldValue are set into HttpHeader successfully.
1471   @retval EFI_OUT_OF_RESOURCES    Failed to allocate resources.
1472
1473 **/
1474 EFI_STATUS
1475 EFIAPI
1476 HttpSetFieldNameAndValue (
1477   IN  OUT   EFI_HTTP_HEADER       *HttpHeader,
1478   IN  CONST CHAR8                 *FieldName,
1479   IN  CONST CHAR8                 *FieldValue
1480   )
1481 {
1482   UINTN                       FieldNameSize;
1483   UINTN                       FieldValueSize;
1484
1485   if (HttpHeader->FieldName != NULL) {
1486     FreePool (HttpHeader->FieldName);
1487   }
1488   if (HttpHeader->FieldValue != NULL) {
1489     FreePool (HttpHeader->FieldValue);
1490   }
1491
1492   FieldNameSize = AsciiStrSize (FieldName);
1493   HttpHeader->FieldName = AllocateZeroPool (FieldNameSize);
1494   if (HttpHeader->FieldName == NULL) {
1495     return EFI_OUT_OF_RESOURCES;
1496   }
1497   CopyMem (HttpHeader->FieldName, FieldName, FieldNameSize);
1498   HttpHeader->FieldName[FieldNameSize - 1] = 0;
1499
1500   FieldValueSize = AsciiStrSize (FieldValue);
1501   HttpHeader->FieldValue = AllocateZeroPool (FieldValueSize);
1502   if (HttpHeader->FieldValue == NULL) {
1503     return EFI_OUT_OF_RESOURCES;
1504   }
1505   CopyMem (HttpHeader->FieldValue, FieldValue, FieldValueSize);
1506   HttpHeader->FieldValue[FieldValueSize - 1] = 0;
1507
1508   return EFI_SUCCESS;
1509 }
1510
1511 /**
1512   Get one key/value header pair from the raw string.
1513
1514   @param[in]  String             Pointer to the raw string.
1515   @param[out] FieldName          Points directly to field name within 'HttpHeader'.
1516   @param[out] FieldValue         Points directly to field value within 'HttpHeader'.
1517
1518   @return     Pointer to the next raw string.
1519   @return     NULL if no key/value header pair from this raw string.
1520
1521 **/
1522 CHAR8 *
1523 EFIAPI
1524 HttpGetFieldNameAndValue (
1525   IN     CHAR8   *String,
1526      OUT CHAR8   **FieldName,
1527      OUT CHAR8   **FieldValue
1528   )
1529 {
1530   CHAR8  *FieldNameStr;
1531   CHAR8  *FieldValueStr;
1532   CHAR8  *StrPtr;
1533
1534   if (String == NULL || FieldName == NULL || FieldValue == NULL) {
1535     return NULL;
1536   }
1537
1538   *FieldName    = NULL;
1539   *FieldValue   = NULL;
1540   FieldNameStr  = NULL;
1541   FieldValueStr = NULL;
1542   StrPtr        = NULL;
1543
1544   //
1545   // Each header field consists of a name followed by a colon (":") and the field value.
1546   //
1547   FieldNameStr = String;
1548   FieldValueStr = AsciiStrGetNextToken (FieldNameStr, ':');
1549   if (FieldValueStr == NULL) {
1550     return NULL;
1551   }
1552
1553   //
1554   // Replace ':' with 0
1555   //
1556   *(FieldValueStr - 1) = 0;
1557
1558   //
1559   // The field value MAY be preceded by any amount of LWS, though a single SP is preferred.
1560   //
1561   while (TRUE) {
1562     if (*FieldValueStr == ' ' || *FieldValueStr == '\t') {
1563       FieldValueStr ++;
1564     } else if (*FieldValueStr == '\r' && *(FieldValueStr + 1) == '\n' &&
1565                (*(FieldValueStr + 2) == ' ' || *(FieldValueStr + 2) == '\t')) {
1566       FieldValueStr = FieldValueStr + 3;
1567     } else {
1568       break;
1569     }
1570   }
1571
1572   //
1573   // Header fields can be extended over multiple lines by preceding each extra
1574   // line with at least one SP or HT.
1575   //
1576   StrPtr = FieldValueStr;
1577   do {
1578     StrPtr = AsciiStrGetNextToken (StrPtr, '\r');
1579     if (StrPtr == NULL || *StrPtr != '\n') {
1580       return NULL;
1581     }
1582
1583     StrPtr++;
1584   } while (*StrPtr == ' ' || *StrPtr == '\t');
1585
1586   //
1587   // Replace '\r' with 0
1588   //
1589   *(StrPtr - 2) = 0;
1590
1591   //
1592   // Get FieldName and FieldValue.
1593   //
1594   *FieldName = FieldNameStr;
1595   *FieldValue = FieldValueStr;
1596
1597   return StrPtr;
1598 }
1599
1600 /**
1601   Free existing HeaderFields.
1602
1603   @param[in]  HeaderFields       Pointer to array of key/value header pairs waitting for free.
1604   @param[in]  FieldCount         The number of header pairs in HeaderFields.
1605
1606 **/
1607 VOID
1608 EFIAPI
1609 HttpFreeHeaderFields (
1610   IN  EFI_HTTP_HEADER  *HeaderFields,
1611   IN  UINTN            FieldCount
1612   )
1613 {
1614   UINTN                       Index;
1615
1616   if (HeaderFields != NULL) {
1617     for (Index = 0; Index < FieldCount; Index++) {
1618       if (HeaderFields[Index].FieldName != NULL) {
1619         FreePool (HeaderFields[Index].FieldName);
1620       }
1621       if (HeaderFields[Index].FieldValue != NULL) {
1622         FreePool (HeaderFields[Index].FieldValue);
1623       }
1624     }
1625
1626     FreePool (HeaderFields);
1627   }
1628 }
1629
1630 /**
1631   Generate HTTP request message.
1632
1633   This function will allocate memory for the whole HTTP message and generate a
1634   well formatted HTTP Request message in it, include the Request-Line, header
1635   fields and also the message body. It is the caller's responsibility to free
1636   the buffer returned in *RequestMsg.
1637
1638   @param[in]   Message            Pointer to the EFI_HTTP_MESSAGE structure which
1639                                   contains the required information to generate
1640                                   the HTTP request message.
1641   @param[in]   Url                The URL of a remote host.
1642   @param[out]  RequestMsg         Pointer to the created HTTP request message.
1643                                   NULL if any error occured.
1644   @param[out]  RequestMsgSize     Size of the RequestMsg (in bytes).
1645
1646   @return EFI_SUCCESS             If HTTP request string was created successfully
1647   @retval EFI_OUT_OF_RESOURCES    Failed to allocate resources.
1648   @retval EFI_INVALID_PARAMETER   The input arguments are invalid
1649
1650 **/
1651 EFI_STATUS
1652 EFIAPI
1653 HttpGenRequestMessage (
1654   IN     CONST EFI_HTTP_MESSAGE        *Message,
1655   IN     CONST CHAR8                   *Url,
1656      OUT CHAR8                         **RequestMsg,
1657      OUT UINTN                         *RequestMsgSize
1658   )
1659 {
1660   EFI_STATUS                       Status;
1661   UINTN                            StrLength;
1662   CHAR8                            *RequestPtr;
1663   UINTN                            HttpHdrSize;
1664   UINTN                            MsgSize;
1665   BOOLEAN                          Success;
1666   VOID                             *HttpHdr;
1667   EFI_HTTP_HEADER                  **AppendList;
1668   UINTN                            Index;
1669   EFI_HTTP_UTILITIES_PROTOCOL      *HttpUtilitiesProtocol;
1670
1671
1672   ASSERT (Message != NULL);
1673
1674   *RequestMsg           = NULL;
1675   Status                = EFI_SUCCESS;
1676   HttpHdrSize           = 0;
1677   MsgSize               = 0;
1678   Success               = FALSE;
1679   HttpHdr               = NULL;
1680   AppendList            = NULL;
1681   HttpUtilitiesProtocol = NULL;
1682
1683   //
1684   // 1. If we have a Request, we cannot have a NULL Url
1685   // 2. If we have a Request, HeaderCount can not be non-zero
1686   // 3. If we do not have a Request, HeaderCount should be zero
1687   // 4. If we do not have Request and Headers, we need at least a message-body
1688   //
1689   if ((Message->Data.Request != NULL && Url == NULL) ||
1690       (Message->Data.Request != NULL && Message->HeaderCount == 0) ||
1691       (Message->Data.Request == NULL && Message->HeaderCount != 0) ||
1692       (Message->Data.Request == NULL && Message->HeaderCount == 0 && Message->BodyLength == 0)) {
1693     return EFI_INVALID_PARAMETER;
1694   }
1695
1696   if (Message->HeaderCount != 0) {
1697     //
1698     // Locate the HTTP_UTILITIES protocol.
1699     //
1700     Status = gBS->LocateProtocol (
1701                     &gEfiHttpUtilitiesProtocolGuid,
1702                     NULL,
1703                     (VOID **)&HttpUtilitiesProtocol
1704                     );
1705
1706     if (EFI_ERROR (Status)) {
1707       DEBUG ((DEBUG_ERROR,"Failed to locate Http Utilities protocol. Status = %r.\n", Status));
1708       return Status;
1709     }
1710
1711     //
1712     // Build AppendList to send into HttpUtilitiesBuild
1713     //
1714     AppendList = AllocateZeroPool (sizeof (EFI_HTTP_HEADER *) * (Message->HeaderCount));
1715     if (AppendList == NULL) {
1716       return EFI_OUT_OF_RESOURCES;
1717     }
1718
1719     for(Index = 0; Index < Message->HeaderCount; Index++){
1720       AppendList[Index] = &Message->Headers[Index];
1721     }
1722
1723     //
1724     // Build raw HTTP Headers
1725     //
1726     Status = HttpUtilitiesProtocol->Build (
1727                 HttpUtilitiesProtocol,
1728                 0,
1729                 NULL,
1730                 0,
1731                 NULL,
1732                 Message->HeaderCount,
1733                 AppendList,
1734                 &HttpHdrSize,
1735                 &HttpHdr
1736                 );
1737
1738     if (AppendList != NULL) {
1739       FreePool (AppendList);
1740     }
1741
1742     if (EFI_ERROR (Status) || HttpHdr == NULL){
1743       return Status;
1744     }
1745   }
1746
1747   //
1748   // If we have headers to be sent, account for it.
1749   //
1750   if (Message->HeaderCount != 0) {
1751     MsgSize = HttpHdrSize;
1752   }
1753
1754   //
1755   // If we have a request line, account for the fields.
1756   //
1757   if (Message->Data.Request != NULL) {
1758     MsgSize += HTTP_METHOD_MAXIMUM_LEN + AsciiStrLen (HTTP_VERSION_CRLF_STR) + AsciiStrLen (Url);
1759   }
1760
1761
1762   //
1763   // If we have a message body to be sent, account for it.
1764   //
1765   MsgSize += Message->BodyLength;
1766
1767   //
1768   // memory for the string that needs to be sent to TCP
1769   //
1770   *RequestMsg = AllocateZeroPool (MsgSize);
1771   if (*RequestMsg == NULL) {
1772     Status = EFI_OUT_OF_RESOURCES;
1773     goto Exit;
1774   }
1775
1776   RequestPtr = *RequestMsg;
1777   //
1778   // Construct header request
1779   //
1780   if (Message->Data.Request != NULL) {
1781     switch (Message->Data.Request->Method) {
1782     case HttpMethodGet:
1783       StrLength = sizeof (HTTP_METHOD_GET) - 1;
1784       CopyMem (RequestPtr, HTTP_METHOD_GET, StrLength);
1785       RequestPtr += StrLength;
1786       break;
1787     case HttpMethodPut:
1788       StrLength = sizeof (HTTP_METHOD_PUT) - 1;
1789       CopyMem (RequestPtr, HTTP_METHOD_PUT, StrLength);
1790       RequestPtr += StrLength;
1791       break;
1792     case HttpMethodPatch:
1793       StrLength = sizeof (HTTP_METHOD_PATCH) - 1;
1794       CopyMem (RequestPtr, HTTP_METHOD_PATCH, StrLength);
1795       RequestPtr += StrLength;
1796       break;
1797     case HttpMethodPost:
1798       StrLength = sizeof (HTTP_METHOD_POST) - 1;
1799       CopyMem (RequestPtr, HTTP_METHOD_POST, StrLength);
1800       RequestPtr += StrLength;
1801       break;
1802     case HttpMethodHead:
1803       StrLength = sizeof (HTTP_METHOD_HEAD) - 1;
1804       CopyMem (RequestPtr, HTTP_METHOD_HEAD, StrLength);
1805       RequestPtr += StrLength;
1806       break;
1807     case HttpMethodDelete:
1808       StrLength = sizeof (HTTP_METHOD_DELETE) - 1;
1809       CopyMem (RequestPtr, HTTP_METHOD_DELETE, StrLength);
1810       RequestPtr += StrLength;
1811       break;
1812     default:
1813       ASSERT (FALSE);
1814       Status = EFI_INVALID_PARAMETER;
1815       goto Exit;
1816     }
1817
1818     StrLength = AsciiStrLen(EMPTY_SPACE);
1819     CopyMem (RequestPtr, EMPTY_SPACE, StrLength);
1820     RequestPtr += StrLength;
1821
1822     StrLength = AsciiStrLen (Url);
1823     CopyMem (RequestPtr, Url, StrLength);
1824     RequestPtr += StrLength;
1825
1826     StrLength = sizeof (HTTP_VERSION_CRLF_STR) - 1;
1827     CopyMem (RequestPtr, HTTP_VERSION_CRLF_STR, StrLength);
1828     RequestPtr += StrLength;
1829
1830     if (HttpHdr != NULL) {
1831       //
1832       // Construct header
1833       //
1834       CopyMem (RequestPtr, HttpHdr, HttpHdrSize);
1835       RequestPtr += HttpHdrSize;
1836     }
1837   }
1838
1839   //
1840   // Construct body
1841   //
1842   if (Message->Body != NULL) {
1843     CopyMem (RequestPtr, Message->Body, Message->BodyLength);
1844     RequestPtr += Message->BodyLength;
1845   }
1846
1847   //
1848   // Done
1849   //
1850   (*RequestMsgSize) = (UINTN)(RequestPtr) - (UINTN)(*RequestMsg);
1851   Success     = TRUE;
1852
1853 Exit:
1854
1855   if (!Success) {
1856     if (*RequestMsg != NULL) {
1857       FreePool (*RequestMsg);
1858     }
1859     *RequestMsg = NULL;
1860     return Status;
1861   }
1862
1863   if (HttpHdr != NULL) {
1864     FreePool (HttpHdr);
1865   }
1866
1867   return EFI_SUCCESS;
1868 }
1869
1870 /**
1871   Translate the status code in HTTP message to EFI_HTTP_STATUS_CODE defined
1872   in UEFI 2.5 specification.
1873
1874   @param[in]  StatusCode         The status code value in HTTP message.
1875
1876   @return                        Value defined in EFI_HTTP_STATUS_CODE .
1877
1878 **/
1879 EFI_HTTP_STATUS_CODE
1880 EFIAPI
1881 HttpMappingToStatusCode (
1882   IN UINTN                  StatusCode
1883   )
1884 {
1885   switch (StatusCode) {
1886   case 100:
1887     return HTTP_STATUS_100_CONTINUE;
1888   case 101:
1889     return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
1890   case 200:
1891     return HTTP_STATUS_200_OK;
1892   case 201:
1893     return HTTP_STATUS_201_CREATED;
1894   case 202:
1895     return HTTP_STATUS_202_ACCEPTED;
1896   case 203:
1897     return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
1898   case 204:
1899     return HTTP_STATUS_204_NO_CONTENT;
1900   case 205:
1901     return HTTP_STATUS_205_RESET_CONTENT;
1902   case 206:
1903     return HTTP_STATUS_206_PARTIAL_CONTENT;
1904   case 300:
1905     return HTTP_STATUS_300_MULTIPLE_CHIOCES;
1906   case 301:
1907     return HTTP_STATUS_301_MOVED_PERMANENTLY;
1908   case 302:
1909     return HTTP_STATUS_302_FOUND;
1910   case 303:
1911     return HTTP_STATUS_303_SEE_OTHER;
1912   case 304:
1913     return HTTP_STATUS_304_NOT_MODIFIED;
1914   case 305:
1915     return HTTP_STATUS_305_USE_PROXY;
1916   case 307:
1917     return HTTP_STATUS_307_TEMPORARY_REDIRECT;
1918   case 400:
1919     return HTTP_STATUS_400_BAD_REQUEST;
1920   case 401:
1921     return HTTP_STATUS_401_UNAUTHORIZED;
1922   case 402:
1923     return HTTP_STATUS_402_PAYMENT_REQUIRED;
1924   case 403:
1925     return HTTP_STATUS_403_FORBIDDEN;
1926   case 404:
1927     return HTTP_STATUS_404_NOT_FOUND;
1928   case 405:
1929     return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
1930   case 406:
1931     return HTTP_STATUS_406_NOT_ACCEPTABLE;
1932   case 407:
1933     return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
1934   case 408:
1935     return HTTP_STATUS_408_REQUEST_TIME_OUT;
1936   case 409:
1937     return HTTP_STATUS_409_CONFLICT;
1938   case 410:
1939     return HTTP_STATUS_410_GONE;
1940   case 411:
1941     return HTTP_STATUS_411_LENGTH_REQUIRED;
1942   case 412:
1943     return HTTP_STATUS_412_PRECONDITION_FAILED;
1944   case 413:
1945     return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
1946   case 414:
1947     return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
1948   case 415:
1949     return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE;
1950   case 416:
1951     return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
1952   case 417:
1953     return HTTP_STATUS_417_EXPECTATION_FAILED;
1954   case 500:
1955     return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
1956   case 501:
1957     return HTTP_STATUS_501_NOT_IMPLEMENTED;
1958   case 502:
1959     return HTTP_STATUS_502_BAD_GATEWAY;
1960   case 503:
1961     return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
1962   case 504:
1963     return HTTP_STATUS_504_GATEWAY_TIME_OUT;
1964   case 505:
1965     return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
1966
1967   default:
1968     return HTTP_STATUS_UNSUPPORTED_STATUS;
1969   }
1970 }
1971
1972 /**
1973   Check whether header field called FieldName is in DeleteList.
1974
1975   @param[in]  DeleteList        Pointer to array of key/value header pairs.
1976   @param[in]  DeleteCount       The number of header pairs.
1977   @param[in]  FieldName         Pointer to header field's name.
1978
1979   @return     TRUE if FieldName is not in DeleteList, that means this header field is valid.
1980   @return     FALSE if FieldName is in DeleteList, that means this header field is invalid.
1981
1982 **/
1983 BOOLEAN
1984 EFIAPI
1985 HttpIsValidHttpHeader (
1986   IN  CHAR8            *DeleteList[],
1987   IN  UINTN            DeleteCount,
1988   IN  CHAR8            *FieldName
1989   )
1990 {
1991   UINTN                       Index;
1992
1993   for (Index = 0; Index < DeleteCount; Index++) {
1994     if (AsciiStrCmp (FieldName, DeleteList[Index]) == 0) {
1995       return FALSE;
1996     }
1997   }
1998
1999   return TRUE;
2000 }
2001