NetworkPkg/HttpDxe/HttpsSupport.c

   1 /** @file
   2   Miscellaneous routines specific to Https for HttpDxe driver.
   3
   4 Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>
   5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "HttpDriver.h"
  17
  18 /**
  19   Returns the first occurrence of a Null-terminated ASCII sub-string in a Null-terminated
  20   ASCII string and ignore case during the search process.
  21
  22   This function scans the contents of the ASCII string specified by String
  23   and returns the first occurrence of SearchString and ignore case during the search process.
  24   If SearchString is not found in String, then NULL is returned. If the length of SearchString
  25   is zero, then String is returned.
  26
  27   If String is NULL, then ASSERT().
  28   If SearchString is NULL, then ASSERT().
  29
  30   @param[in]  String          A pointer to a Null-terminated ASCII string.
  31   @param[in]  SearchString    A pointer to a Null-terminated ASCII string to search for.
  32
  33   @retval NULL            If the SearchString does not appear in String.
  34   @retval others          If there is a match return the first occurrence of SearchingString.
  35                           If the length of SearchString is zero,return String.
  36
  37 **/
  38 CHAR8 *
  39 AsciiStrCaseStr (
  40   IN      CONST CHAR8               *String,
  41   IN      CONST CHAR8               *SearchString
  42   )
  43 {
  44   CONST CHAR8 *FirstMatch;
  45   CONST CHAR8 *SearchStringTmp;
  46
  47   CHAR8 Src;
  48   CHAR8 Dst;
  49
  50   //
  51   // ASSERT both strings are less long than PcdMaximumAsciiStringLength
  52   //
  53   ASSERT (AsciiStrSize (String) != 0);
  54   ASSERT (AsciiStrSize (SearchString) != 0);
  55
  56   if (*SearchString == '\0') {
  57     return (CHAR8 *) String;
  58   }
  59
  60   while (*String != '\0') {
  61     SearchStringTmp = SearchString;
  62     FirstMatch = String;
  63
  64     while ((*SearchStringTmp != '\0')
  65             && (*String != '\0')) {
  66       Src = *String;
  67       Dst = *SearchStringTmp;
  68
  69       if ((Src >= 'A') && (Src <= 'Z')) {
  70         Src += ('a' - 'A');
  71       }
  72
  73       if ((Dst >= 'A') && (Dst <= 'Z')) {
  74         Dst += ('a' - 'A');
  75       }
  76
  77       if (Src != Dst) {
  78         break;
  79       }
  80
  81       String++;
  82       SearchStringTmp++;
  83     }
  84
  85     if (*SearchStringTmp == '\0') {
  86       return (CHAR8 *) FirstMatch;
  87     }
  88
  89     String = FirstMatch + 1;
  90   }
  91
  92   return NULL;
  93 }
  94
  95 /**
  96   The callback function to free the net buffer list.
  97
  98   @param[in]  Arg The opaque parameter.
  99
 100 **/
 101 VOID
 102 EFIAPI
 103 FreeNbufList (
 104   IN VOID *Arg
 105   )
 106 {
 107   ASSERT (Arg != NULL);
 108
 109   NetbufFreeList ((LIST_ENTRY *) Arg);
 110   FreePool (Arg);
 111 }
 112
 113 /**
 114   Check whether the Url is from Https.
 115
 116   @param[in]    Url             The pointer to a HTTP or HTTPS URL string.
 117
 118   @retval TRUE                  The Url is from HTTPS.
 119   @retval FALSE                 The Url is from HTTP.
 120
 121 **/
 122 BOOLEAN
 123 IsHttpsUrl (
 124   IN CHAR8    *Url
 125   )
 126 {
 127   CHAR8  *Tmp;
 128
 129   Tmp = NULL;
 130
 131   Tmp = AsciiStrCaseStr (Url, HTTPS_FLAG);
 132   if (Tmp != NULL && Tmp == Url) {
 133     return TRUE;
 134   }
 135
 136   return FALSE;
 137 }
 138
 139 /**
 140   Creates a Tls child handle, open EFI_TLS_PROTOCOL and EFI_TLS_CONFIGURATION_PROTOCOL.
 141
 142   @param[in]  ImageHandle           The firmware allocated handle for the UEFI image.
 143   @param[out] TlsSb                 Pointer to the TLS SERVICE_BINDING_PROTOCOL.
 144   @param[out] TlsProto              Pointer to the EFI_TLS_PROTOCOL instance.
 145   @param[out] TlsConfiguration      Pointer to the EFI_TLS_CONFIGURATION_PROTOCOL instance.
 146
 147   @return  The child handle with opened EFI_TLS_PROTOCOL and EFI_TLS_CONFIGURATION_PROTOCOL.
 148
 149 **/
 150 EFI_HANDLE
 151 EFIAPI
 152 TlsCreateChild (
 153   IN  EFI_HANDLE                     ImageHandle,
 154   OUT EFI_SERVICE_BINDING_PROTOCOL   **TlsSb,
 155   OUT EFI_TLS_PROTOCOL               **TlsProto,
 156   OUT EFI_TLS_CONFIGURATION_PROTOCOL **TlsConfiguration
 157   )
 158 {
 159   EFI_STATUS                    Status;
 160   EFI_HANDLE                    TlsChildHandle;
 161
 162   TlsChildHandle = 0;
 163
 164   //
 165   // Locate TlsServiceBinding protocol.
 166   //
 167   gBS->LocateProtocol (
 168      &gEfiTlsServiceBindingProtocolGuid,
 169      NULL,
 170      (VOID **) TlsSb
 171      );
 172   if (*TlsSb == NULL) {
 173     return NULL;
 174   }
 175
 176   Status = (*TlsSb)->CreateChild (*TlsSb, &TlsChildHandle);
 177   if (EFI_ERROR (Status)) {
 178     return NULL;
 179   }
 180
 181   Status = gBS->OpenProtocol (
 182                   TlsChildHandle,
 183                   &gEfiTlsProtocolGuid,
 184                   (VOID **) TlsProto,
 185                   ImageHandle,
 186                   TlsChildHandle,
 187                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 188                   );
 189   if (EFI_ERROR (Status)) {
 190     (*TlsSb)->DestroyChild (*TlsSb, TlsChildHandle);
 191     return NULL;
 192   }
 193
 194   Status = gBS->OpenProtocol (
 195                   TlsChildHandle,
 196                   &gEfiTlsConfigurationProtocolGuid,
 197                   (VOID **) TlsConfiguration,
 198                   ImageHandle,
 199                   TlsChildHandle,
 200                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 201                   );
 202   if (EFI_ERROR (Status)) {
 203     (*TlsSb)->DestroyChild (*TlsSb, TlsChildHandle);
 204     return NULL;
 205   }
 206
 207   return TlsChildHandle;
 208 }
 209
 210 /**
 211   Create event for the TLS receive and transmit tokens which are used to receive and
 212   transmit TLS related messages.
 213
 214   @param[in, out]  HttpInstance       Pointer to HTTP_PROTOCOL structure.
 215
 216   @retval EFI_SUCCESS            The events are created successfully.
 217   @retval others                 Other error as indicated.
 218
 219 **/
 220 EFI_STATUS
 221 EFIAPI
 222 TlsCreateTxRxEvent (
 223   IN OUT HTTP_PROTOCOL      *HttpInstance
 224   )
 225 {
 226   EFI_STATUS                Status;
 227
 228   if (!HttpInstance->LocalAddressIsIPv6) {
 229     //
 230     // For Tcp4TlsTxToken.
 231     //
 232     Status = gBS->CreateEvent (
 233                     EVT_NOTIFY_SIGNAL,
 234                     TPL_NOTIFY,
 235                     HttpCommonNotify,
 236                     &HttpInstance->TlsIsTxDone,
 237                     &HttpInstance->Tcp4TlsTxToken.CompletionToken.Event
 238                     );
 239     if (EFI_ERROR (Status)) {
 240       goto ERROR;
 241     }
 242
 243     HttpInstance->Tcp4TlsTxData.Push = TRUE;
 244     HttpInstance->Tcp4TlsTxData.Urgent = FALSE;
 245     HttpInstance->Tcp4TlsTxData.DataLength = 0;
 246     HttpInstance->Tcp4TlsTxData.FragmentCount = 1;
 247     HttpInstance->Tcp4TlsTxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp4TlsTxData.DataLength;
 248     HttpInstance->Tcp4TlsTxData.FragmentTable[0].FragmentBuffer = NULL;
 249     HttpInstance->Tcp4TlsTxToken.Packet.TxData = &HttpInstance->Tcp4TlsTxData;
 250     HttpInstance->Tcp4TlsTxToken.CompletionToken.Status = EFI_NOT_READY;
 251
 252     //
 253     // For Tcp4TlsRxToken.
 254     //
 255     Status = gBS->CreateEvent (
 256                     EVT_NOTIFY_SIGNAL,
 257                     TPL_NOTIFY,
 258                     HttpCommonNotify,
 259                     &HttpInstance->TlsIsRxDone,
 260                     &HttpInstance->Tcp4TlsRxToken.CompletionToken.Event
 261                     );
 262     if (EFI_ERROR (Status)) {
 263       goto ERROR;
 264     }
 265
 266     HttpInstance->Tcp4TlsRxData.DataLength                       = 0;
 267     HttpInstance->Tcp4TlsRxData.FragmentCount                    = 1;
 268     HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentLength  = HttpInstance->Tcp4TlsRxData.DataLength ;
 269     HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentBuffer  = NULL;
 270     HttpInstance->Tcp4TlsRxToken.Packet.RxData          = &HttpInstance->Tcp4TlsRxData;
 271     HttpInstance->Tcp4TlsRxToken.CompletionToken.Status = EFI_NOT_READY;
 272   } else {
 273     //
 274     // For Tcp6TlsTxToken.
 275     //
 276     Status = gBS->CreateEvent (
 277                     EVT_NOTIFY_SIGNAL,
 278                     TPL_NOTIFY,
 279                     HttpCommonNotify,
 280                     &HttpInstance->TlsIsTxDone,
 281                     &HttpInstance->Tcp6TlsTxToken.CompletionToken.Event
 282                     );
 283     if (EFI_ERROR (Status)) {
 284       goto ERROR;
 285     }
 286
 287     HttpInstance->Tcp6TlsTxData.Push = TRUE;
 288     HttpInstance->Tcp6TlsTxData.Urgent = FALSE;
 289     HttpInstance->Tcp6TlsTxData.DataLength = 0;
 290     HttpInstance->Tcp6TlsTxData.FragmentCount = 1;
 291     HttpInstance->Tcp6TlsTxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp6TlsTxData.DataLength;
 292     HttpInstance->Tcp6TlsTxData.FragmentTable[0].FragmentBuffer = NULL;
 293     HttpInstance->Tcp6TlsTxToken.Packet.TxData = &HttpInstance->Tcp6TlsTxData;
 294     HttpInstance->Tcp6TlsTxToken.CompletionToken.Status = EFI_NOT_READY;
 295
 296     //
 297     // For Tcp6TlsRxToken.
 298     //
 299     Status = gBS->CreateEvent (
 300                     EVT_NOTIFY_SIGNAL,
 301                     TPL_NOTIFY,
 302                     HttpCommonNotify,
 303                     &HttpInstance->TlsIsRxDone,
 304                     &HttpInstance->Tcp6TlsRxToken.CompletionToken.Event
 305                     );
 306     if (EFI_ERROR (Status)) {
 307       goto ERROR;
 308     }
 309
 310     HttpInstance->Tcp6TlsRxData.DataLength                       = 0;
 311     HttpInstance->Tcp6TlsRxData.FragmentCount                    = 1;
 312     HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentLength  = HttpInstance->Tcp6TlsRxData.DataLength ;
 313     HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentBuffer  = NULL;
 314     HttpInstance->Tcp6TlsRxToken.Packet.RxData          = &HttpInstance->Tcp6TlsRxData;
 315     HttpInstance->Tcp6TlsRxToken.CompletionToken.Status = EFI_NOT_READY;
 316   }
 317
 318   return Status;
 319
 320 ERROR:
 321   //
 322   // Error handling
 323   //
 324   TlsCloseTxRxEvent (HttpInstance);
 325
 326   return Status;
 327 }
 328
 329 /**
 330   Close events in the TlsTxToken and TlsRxToken.
 331
 332   @param[in]  HttpInstance   Pointer to HTTP_PROTOCOL structure.
 333
 334 **/
 335 VOID
 336 EFIAPI
 337 TlsCloseTxRxEvent (
 338   IN  HTTP_PROTOCOL        *HttpInstance
 339   )
 340 {
 341   ASSERT (HttpInstance != NULL);
 342   if (!HttpInstance->LocalAddressIsIPv6) {
 343     if (NULL != HttpInstance->Tcp4TlsTxToken.CompletionToken.Event) {
 344       gBS->CloseEvent(HttpInstance->Tcp4TlsTxToken.CompletionToken.Event);
 345       HttpInstance->Tcp4TlsTxToken.CompletionToken.Event = NULL;
 346     }
 347
 348     if (NULL != HttpInstance->Tcp4TlsRxToken.CompletionToken.Event) {
 349       gBS->CloseEvent (HttpInstance->Tcp4TlsRxToken.CompletionToken.Event);
 350       HttpInstance->Tcp4TlsRxToken.CompletionToken.Event = NULL;
 351     }
 352   } else {
 353     if (NULL != HttpInstance->Tcp6TlsTxToken.CompletionToken.Event) {
 354       gBS->CloseEvent(HttpInstance->Tcp6TlsTxToken.CompletionToken.Event);
 355       HttpInstance->Tcp6TlsTxToken.CompletionToken.Event = NULL;
 356     }
 357
 358     if (NULL != HttpInstance->Tcp6TlsRxToken.CompletionToken.Event) {
 359       gBS->CloseEvent (HttpInstance->Tcp6TlsRxToken.CompletionToken.Event);
 360       HttpInstance->Tcp6TlsRxToken.CompletionToken.Event = NULL;
 361     }
 362   }
 363 }
 364
 365 /**
 366   Read the TlsCaCertificate variable and configure it.
 367
 368   @param[in, out]  HttpInstance       The HTTP instance private data.
 369
 370   @retval EFI_SUCCESS            TlsCaCertificate is configured.
 371   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
 372   @retval EFI_NOT_FOUND          Fail to get 'TlsCaCertificate' variable.
 373   @retval Others                 Other error as indicated.
 374
 375 **/
 376 EFI_STATUS
 377 TlsConfigCertificate (
 378   IN OUT HTTP_PROTOCOL      *HttpInstance
 379   )
 380 {
 381   EFI_STATUS          Status;
 382   UINT8               *CACert;
 383   UINTN               CACertSize;
 384   UINT32              Index;
 385   EFI_SIGNATURE_LIST  *CertList;
 386   EFI_SIGNATURE_DATA  *Cert;
 387   UINTN               CertCount;
 388   UINT32              ItemDataSize;
 389
 390   CACert     = NULL;
 391   CACertSize = 0;
 392
 393   //
 394   // Try to read the TlsCaCertificate variable.
 395   //
 396   Status  = gRT->GetVariable (
 397                    EFI_TLS_CA_CERTIFICATE_VARIABLE,
 398                    &gEfiTlsCaCertificateGuid,
 399                    NULL,
 400                    &CACertSize,
 401                    NULL
 402                    );
 403
 404   if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
 405     return Status;
 406   }
 407
 408   //
 409   // Allocate buffer and read the config variable.
 410   //
 411   CACert = AllocatePool (CACertSize);
 412   if (CACert == NULL) {
 413     return EFI_OUT_OF_RESOURCES;
 414   }
 415
 416   Status = gRT->GetVariable (
 417                   EFI_TLS_CA_CERTIFICATE_VARIABLE,
 418                   &gEfiTlsCaCertificateGuid,
 419                   NULL,
 420                   &CACertSize,
 421                   CACert
 422                   );
 423   if (EFI_ERROR (Status)) {
 424     //
 425     // GetVariable still error or the variable is corrupted.
 426     // Fall back to the default value.
 427     //
 428     FreePool (CACert);
 429
 430     return EFI_NOT_FOUND;
 431   }
 432
 433   ASSERT (CACert != NULL);
 434
 435   //
 436   // Enumerate all data and erasing the target item.
 437   //
 438   ItemDataSize = (UINT32) CACertSize;
 439   CertList = (EFI_SIGNATURE_LIST *) CACert;
 440   while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {
 441     Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
 442     CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
 443     for (Index = 0; Index < CertCount; Index++) {
 444       //
 445       // EfiTlsConfigDataTypeCACertificate
 446       //
 447       Status = HttpInstance->TlsConfiguration->SetData (
 448                                                  HttpInstance->TlsConfiguration,
 449                                                  EfiTlsConfigDataTypeCACertificate,
 450                                                  Cert->SignatureData,
 451                                                  CertList->SignatureSize - sizeof (Cert->SignatureOwner)
 452                                                  );
 453       if (EFI_ERROR (Status)) {
 454         FreePool (CACert);
 455         return Status;
 456       }
 457
 458       Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);
 459     }
 460
 461     ItemDataSize -= CertList->SignatureListSize;
 462     CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
 463   }
 464
 465   FreePool (CACert);
 466   return Status;
 467 }
 468
 469 /**
 470   Read the HttpTlsCipherList variable and configure it for HTTPS session.
 471
 472   @param[in, out]  HttpInstance  The HTTP instance private data.
 473
 474   @retval EFI_SUCCESS            The prefered HTTP TLS CipherList is configured.
 475   @retval EFI_NOT_FOUND          Fail to get 'HttpTlsCipherList' variable.
 476   @retval EFI_INVALID_PARAMETER  The contents of variable are invalid.
 477   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
 478
 479   @retval Others                 Other error as indicated.
 480
 481 **/
 482 EFI_STATUS
 483 TlsConfigCipherList (
 484   IN OUT HTTP_PROTOCOL      *HttpInstance
 485   )
 486 {
 487   EFI_STATUS          Status;
 488   UINT8               *CipherList;
 489   UINTN               CipherListSize;
 490
 491   CipherList     = NULL;
 492   CipherListSize = 0;
 493
 494   //
 495   // Try to read the HttpTlsCipherList variable.
 496   //
 497   Status  = gRT->GetVariable (
 498                    EDKII_HTTP_TLS_CIPHER_LIST_VARIABLE,
 499                    &gEdkiiHttpTlsCipherListGuid,
 500                    NULL,
 501                    &CipherListSize,
 502                    NULL
 503                    );
 504   ASSERT (EFI_ERROR (Status));
 505   if (Status != EFI_BUFFER_TOO_SMALL) {
 506     return Status;
 507   }
 508
 509   if (CipherListSize % sizeof (EFI_TLS_CIPHER) != 0) {
 510     return EFI_INVALID_PARAMETER;
 511   }
 512
 513   //
 514   // Allocate buffer and read the config variable.
 515   //
 516   CipherList = AllocatePool (CipherListSize);
 517   if (CipherList == NULL) {
 518     return EFI_OUT_OF_RESOURCES;
 519   }
 520
 521   Status = gRT->GetVariable (
 522                   EDKII_HTTP_TLS_CIPHER_LIST_VARIABLE,
 523                   &gEdkiiHttpTlsCipherListGuid,
 524                   NULL,
 525                   &CipherListSize,
 526                   CipherList
 527                   );
 528   if (EFI_ERROR (Status)) {
 529     //
 530     // GetVariable still error or the variable is corrupted.
 531     //
 532     goto ON_EXIT;
 533   }
 534
 535   ASSERT (CipherList != NULL);
 536
 537   Status = HttpInstance->Tls->SetSessionData (
 538                                 HttpInstance->Tls,
 539                                 EfiTlsCipherList,
 540                                 CipherList,
 541                                 CipherListSize
 542                                 );
 543
 544 ON_EXIT:
 545   FreePool (CipherList);
 546
 547   return Status;
 548 }
 549
 550 /**
 551   Configure TLS session data.
 552
 553   @param[in, out]  HttpInstance       The HTTP instance private data.
 554
 555   @retval EFI_SUCCESS            TLS session data is configured.
 556   @retval Others                 Other error as indicated.
 557
 558 **/
 559 EFI_STATUS
 560 EFIAPI
 561 TlsConfigureSession (
 562   IN OUT HTTP_PROTOCOL      *HttpInstance
 563   )
 564 {
 565   EFI_STATUS                 Status;
 566
 567   //
 568   // TlsConfigData initialization
 569   //
 570   HttpInstance->TlsConfigData.ConnectionEnd = EfiTlsClient;
 571   HttpInstance->TlsConfigData.VerifyMethod = EFI_TLS_VERIFY_PEER;
 572   HttpInstance->TlsConfigData.SessionState = EfiTlsSessionNotStarted;
 573
 574   //
 575   // EfiTlsConnectionEnd,
 576   // EfiTlsVerifyMethod
 577   // EfiTlsSessionState
 578   //
 579   Status = HttpInstance->Tls->SetSessionData (
 580                                 HttpInstance->Tls,
 581                                 EfiTlsConnectionEnd,
 582                                 &(HttpInstance->TlsConfigData.ConnectionEnd),
 583                                 sizeof (EFI_TLS_CONNECTION_END)
 584                                 );
 585   if (EFI_ERROR (Status)) {
 586     return Status;
 587   }
 588
 589   Status = HttpInstance->Tls->SetSessionData (
 590                                 HttpInstance->Tls,
 591                                 EfiTlsVerifyMethod,
 592                                 &HttpInstance->TlsConfigData.VerifyMethod,
 593                                 sizeof (EFI_TLS_VERIFY)
 594                                 );
 595   if (EFI_ERROR (Status)) {
 596     return Status;
 597   }
 598
 599   Status = HttpInstance->Tls->SetSessionData (
 600                                 HttpInstance->Tls,
 601                                 EfiTlsSessionState,
 602                                 &(HttpInstance->TlsConfigData.SessionState),
 603                                 sizeof (EFI_TLS_SESSION_STATE)
 604                                 );
 605   if (EFI_ERROR (Status)) {
 606     return Status;
 607   }
 608
 609   //
 610   // Tls Cipher List
 611   //
 612   Status = TlsConfigCipherList (HttpInstance);
 613   if (EFI_ERROR (Status) && Status != EFI_NOT_FOUND) {
 614     DEBUG ((EFI_D_ERROR, "TlsConfigCipherList: return %r error.\n", Status));
 615     return Status;
 616   }
 617
 618   //
 619   // Tls Config Certificate
 620   //
 621   Status = TlsConfigCertificate (HttpInstance);
 622   if (EFI_ERROR (Status)) {
 623     DEBUG ((EFI_D_ERROR, "TLS Certificate Config Error!\n"));
 624     return Status;
 625   }
 626
 627   //
 628   // TlsCreateTxRxEvent
 629   //
 630   Status = TlsCreateTxRxEvent (HttpInstance);
 631   if (EFI_ERROR (Status)) {
 632     goto ERROR;
 633   }
 634
 635   return Status;
 636
 637 ERROR:
 638   TlsCloseTxRxEvent (HttpInstance);
 639
 640   return Status;
 641 }
 642
 643 /**
 644   Transmit the Packet by processing the associated HTTPS token.
 645
 646   @param[in, out]   HttpInstance    Pointer to HTTP_PROTOCOL structure.
 647   @param[in]        Packet          The packet to transmit.
 648
 649   @retval EFI_SUCCESS            The packet is transmitted.
 650   @retval EFI_INVALID_PARAMETER  HttpInstance is NULL or Packet is NULL.
 651   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
 652   @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
 653   @retval Others                 Other errors as indicated.
 654
 655 **/
 656 EFI_STATUS
 657 EFIAPI
 658 TlsCommonTransmit (
 659   IN OUT HTTP_PROTOCOL      *HttpInstance,
 660   IN     NET_BUF            *Packet
 661   )
 662 {
 663   EFI_STATUS                Status;
 664   VOID                      *Data;
 665   UINTN                     Size;
 666
 667   if ((HttpInstance == NULL) || (Packet == NULL)) {
 668     return EFI_INVALID_PARAMETER;
 669   }
 670
 671   if (!HttpInstance->LocalAddressIsIPv6) {
 672     Size = sizeof (EFI_TCP4_TRANSMIT_DATA) +
 673            (Packet->BlockOpNum - 1) * sizeof (EFI_TCP4_FRAGMENT_DATA);
 674   } else {
 675     Size = sizeof (EFI_TCP6_TRANSMIT_DATA) +
 676            (Packet->BlockOpNum - 1) * sizeof (EFI_TCP6_FRAGMENT_DATA);
 677   }
 678
 679   Data = AllocatePool (Size);
 680   if (Data == NULL) {
 681     return EFI_OUT_OF_RESOURCES;
 682   }
 683
 684   if (!HttpInstance->LocalAddressIsIPv6) {
 685     ((EFI_TCP4_TRANSMIT_DATA *) Data)->Push        = TRUE;
 686     ((EFI_TCP4_TRANSMIT_DATA *) Data)->Urgent      = FALSE;
 687     ((EFI_TCP4_TRANSMIT_DATA *) Data)->DataLength  = Packet->TotalSize;
 688
 689     //
 690     // Build the fragment table.
 691     //
 692     ((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentCount = Packet->BlockOpNum;
 693
 694     NetbufBuildExt (
 695       Packet,
 696       (NET_FRAGMENT *) &((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentTable[0],
 697       &((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentCount
 698       );
 699
 700     HttpInstance->Tcp4TlsTxToken.Packet.TxData = (EFI_TCP4_TRANSMIT_DATA *) Data;
 701
 702     Status = EFI_DEVICE_ERROR;
 703
 704     //
 705     // Transmit the packet.
 706     //
 707     Status  = HttpInstance->Tcp4->Transmit (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsTxToken);
 708     if (EFI_ERROR (Status)) {
 709       goto ON_EXIT;
 710     }
 711
 712     while (!HttpInstance->TlsIsTxDone) {
 713       HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 714     }
 715
 716     HttpInstance->TlsIsTxDone = FALSE;
 717     Status = HttpInstance->Tcp4TlsTxToken.CompletionToken.Status;
 718   } else {
 719     ((EFI_TCP6_TRANSMIT_DATA *) Data)->Push        = TRUE;
 720     ((EFI_TCP6_TRANSMIT_DATA *) Data)->Urgent      = FALSE;
 721     ((EFI_TCP6_TRANSMIT_DATA *) Data)->DataLength  = Packet->TotalSize;
 722
 723     //
 724     // Build the fragment table.
 725     //
 726     ((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentCount = Packet->BlockOpNum;
 727
 728     NetbufBuildExt (
 729       Packet,
 730       (NET_FRAGMENT *) &((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentTable[0],
 731       &((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentCount
 732       );
 733
 734     HttpInstance->Tcp6TlsTxToken.Packet.TxData = (EFI_TCP6_TRANSMIT_DATA *) Data;
 735
 736     Status = EFI_DEVICE_ERROR;
 737
 738     //
 739     // Transmit the packet.
 740     //
 741     Status  = HttpInstance->Tcp6->Transmit (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsTxToken);
 742     if (EFI_ERROR (Status)) {
 743       goto ON_EXIT;
 744     }
 745
 746     while (!HttpInstance->TlsIsTxDone) {
 747       HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
 748     }
 749
 750     HttpInstance->TlsIsTxDone = FALSE;
 751     Status = HttpInstance->Tcp6TlsTxToken.CompletionToken.Status;
 752   }
 753
 754 ON_EXIT:
 755   FreePool (Data);
 756
 757   return Status;
 758 }
 759
 760 /**
 761   Receive the Packet by processing the associated HTTPS token.
 762
 763   @param[in, out]   HttpInstance    Pointer to HTTP_PROTOCOL structure.
 764   @param[in]        Packet          The packet to transmit.
 765   @param[in]        Timeout         The time to wait for connection done.
 766
 767   @retval EFI_SUCCESS            The Packet is received.
 768   @retval EFI_INVALID_PARAMETER  HttpInstance is NULL or Packet is NULL.
 769   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
 770   @retval EFI_TIMEOUT            The operation is time out.
 771   @retval Others                 Other error as indicated.
 772
 773 **/
 774 EFI_STATUS
 775 EFIAPI
 776 TlsCommonReceive (
 777   IN OUT HTTP_PROTOCOL      *HttpInstance,
 778   IN     NET_BUF            *Packet,
 779   IN     EFI_EVENT          Timeout
 780   )
 781 {
 782   EFI_TCP4_RECEIVE_DATA     *Tcp4RxData;
 783   EFI_TCP6_RECEIVE_DATA     *Tcp6RxData;
 784   EFI_STATUS                Status;
 785   NET_FRAGMENT              *Fragment;
 786   UINT32                    FragmentCount;
 787   UINT32                    CurrentFragment;
 788
 789   Tcp4RxData = NULL;
 790   Tcp6RxData = NULL;
 791
 792   if ((HttpInstance == NULL) || (Packet == NULL)) {
 793     return EFI_INVALID_PARAMETER;
 794   }
 795
 796   FragmentCount = Packet->BlockOpNum;
 797   Fragment      = AllocatePool (FragmentCount * sizeof (NET_FRAGMENT));
 798   if (Fragment == NULL) {
 799     Status = EFI_OUT_OF_RESOURCES;
 800     goto ON_EXIT;
 801   }
 802
 803   //
 804   // Build the fragment table.
 805   //
 806   NetbufBuildExt (Packet, Fragment, &FragmentCount);
 807
 808   if (!HttpInstance->LocalAddressIsIPv6) {
 809     Tcp4RxData = HttpInstance->Tcp4TlsRxToken.Packet.RxData;
 810     if (Tcp4RxData == NULL) {
 811       return EFI_INVALID_PARAMETER;
 812     }
 813     Tcp4RxData->FragmentCount         = 1;
 814   } else {
 815     Tcp6RxData = HttpInstance->Tcp6TlsRxToken.Packet.RxData;
 816     if (Tcp6RxData == NULL) {
 817       return EFI_INVALID_PARAMETER;
 818     }
 819     Tcp6RxData->FragmentCount         = 1;
 820   }
 821
 822   CurrentFragment               = 0;
 823   Status                        = EFI_SUCCESS;
 824
 825   while (CurrentFragment < FragmentCount) {
 826     if (!HttpInstance->LocalAddressIsIPv6) {
 827       Tcp4RxData->DataLength                       = Fragment[CurrentFragment].Len;
 828       Tcp4RxData->FragmentTable[0].FragmentLength  = Fragment[CurrentFragment].Len;
 829       Tcp4RxData->FragmentTable[0].FragmentBuffer  = Fragment[CurrentFragment].Bulk;
 830       Status = HttpInstance->Tcp4->Receive (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsRxToken);
 831     } else {
 832       Tcp6RxData->DataLength                       = Fragment[CurrentFragment].Len;
 833       Tcp6RxData->FragmentTable[0].FragmentLength  = Fragment[CurrentFragment].Len;
 834       Tcp6RxData->FragmentTable[0].FragmentBuffer  = Fragment[CurrentFragment].Bulk;
 835       Status = HttpInstance->Tcp6->Receive (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsRxToken);
 836     }
 837     if (EFI_ERROR (Status)) {
 838       goto ON_EXIT;
 839     }
 840
 841     while (!HttpInstance->TlsIsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
 842       //
 843       // Poll until some data is received or an error occurs.
 844       //
 845       if (!HttpInstance->LocalAddressIsIPv6) {
 846         HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);
 847       } else {
 848         HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);
 849       }
 850     }
 851
 852     if (!HttpInstance->TlsIsRxDone) {
 853       //
 854       // Timeout occurs, cancel the receive request.
 855       //
 856       if (!HttpInstance->LocalAddressIsIPv6) {
 857         HttpInstance->Tcp4->Cancel (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsRxToken.CompletionToken);
 858       } else {
 859         HttpInstance->Tcp6->Cancel (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsRxToken.CompletionToken);
 860       }
 861
 862       Status = EFI_TIMEOUT;
 863       goto ON_EXIT;
 864     } else {
 865       HttpInstance->TlsIsRxDone = FALSE;
 866     }
 867
 868     if (!HttpInstance->LocalAddressIsIPv6) {
 869       Status = HttpInstance->Tcp4TlsRxToken.CompletionToken.Status;
 870       if (EFI_ERROR (Status)) {
 871         goto ON_EXIT;
 872       }
 873
 874       Fragment[CurrentFragment].Len -= Tcp4RxData->FragmentTable[0].FragmentLength;
 875       if (Fragment[CurrentFragment].Len == 0) {
 876         CurrentFragment++;
 877       } else {
 878         Fragment[CurrentFragment].Bulk += Tcp4RxData->FragmentTable[0].FragmentLength;
 879       }
 880     } else {
 881       Status = HttpInstance->Tcp6TlsRxToken.CompletionToken.Status;
 882       if (EFI_ERROR (Status)) {
 883         goto ON_EXIT;
 884       }
 885
 886       Fragment[CurrentFragment].Len -= Tcp6RxData->FragmentTable[0].FragmentLength;
 887       if (Fragment[CurrentFragment].Len == 0) {
 888         CurrentFragment++;
 889       } else {
 890         Fragment[CurrentFragment].Bulk += Tcp6RxData->FragmentTable[0].FragmentLength;
 891       }
 892     }
 893   }
 894
 895 ON_EXIT:
 896
 897   if (Fragment != NULL) {
 898     FreePool (Fragment);
 899   }
 900
 901   return Status;
 902 }
 903
 904 /**
 905   Receive one TLS PDU. An TLS PDU contains an TLS record header and it's
 906   corresponding record data. These two parts will be put into two blocks of buffers in the
 907   net buffer.
 908
 909   @param[in, out]      HttpInstance    Pointer to HTTP_PROTOCOL structure.
 910   @param[out]          Pdu             The received TLS PDU.
 911   @param[in]           Timeout         The time to wait for connection done.
 912
 913   @retval EFI_SUCCESS          An TLS PDU is received.
 914   @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources.
 915   @retval EFI_PROTOCOL_ERROR   An unexpected TLS packet was received.
 916   @retval Others               Other errors as indicated.
 917
 918 **/
 919 EFI_STATUS
 920 EFIAPI
 921 TlsReceiveOnePdu (
 922   IN OUT HTTP_PROTOCOL      *HttpInstance,
 923      OUT NET_BUF            **Pdu,
 924   IN     EFI_EVENT          Timeout
 925   )
 926 {
 927   EFI_STATUS      Status;
 928
 929   LIST_ENTRY      *NbufList;
 930
 931   UINT32          Len;
 932
 933   NET_BUF           *PduHdr;
 934   UINT8             *Header;
 935   TLS_RECORD_HEADER RecordHeader;
 936
 937   NET_BUF           *DataSeg;
 938
 939   NbufList = NULL;
 940   PduHdr   = NULL;
 941   Header   = NULL;
 942   DataSeg  = NULL;
 943
 944   NbufList = AllocatePool (sizeof (LIST_ENTRY));
 945   if (NbufList == NULL) {
 946     return EFI_OUT_OF_RESOURCES;
 947   }
 948
 949   InitializeListHead (NbufList);
 950
 951   //
 952   // Allocate buffer to receive one TLS header.
 953   //
 954   Len     = TLS_RECORD_HEADER_LENGTH;
 955   PduHdr  = NetbufAlloc (Len);
 956   if (PduHdr == NULL) {
 957     Status = EFI_OUT_OF_RESOURCES;
 958     goto ON_EXIT;
 959   }
 960
 961   Header = NetbufAllocSpace (PduHdr, Len, NET_BUF_TAIL);
 962   if (Header == NULL) {
 963     Status = EFI_OUT_OF_RESOURCES;
 964     goto ON_EXIT;
 965   }
 966
 967   //
 968   // First step, receive one TLS header.
 969   //
 970   Status = TlsCommonReceive (HttpInstance, PduHdr, Timeout);
 971   if (EFI_ERROR (Status)) {
 972     goto ON_EXIT;
 973   }
 974
 975   RecordHeader = *(TLS_RECORD_HEADER *) Header;
 976   if ((RecordHeader.ContentType == TlsContentTypeHandshake ||
 977     RecordHeader.ContentType == TlsContentTypeAlert ||
 978     RecordHeader.ContentType == TlsContentTypeChangeCipherSpec ||
 979     RecordHeader.ContentType == TlsContentTypeApplicationData) &&
 980     (RecordHeader.Version.Major == 0x03) && /// Major versions are same.
 981     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
 982     RecordHeader.Version.Minor ==TLS11_PROTOCOL_VERSION_MINOR ||
 983     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
 984    ) {
 985     InsertTailList (NbufList, &PduHdr->List);
 986   } else {
 987     Status = EFI_PROTOCOL_ERROR;
 988     goto ON_EXIT;
 989   }
 990
 991   Len = SwapBytes16(RecordHeader.Length);
 992   if (Len == 0) {
 993     //
 994     // No TLS payload.
 995     //
 996     goto FORM_PDU;
 997   }
 998
 999   //
1000   // Allocate buffer to receive one TLS payload.
1001   //
1002   DataSeg = NetbufAlloc (Len);
1003   if (DataSeg == NULL) {
1004     Status = EFI_OUT_OF_RESOURCES;
1005     goto ON_EXIT;
1006   }
1007
1008   NetbufAllocSpace (DataSeg, Len, NET_BUF_TAIL);
1009
1010   //
1011   // Second step, receive one TLS payload.
1012   //
1013   Status = TlsCommonReceive (HttpInstance, DataSeg, Timeout);
1014   if (EFI_ERROR (Status)) {
1015     goto ON_EXIT;
1016   }
1017
1018   InsertTailList (NbufList, &DataSeg->List);
1019
1020 FORM_PDU:
1021   //
1022   // Form the PDU from a list of PDU.
1023   //
1024   *Pdu = NetbufFromBufList (NbufList, 0, 0, FreeNbufList, NbufList);
1025   if (*Pdu == NULL) {
1026     Status = EFI_OUT_OF_RESOURCES;
1027   }
1028
1029 ON_EXIT:
1030
1031   if (EFI_ERROR (Status)) {
1032     //
1033     // Free the Nbufs in this NbufList and the NbufList itself.
1034     //
1035     FreeNbufList (NbufList);
1036   }
1037
1038   return Status;
1039 }
1040
1041 /**
1042   Connect one TLS session by finishing the TLS handshake process.
1043
1044   @param[in]  HttpInstance       The HTTP instance private data.
1045   @param[in]  Timeout            The time to wait for connection done.
1046
1047   @retval EFI_SUCCESS            The TLS session is established.
1048   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
1049   @retval EFI_ABORTED            TLS session state is incorrect.
1050   @retval Others                 Other error as indicated.
1051
1052 **/
1053 EFI_STATUS
1054 EFIAPI
1055 TlsConnectSession (
1056   IN  HTTP_PROTOCOL            *HttpInstance,
1057   IN  EFI_EVENT                Timeout
1058   )
1059 {
1060   EFI_STATUS              Status;
1061   UINT8                   *BufferOut;
1062   UINTN                   BufferOutSize;
1063   NET_BUF                 *PacketOut;
1064   UINT8                   *DataOut;
1065   NET_BUF                 *Pdu;
1066   UINT8                   *BufferIn;
1067   UINTN                   BufferInSize;
1068   UINT8                   *GetSessionDataBuffer;
1069   UINTN                   GetSessionDataBufferSize;
1070
1071   BufferOut    = NULL;
1072   PacketOut    = NULL;
1073   DataOut      = NULL;
1074   Pdu          = NULL;
1075   BufferIn     = NULL;
1076
1077   //
1078   // Initialize TLS state.
1079   //
1080   HttpInstance->TlsSessionState = EfiTlsSessionNotStarted;
1081   Status = HttpInstance->Tls->SetSessionData (
1082                                 HttpInstance->Tls,
1083                                 EfiTlsSessionState,
1084                                 &(HttpInstance->TlsSessionState),
1085                                 sizeof (EFI_TLS_SESSION_STATE)
1086                                 );
1087   if (EFI_ERROR (Status)) {
1088     return Status;
1089   }
1090
1091   //
1092   // Create ClientHello
1093   //
1094   BufferOutSize = DEF_BUF_LEN;
1095   BufferOut = AllocateZeroPool (BufferOutSize);
1096   if (BufferOut == NULL) {
1097     Status = EFI_OUT_OF_RESOURCES;
1098     return Status;
1099   }
1100
1101   Status = HttpInstance->Tls->BuildResponsePacket (
1102                                 HttpInstance->Tls,
1103                                 NULL,
1104                                 0,
1105                                 BufferOut,
1106                                 &BufferOutSize
1107                                 );
1108   if (Status == EFI_BUFFER_TOO_SMALL) {
1109     FreePool (BufferOut);
1110     BufferOut = AllocateZeroPool (BufferOutSize);
1111     if (BufferOut == NULL) {
1112       Status = EFI_OUT_OF_RESOURCES;
1113       return Status;
1114     }
1115
1116     Status = HttpInstance->Tls->BuildResponsePacket (
1117                                   HttpInstance->Tls,
1118                                   NULL,
1119                                   0,
1120                                   BufferOut,
1121                                   &BufferOutSize
1122                                   );
1123   }
1124   if (EFI_ERROR (Status)) {
1125     FreePool (BufferOut);
1126     return Status;
1127   }
1128
1129   //
1130   // Transmit ClientHello
1131   //
1132   PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
1133   DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
1134   if (DataOut == NULL) {
1135     FreePool (BufferOut);
1136     return EFI_OUT_OF_RESOURCES;
1137   }
1138
1139   CopyMem (DataOut, BufferOut, BufferOutSize);
1140   Status = TlsCommonTransmit (HttpInstance, PacketOut);
1141
1142   FreePool (BufferOut);
1143   NetbufFree (PacketOut);
1144
1145   if (EFI_ERROR (Status)) {
1146     return Status;
1147   }
1148
1149   while(HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring && \
1150     ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
1151     //
1152     // Receive one TLS record.
1153     //
1154     Status = TlsReceiveOnePdu (HttpInstance, &Pdu, Timeout);
1155     if (EFI_ERROR (Status)) {
1156       return Status;
1157     }
1158
1159     BufferInSize = Pdu->TotalSize;
1160     BufferIn = AllocateZeroPool (BufferInSize);
1161     if (BufferIn == NULL) {
1162       NetbufFree (Pdu);
1163       Status = EFI_OUT_OF_RESOURCES;
1164       return Status;
1165     }
1166
1167     NetbufCopy (Pdu, 0, (UINT32)BufferInSize, BufferIn);
1168
1169     NetbufFree (Pdu);
1170
1171     //
1172     // Handle Receive data.
1173     //
1174     BufferOutSize = DEF_BUF_LEN;
1175     BufferOut = AllocateZeroPool (BufferOutSize);
1176     if (BufferOut == NULL) {
1177       Status = EFI_OUT_OF_RESOURCES;
1178       return Status;
1179     }
1180
1181     Status = HttpInstance->Tls->BuildResponsePacket (
1182                                   HttpInstance->Tls,
1183                                   BufferIn,
1184                                   BufferInSize,
1185                                   BufferOut,
1186                                   &BufferOutSize
1187                                   );
1188     if (Status == EFI_BUFFER_TOO_SMALL) {
1189        FreePool (BufferOut);
1190        BufferOut = AllocateZeroPool (BufferOutSize);
1191        if (BufferOut == NULL) {
1192          FreePool (BufferIn);
1193          Status = EFI_OUT_OF_RESOURCES;
1194          return Status;
1195        }
1196
1197        Status = HttpInstance->Tls->BuildResponsePacket (
1198                                      HttpInstance->Tls,
1199                                      BufferIn,
1200                                      BufferInSize,
1201                                      BufferOut,
1202                                      &BufferOutSize
1203                                      );
1204     }
1205
1206     FreePool (BufferIn);
1207
1208     if (EFI_ERROR (Status)) {
1209       FreePool (BufferOut);
1210       return Status;
1211     }
1212
1213     if (BufferOutSize != 0) {
1214       //
1215       // Transmit the response packet.
1216       //
1217       PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
1218       DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
1219       if (DataOut == NULL) {
1220         FreePool (BufferOut);
1221         return EFI_OUT_OF_RESOURCES;
1222       }
1223
1224       CopyMem (DataOut, BufferOut, BufferOutSize);
1225
1226       Status = TlsCommonTransmit (HttpInstance, PacketOut);
1227
1228       NetbufFree (PacketOut);
1229
1230       if (EFI_ERROR (Status)) {
1231         FreePool (BufferOut);
1232         return Status;
1233       }
1234     }
1235
1236     FreePool (BufferOut);
1237
1238     //
1239     // Get the session state, then decide whether need to continue handle received packet.
1240     //
1241     GetSessionDataBufferSize = DEF_BUF_LEN;
1242     GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
1243     if (GetSessionDataBuffer == NULL) {
1244       Status = EFI_OUT_OF_RESOURCES;
1245       return Status;
1246     }
1247
1248     Status = HttpInstance->Tls->GetSessionData (
1249                                   HttpInstance->Tls,
1250                                   EfiTlsSessionState,
1251                                   GetSessionDataBuffer,
1252                                   &GetSessionDataBufferSize
1253                                   );
1254     if (Status == EFI_BUFFER_TOO_SMALL) {
1255        FreePool (GetSessionDataBuffer);
1256        GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
1257        if (GetSessionDataBuffer == NULL) {
1258          Status = EFI_OUT_OF_RESOURCES;
1259          return Status;
1260        }
1261
1262        Status = HttpInstance->Tls->GetSessionData (
1263                                      HttpInstance->Tls,
1264                                      EfiTlsSessionState,
1265                                      GetSessionDataBuffer,
1266                                      &GetSessionDataBufferSize
1267                                      );
1268     }
1269     if (EFI_ERROR (Status)) {
1270       FreePool(GetSessionDataBuffer);
1271       return Status;
1272     }
1273
1274     ASSERT(GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
1275     HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *) GetSessionDataBuffer;
1276
1277     FreePool (GetSessionDataBuffer);
1278
1279     if(HttpInstance->TlsSessionState == EfiTlsSessionError) {
1280       return EFI_ABORTED;
1281     }
1282   }
1283
1284   if (HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring) {
1285     Status = EFI_ABORTED;
1286   }
1287
1288   return Status;
1289 }
1290
1291 /**
1292   Close the TLS session and send out the close notification message.
1293
1294   @param[in]  HttpInstance       The HTTP instance private data.
1295
1296   @retval EFI_SUCCESS            The TLS session is closed.
1297   @retval EFI_INVALID_PARAMETER  HttpInstance is NULL.
1298   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
1299   @retval Others                 Other error as indicated.
1300
1301 **/
1302 EFI_STATUS
1303 EFIAPI
1304 TlsCloseSession (
1305   IN  HTTP_PROTOCOL            *HttpInstance
1306   )
1307 {
1308   EFI_STATUS      Status;
1309
1310   UINT8           *BufferOut;
1311   UINTN           BufferOutSize;
1312
1313   NET_BUF         *PacketOut;
1314   UINT8           *DataOut;
1315
1316   Status    = EFI_SUCCESS;
1317   BufferOut = NULL;
1318   PacketOut = NULL;
1319   DataOut   = NULL;
1320
1321   if (HttpInstance == NULL) {
1322     return EFI_INVALID_PARAMETER;
1323   }
1324
1325   HttpInstance->TlsSessionState = EfiTlsSessionClosing;
1326
1327   Status = HttpInstance->Tls->SetSessionData (
1328                                 HttpInstance->Tls,
1329                                 EfiTlsSessionState,
1330                                 &(HttpInstance->TlsSessionState),
1331                                 sizeof (EFI_TLS_SESSION_STATE)
1332                                 );
1333   if (EFI_ERROR (Status)) {
1334     return Status;
1335   }
1336
1337   BufferOutSize = DEF_BUF_LEN;
1338   BufferOut = AllocateZeroPool (BufferOutSize);
1339   if (BufferOut == NULL) {
1340     Status = EFI_OUT_OF_RESOURCES;
1341     return Status;
1342   }
1343
1344   Status = HttpInstance->Tls->BuildResponsePacket (
1345                                 HttpInstance->Tls,
1346                                 NULL,
1347                                 0,
1348                                 BufferOut,
1349                                 &BufferOutSize
1350                                 );
1351   if (Status == EFI_BUFFER_TOO_SMALL) {
1352     FreePool (BufferOut);
1353     BufferOut = AllocateZeroPool (BufferOutSize);
1354     if (BufferOut == NULL) {
1355       Status = EFI_OUT_OF_RESOURCES;
1356       return Status;
1357     }
1358
1359     Status = HttpInstance->Tls->BuildResponsePacket (
1360                                   HttpInstance->Tls,
1361                                   NULL,
1362                                   0,
1363                                   BufferOut,
1364                                   &BufferOutSize
1365                                   );
1366   }
1367
1368   if (EFI_ERROR (Status)) {
1369     FreePool (BufferOut);
1370     return Status;
1371   }
1372
1373   PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
1374   DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
1375   if (DataOut == NULL) {
1376     FreePool (BufferOut);
1377     return EFI_OUT_OF_RESOURCES;
1378   }
1379
1380   CopyMem (DataOut, BufferOut, BufferOutSize);
1381
1382   Status = TlsCommonTransmit (HttpInstance, PacketOut);
1383
1384   FreePool (BufferOut);
1385   NetbufFree (PacketOut);
1386
1387   return Status;
1388 }
1389
1390 /**
1391   Process one message according to the CryptMode.
1392
1393   @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
1394   @param[in]           Message         Pointer to the message buffer needed to processed.
1395                                        If ProcessMode is EfiTlsEncrypt, the message contain the TLS
1396                                        header and plain text TLS APP payload.
1397                                        If ProcessMode is EfiTlsDecrypt, the message contain the TLS
1398                                        header and cipher text TLS APP payload.
1399   @param[in]           MessageSize     Pointer to the message buffer size.
1400   @param[in]           ProcessMode     Process mode.
1401   @param[in, out]      Fragment        Only one Fragment returned after the Message is
1402                                        processed successfully.
1403                                        If ProcessMode is EfiTlsEncrypt, the fragment contain the TLS
1404                                        header and cipher text TLS APP payload.
1405                                        If ProcessMode is EfiTlsDecrypt, the fragment contain the TLS
1406                                        header and plain text TLS APP payload.
1407
1408   @retval EFI_SUCCESS          Message is processed successfully.
1409   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
1410   @retval Others               Other errors as indicated.
1411
1412 **/
1413 EFI_STATUS
1414 EFIAPI
1415 TlsProcessMessage (
1416   IN     HTTP_PROTOCOL            *HttpInstance,
1417   IN     UINT8                    *Message,
1418   IN     UINTN                    MessageSize,
1419   IN     EFI_TLS_CRYPT_MODE       ProcessMode,
1420   IN OUT NET_FRAGMENT             *Fragment
1421   )
1422 {
1423   EFI_STATUS                      Status;
1424   UINT8                           *Buffer;
1425   UINT32                          BufferSize;
1426   UINT32                          BytesCopied;
1427   EFI_TLS_FRAGMENT_DATA           *FragmentTable;
1428   UINT32                          FragmentCount;
1429   EFI_TLS_FRAGMENT_DATA           *OriginalFragmentTable;
1430   UINTN                           Index;
1431
1432   Status                   = EFI_SUCCESS;
1433   Buffer                   = NULL;
1434   BufferSize               = 0;
1435   BytesCopied              = 0;
1436   FragmentTable            = NULL;
1437   OriginalFragmentTable    = NULL;
1438
1439   //
1440   // Rebuild fragment table from BufferIn.
1441   //
1442   FragmentCount = 1;
1443   FragmentTable = AllocateZeroPool (FragmentCount * sizeof (EFI_TLS_FRAGMENT_DATA));
1444   if (FragmentTable == NULL) {
1445     Status = EFI_OUT_OF_RESOURCES;
1446     goto ON_EXIT;
1447   }
1448
1449   FragmentTable->FragmentLength = (UINT32) MessageSize;
1450   FragmentTable->FragmentBuffer = Message;
1451
1452   //
1453   // Record the original FragmentTable.
1454   //
1455   OriginalFragmentTable = FragmentTable;
1456
1457   //
1458   // Process the Message.
1459   //
1460   Status = HttpInstance->Tls->ProcessPacket (
1461                                 HttpInstance->Tls,
1462                                 &FragmentTable,
1463                                 &FragmentCount,
1464                                 ProcessMode
1465                                 );
1466   if (EFI_ERROR (Status)) {
1467     goto ON_EXIT;
1468   }
1469
1470   //
1471   // Calculate the size according to FragmentTable.
1472   //
1473   for (Index = 0; Index < FragmentCount; Index++) {
1474     BufferSize += FragmentTable[Index].FragmentLength;
1475   }
1476
1477   //
1478   // Allocate buffer for processed data.
1479   //
1480   Buffer = AllocateZeroPool (BufferSize);
1481   if (Buffer == NULL) {
1482     Status = EFI_OUT_OF_RESOURCES;
1483     goto ON_EXIT;
1484   }
1485
1486   //
1487   // Copy the new FragmentTable buffer into Buffer.
1488   //
1489   for (Index = 0; Index < FragmentCount; Index++) {
1490     CopyMem (
1491       (Buffer + BytesCopied),
1492       FragmentTable[Index].FragmentBuffer,
1493       FragmentTable[Index].FragmentLength
1494       );
1495     BytesCopied += FragmentTable[Index].FragmentLength;
1496
1497     //
1498     // Free the FragmentBuffer since it has been copied.
1499     //
1500     FreePool (FragmentTable[Index].FragmentBuffer);
1501   }
1502
1503   Fragment->Len  = BufferSize;
1504   Fragment->Bulk = Buffer;
1505
1506 ON_EXIT:
1507
1508   if (OriginalFragmentTable != NULL) {
1509     if( FragmentTable == OriginalFragmentTable) {
1510       FragmentTable = NULL;
1511     }
1512     FreePool (OriginalFragmentTable);
1513     OriginalFragmentTable = NULL;
1514   }
1515
1516   //
1517   // Caller has the responsibility to free the FragmentTable.
1518   //
1519   if (FragmentTable != NULL) {
1520     FreePool (FragmentTable);
1521     FragmentTable = NULL;
1522   }
1523
1524   return Status;
1525 }
1526
1527 /**
1528   Receive one fragment decrypted from one TLS record.
1529
1530   @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
1531   @param[in, out]      Fragment        The received Fragment.
1532   @param[in]           Timeout         The time to wait for connection done.
1533
1534   @retval EFI_SUCCESS          One fragment is received.
1535   @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources.
1536   @retval EFI_ABORTED          Something wrong decryption the message.
1537   @retval Others               Other errors as indicated.
1538
1539 **/
1540 EFI_STATUS
1541 EFIAPI
1542 HttpsReceive (
1543   IN     HTTP_PROTOCOL         *HttpInstance,
1544   IN OUT NET_FRAGMENT          *Fragment,
1545   IN     EFI_EVENT             Timeout
1546   )
1547 {
1548   EFI_STATUS                      Status;
1549   NET_BUF                         *Pdu;
1550   TLS_RECORD_HEADER               RecordHeader;
1551   UINT8                           *BufferIn;
1552   UINTN                           BufferInSize;
1553   NET_FRAGMENT                    TempFragment;
1554   UINT8                           *BufferOut;
1555   UINTN                           BufferOutSize;
1556   NET_BUF                         *PacketOut;
1557   UINT8                           *DataOut;
1558   UINT8                           *GetSessionDataBuffer;
1559   UINTN                           GetSessionDataBufferSize;
1560
1561   Status                   = EFI_SUCCESS;
1562   Pdu                      = NULL;
1563   BufferIn                 = NULL;
1564   BufferInSize             = 0;
1565   BufferOut                = NULL;
1566   BufferOutSize            = 0;
1567   PacketOut                = NULL;
1568   DataOut                  = NULL;
1569   GetSessionDataBuffer     = NULL;
1570   GetSessionDataBufferSize = 0;
1571
1572   //
1573   // Receive only one TLS record
1574   //
1575   Status = TlsReceiveOnePdu (HttpInstance, &Pdu, Timeout);
1576   if (EFI_ERROR (Status)) {
1577     return Status;
1578   }
1579
1580   BufferInSize = Pdu->TotalSize;
1581   BufferIn = AllocateZeroPool (BufferInSize);
1582   if (BufferIn == NULL) {
1583     Status = EFI_OUT_OF_RESOURCES;
1584     NetbufFree (Pdu);
1585     return Status;
1586   }
1587
1588   NetbufCopy (Pdu, 0, (UINT32) BufferInSize, BufferIn);
1589
1590   NetbufFree (Pdu);
1591
1592   //
1593   // Handle Receive data.
1594   //
1595   RecordHeader = *(TLS_RECORD_HEADER *) BufferIn;
1596
1597   if ((RecordHeader.ContentType == TlsContentTypeApplicationData) &&
1598     (RecordHeader.Version.Major == 0x03) &&
1599     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
1600     RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR ||
1601     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
1602   ) {
1603     //
1604     // Decrypt Packet.
1605     //
1606     Status = TlsProcessMessage (
1607                HttpInstance,
1608                BufferIn,
1609                BufferInSize,
1610                EfiTlsDecrypt,
1611                &TempFragment
1612                );
1613
1614     FreePool (BufferIn);
1615
1616     if (EFI_ERROR (Status)) {
1617       if (Status == EFI_ABORTED) {
1618         //
1619         // Something wrong decryption the message.
1620         // BuildResponsePacket() will be called to generate Error Alert message and send it out.
1621         //
1622         BufferOutSize = DEF_BUF_LEN;
1623         BufferOut = AllocateZeroPool (BufferOutSize);
1624         if (BufferOut == NULL) {
1625           Status = EFI_OUT_OF_RESOURCES;
1626           return Status;
1627         }
1628
1629         Status = HttpInstance->Tls->BuildResponsePacket (
1630                                       HttpInstance->Tls,
1631                                       NULL,
1632                                       0,
1633                                       BufferOut,
1634                                       &BufferOutSize
1635                                       );
1636         if (Status == EFI_BUFFER_TOO_SMALL) {
1637           FreePool (BufferOut);
1638           BufferOut = AllocateZeroPool (BufferOutSize);
1639           if (BufferOut == NULL) {
1640             Status = EFI_OUT_OF_RESOURCES;
1641             return Status;
1642           }
1643
1644           Status = HttpInstance->Tls->BuildResponsePacket (
1645                                         HttpInstance->Tls,
1646                                         NULL,
1647                                         0,
1648                                         BufferOut,
1649                                         &BufferOutSize
1650                                         );
1651         }
1652         if (EFI_ERROR (Status)) {
1653           FreePool(BufferOut);
1654           return Status;
1655         }
1656
1657         if (BufferOutSize != 0) {
1658           PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
1659           DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
1660           if (DataOut == NULL) {
1661             FreePool (BufferOut);
1662             return EFI_OUT_OF_RESOURCES;
1663           }
1664
1665           CopyMem (DataOut, BufferOut, BufferOutSize);
1666
1667           Status = TlsCommonTransmit (HttpInstance, PacketOut);
1668
1669           NetbufFree (PacketOut);
1670         }
1671
1672         FreePool(BufferOut);
1673
1674         if (EFI_ERROR (Status)) {
1675           return Status;
1676         }
1677
1678         return EFI_ABORTED;
1679       }
1680
1681       return Status;
1682     }
1683
1684     //
1685     // Parsing buffer.
1686     //
1687     ASSERT (((TLS_RECORD_HEADER *) (TempFragment.Bulk))->ContentType == TlsContentTypeApplicationData);
1688
1689     BufferInSize = ((TLS_RECORD_HEADER *) (TempFragment.Bulk))->Length;
1690     BufferIn = AllocateZeroPool (BufferInSize);
1691     if (BufferIn == NULL) {
1692       Status = EFI_OUT_OF_RESOURCES;
1693       return Status;
1694     }
1695
1696     CopyMem (BufferIn, TempFragment.Bulk + TLS_RECORD_HEADER_LENGTH, BufferInSize);
1697
1698     //
1699     // Free the buffer in TempFragment.
1700     //
1701     FreePool (TempFragment.Bulk);
1702
1703   } else if ((RecordHeader.ContentType == TlsContentTypeAlert) &&
1704     (RecordHeader.Version.Major == 0x03) &&
1705     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
1706     RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR ||
1707     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
1708     ) {
1709     BufferOutSize = DEF_BUF_LEN;
1710     BufferOut = AllocateZeroPool (BufferOutSize);
1711     if (BufferOut == NULL) {
1712       FreePool (BufferIn);
1713       Status = EFI_OUT_OF_RESOURCES;
1714       return Status;
1715     }
1716
1717     Status = HttpInstance->Tls->BuildResponsePacket (
1718                                   HttpInstance->Tls,
1719                                   BufferIn,
1720                                   BufferInSize,
1721                                   BufferOut,
1722                                   &BufferOutSize
1723                                   );
1724     if (Status == EFI_BUFFER_TOO_SMALL) {
1725       FreePool (BufferOut);
1726       BufferOut = AllocateZeroPool (BufferOutSize);
1727       if (BufferOut == NULL) {
1728         FreePool (BufferIn);
1729         Status = EFI_OUT_OF_RESOURCES;
1730         return Status;
1731       }
1732
1733       Status = HttpInstance->Tls->BuildResponsePacket (
1734                                     HttpInstance->Tls,
1735                                     BufferIn,
1736                                     BufferInSize,
1737                                     BufferOut,
1738                                     &BufferOutSize
1739                                     );
1740     }
1741
1742     FreePool (BufferIn);
1743
1744     if (EFI_ERROR (Status)) {
1745       FreePool (BufferOut);
1746       return Status;
1747     }
1748
1749     if (BufferOutSize != 0) {
1750       PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
1751       DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
1752       if (DataOut == NULL) {
1753         FreePool (BufferOut);
1754         return EFI_OUT_OF_RESOURCES;
1755       }
1756
1757       CopyMem (DataOut, BufferOut, BufferOutSize);
1758
1759       Status = TlsCommonTransmit (HttpInstance, PacketOut);
1760
1761       NetbufFree (PacketOut);
1762     }
1763
1764     FreePool (BufferOut);
1765
1766     //
1767     // Get the session state.
1768     //
1769     GetSessionDataBufferSize = DEF_BUF_LEN;
1770     GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
1771     if (GetSessionDataBuffer == NULL) {
1772       Status = EFI_OUT_OF_RESOURCES;
1773       return Status;
1774     }
1775
1776     Status = HttpInstance->Tls->GetSessionData (
1777                                   HttpInstance->Tls,
1778                                   EfiTlsSessionState,
1779                                   GetSessionDataBuffer,
1780                                   &GetSessionDataBufferSize
1781                                   );
1782     if (Status == EFI_BUFFER_TOO_SMALL) {
1783        FreePool (GetSessionDataBuffer);
1784        GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
1785        if (GetSessionDataBuffer == NULL) {
1786          Status = EFI_OUT_OF_RESOURCES;
1787          return Status;
1788        }
1789
1790        Status = HttpInstance->Tls->GetSessionData (
1791                                      HttpInstance->Tls,
1792                                      EfiTlsSessionState,
1793                                      GetSessionDataBuffer,
1794                                      &GetSessionDataBufferSize
1795                                      );
1796     }
1797     if (EFI_ERROR (Status)) {
1798       FreePool (GetSessionDataBuffer);
1799       return Status;
1800     }
1801
1802     ASSERT(GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
1803     HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *) GetSessionDataBuffer;
1804
1805     FreePool (GetSessionDataBuffer);
1806
1807     if(HttpInstance->TlsSessionState == EfiTlsSessionError) {
1808       DEBUG ((EFI_D_ERROR, "TLS Session State Error!\n"));
1809       return EFI_ABORTED;
1810     }
1811
1812     BufferIn = NULL;
1813     BufferInSize = 0;
1814   }
1815
1816   Fragment->Bulk = BufferIn;
1817   Fragment->Len = (UINT32) BufferInSize;
1818
1819   return Status;
1820 }
1821