VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/HttpDxe/HttpsSupport.c

    r85718 r99404  
    3232CHAR8 *
    3333AsciiStrCaseStr (
    34   IN      CONST CHAR8               *String,
    35   IN      CONST CHAR8               *SearchString
     34  IN      CONST CHAR8  *String,
     35  IN      CONST CHAR8  *SearchString
    3636  )
    3737{
    38   CONST CHAR8 *FirstMatch;
    39   CONST CHAR8 *SearchStringTmp;
    40 
    41   CHAR8 Src;
    42   CHAR8 Dst;
     38  CONST CHAR8  *FirstMatch;
     39  CONST CHAR8  *SearchStringTmp;
     40
     41  CHAR8  Src;
     42  CHAR8  Dst;
    4343
    4444  //
    … …  
    4949
    5050  if (*SearchString == '\0') {
    51     return (CHAR8 *) String;
     51    return (CHAR8 *)String;
    5252  }
    5353
    5454  while (*String != '\0') {
    5555    SearchStringTmp = SearchString;
    56     FirstMatch = String;
    57 
    58     while ((*SearchStringTmp != '\0')
    59             && (*String != '\0')) {
     56    FirstMatch      = String;
     57
     58    while (  (*SearchStringTmp != '\0')
     59          && (*String != '\0'))
     60    {
    6061      Src = *String;
    6162      Dst = *SearchStringTmp;
    … …  
    7879
    7980    if (*SearchStringTmp == '\0') {
    80       return (CHAR8 *) FirstMatch;
     81      return (CHAR8 *)FirstMatch;
    8182    }
    8283
    … …  
    9697EFIAPI
    9798FreeNbufList (
    98   IN VOID *Arg
     99  IN VOID  *Arg
    99100  )
    100101{
    101102  ASSERT (Arg != NULL);
    102103
    103   NetbufFreeList ((LIST_ENTRY *) Arg);
     104  NetbufFreeList ((LIST_ENTRY *)Arg);
    104105  FreePool (Arg);
    105106}
    … …  
    116117BOOLEAN
    117118IsHttpsUrl (
    118   IN CHAR8    *Url
     119  IN CHAR8  *Url
    119120  )
    120121{
    … …  
    124125
    125126  Tmp = AsciiStrCaseStr (Url, HTTPS_FLAG);
    126   if (Tmp != NULL && Tmp == Url) {
     127  if ((Tmp != NULL) && (Tmp == Url)) {
    127128    return TRUE;
    128129  }
    … …  
    145146EFIAPI
    146147TlsCreateChild (
    147   IN  EFI_HANDLE                     ImageHandle,
    148   OUT EFI_SERVICE_BINDING_PROTOCOL   **TlsSb,
    149   OUT EFI_TLS_PROTOCOL               **TlsProto,
    150   OUT EFI_TLS_CONFIGURATION_PROTOCOL **TlsConfiguration
     148  IN  EFI_HANDLE                      ImageHandle,
     149  OUT EFI_SERVICE_BINDING_PROTOCOL    **TlsSb,
     150  OUT EFI_TLS_PROTOCOL                **TlsProto,
     151  OUT EFI_TLS_CONFIGURATION_PROTOCOL  **TlsConfiguration
    151152  )
    152153{
    153   EFI_STATUS                    Status;
    154   EFI_HANDLE                    TlsChildHandle;
     154  EFI_STATUS  Status;
     155  EFI_HANDLE  TlsChildHandle;
    155156
    156157  TlsChildHandle = 0;
    … …  
    160161  //
    161162  gBS->LocateProtocol (
    162      &gEfiTlsServiceBindingProtocolGuid,
    163      NULL,
    164      (VOID **) TlsSb
    165      );
     163         &gEfiTlsServiceBindingProtocolGuid,
     164         NULL,
     165         (VOID **)TlsSb
     166         );
    166167  if (*TlsSb == NULL) {
    167168    return NULL;
    … …  
    176177                  TlsChildHandle,
    177178                  &gEfiTlsProtocolGuid,
    178                   (VOID **) TlsProto,
     179                  (VOID **)TlsProto,
    179180                  ImageHandle,
    180181                  TlsChildHandle,
    … …  
    189190                  TlsChildHandle,
    190191                  &gEfiTlsConfigurationProtocolGuid,
    191                   (VOID **) TlsConfiguration,
     192                  (VOID **)TlsConfiguration,
    192193                  ImageHandle,
    193194                  TlsChildHandle,
    … …  
    215216EFIAPI
    216217TlsCreateTxRxEvent (
    217   IN OUT HTTP_PROTOCOL      *HttpInstance
     218  IN OUT HTTP_PROTOCOL  *HttpInstance
    218219  )
    219220{
    220   EFI_STATUS                Status;
     221  EFI_STATUS  Status;
    221222
    222223  if (!HttpInstance->LocalAddressIsIPv6) {
    … …  
    235236    }
    236237
    237     HttpInstance->Tcp4TlsTxData.Push = TRUE;
    238     HttpInstance->Tcp4TlsTxData.Urgent = FALSE;
    239     HttpInstance->Tcp4TlsTxData.DataLength = 0;
    240     HttpInstance->Tcp4TlsTxData.FragmentCount = 1;
     238    HttpInstance->Tcp4TlsTxData.Push                            = TRUE;
     239    HttpInstance->Tcp4TlsTxData.Urgent                          = FALSE;
     240    HttpInstance->Tcp4TlsTxData.DataLength                      = 0;
     241    HttpInstance->Tcp4TlsTxData.FragmentCount                   = 1;
    241242    HttpInstance->Tcp4TlsTxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp4TlsTxData.DataLength;
    242243    HttpInstance->Tcp4TlsTxData.FragmentTable[0].FragmentBuffer = NULL;
    243     HttpInstance->Tcp4TlsTxToken.Packet.TxData = &HttpInstance->Tcp4TlsTxData;
    244     HttpInstance->Tcp4TlsTxToken.CompletionToken.Status = EFI_NOT_READY;
     244    HttpInstance->Tcp4TlsTxToken.Packet.TxData                  = &HttpInstance->Tcp4TlsTxData;
     245    HttpInstance->Tcp4TlsTxToken.CompletionToken.Status         = EFI_NOT_READY;
    245246
    246247    //
    … …  
    258259    }
    259260
    260     HttpInstance->Tcp4TlsRxData.DataLength                       = 0;
    261     HttpInstance->Tcp4TlsRxData.FragmentCount                    = 1;
    262     HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentLength  = HttpInstance->Tcp4TlsRxData.DataLength ;
    263     HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentBuffer  = NULL;
    264     HttpInstance->Tcp4TlsRxToken.Packet.RxData          = &HttpInstance->Tcp4TlsRxData;
    265     HttpInstance->Tcp4TlsRxToken.CompletionToken.Status = EFI_NOT_READY;
     261    HttpInstance->Tcp4TlsRxData.DataLength                      = 0;
     262    HttpInstance->Tcp4TlsRxData.FragmentCount                   = 1;
     263    HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp4TlsRxData.DataLength;
     264    HttpInstance->Tcp4TlsRxData.FragmentTable[0].FragmentBuffer = NULL;
     265    HttpInstance->Tcp4TlsRxToken.Packet.RxData                  = &HttpInstance->Tcp4TlsRxData;
     266    HttpInstance->Tcp4TlsRxToken.CompletionToken.Status         = EFI_NOT_READY;
    266267  } else {
    267268    //
    … …  
    279280    }
    280281
    281     HttpInstance->Tcp6TlsTxData.Push = TRUE;
    282     HttpInstance->Tcp6TlsTxData.Urgent = FALSE;
    283     HttpInstance->Tcp6TlsTxData.DataLength = 0;
    284     HttpInstance->Tcp6TlsTxData.FragmentCount = 1;
     282    HttpInstance->Tcp6TlsTxData.Push                            = TRUE;
     283    HttpInstance->Tcp6TlsTxData.Urgent                          = FALSE;
     284    HttpInstance->Tcp6TlsTxData.DataLength                      = 0;
     285    HttpInstance->Tcp6TlsTxData.FragmentCount                   = 1;
    285286    HttpInstance->Tcp6TlsTxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp6TlsTxData.DataLength;
    286287    HttpInstance->Tcp6TlsTxData.FragmentTable[0].FragmentBuffer = NULL;
    287     HttpInstance->Tcp6TlsTxToken.Packet.TxData = &HttpInstance->Tcp6TlsTxData;
    288     HttpInstance->Tcp6TlsTxToken.CompletionToken.Status = EFI_NOT_READY;
     288    HttpInstance->Tcp6TlsTxToken.Packet.TxData                  = &HttpInstance->Tcp6TlsTxData;
     289    HttpInstance->Tcp6TlsTxToken.CompletionToken.Status         = EFI_NOT_READY;
    289290
    290291    //
    … …  
    302303    }
    303304
    304     HttpInstance->Tcp6TlsRxData.DataLength                       = 0;
    305     HttpInstance->Tcp6TlsRxData.FragmentCount                    = 1;
    306     HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentLength  = HttpInstance->Tcp6TlsRxData.DataLength ;
    307     HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentBuffer  = NULL;
    308     HttpInstance->Tcp6TlsRxToken.Packet.RxData          = &HttpInstance->Tcp6TlsRxData;
    309     HttpInstance->Tcp6TlsRxToken.CompletionToken.Status = EFI_NOT_READY;
     305    HttpInstance->Tcp6TlsRxData.DataLength                      = 0;
     306    HttpInstance->Tcp6TlsRxData.FragmentCount                   = 1;
     307    HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentLength = HttpInstance->Tcp6TlsRxData.DataLength;
     308    HttpInstance->Tcp6TlsRxData.FragmentTable[0].FragmentBuffer = NULL;
     309    HttpInstance->Tcp6TlsRxToken.Packet.RxData                  = &HttpInstance->Tcp6TlsRxData;
     310    HttpInstance->Tcp6TlsRxToken.CompletionToken.Status         = EFI_NOT_READY;
    310311  }
    311312
    … …  
    330331EFIAPI
    331332TlsCloseTxRxEvent (
    332   IN  HTTP_PROTOCOL        *HttpInstance
     333  IN  HTTP_PROTOCOL  *HttpInstance
    333334  )
    334335{
    … …  
    336337  if (!HttpInstance->LocalAddressIsIPv6) {
    337338    if (NULL != HttpInstance->Tcp4TlsTxToken.CompletionToken.Event) {
    338       gBS->CloseEvent(HttpInstance->Tcp4TlsTxToken.CompletionToken.Event);
     339      gBS->CloseEvent (HttpInstance->Tcp4TlsTxToken.CompletionToken.Event);
    339340      HttpInstance->Tcp4TlsTxToken.CompletionToken.Event = NULL;
    340341    }
    … …  
    346347  } else {
    347348    if (NULL != HttpInstance->Tcp6TlsTxToken.CompletionToken.Event) {
    348       gBS->CloseEvent(HttpInstance->Tcp6TlsTxToken.CompletionToken.Event);
     349      gBS->CloseEvent (HttpInstance->Tcp6TlsTxToken.CompletionToken.Event);
    349350      HttpInstance->Tcp6TlsTxToken.CompletionToken.Event = NULL;
    350351    }
    … …  
    370371EFI_STATUS
    371372TlsConfigCertificate (
    372   IN OUT HTTP_PROTOCOL      *HttpInstance
     373  IN OUT HTTP_PROTOCOL  *HttpInstance
    373374  )
    374375{
    … …  
    389390  // Try to read the TlsCaCertificate variable.
    390391  //
    391   Status  = gRT->GetVariable (
    392                    EFI_TLS_CA_CERTIFICATE_VARIABLE,
    393                    &gEfiTlsCaCertificateGuid,
    394                    NULL,
    395                    &CACertSize,
    396                    NULL
    397                    );
    398 
    399   if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
     392  Status = gRT->GetVariable (
     393                  EFI_TLS_CA_CERTIFICATE_VARIABLE,
     394                  &gEfiTlsCaCertificateGuid,
     395                  NULL,
     396                  &CACertSize,
     397                  NULL
     398                  );
     399
     400  if (EFI_ERROR (Status) && (Status != EFI_BUFFER_TOO_SMALL)) {
    400401    return Status;
    401402  }
    … …  
    428429  // Sanity check
    429430  //
    430   Status = EFI_INVALID_PARAMETER;
    431   CertCount = 0;
    432   ItemDataSize = (UINT32) CACertSize;
     431  Status       = EFI_INVALID_PARAMETER;
     432  CertCount    = 0;
     433  ItemDataSize = (UINT32)CACertSize;
    433434  while (ItemDataSize > 0) {
    434435    if (ItemDataSize < sizeof (EFI_SIGNATURE_LIST)) {
    435       DEBUG ((DEBUG_ERROR, "%a: truncated EFI_SIGNATURE_LIST header\n",
    436         __FUNCTION__));
     436      DEBUG ((
     437        DEBUG_ERROR,
     438        "%a: truncated EFI_SIGNATURE_LIST header\n",
     439        __FUNCTION__
     440        ));
    437441      goto FreeCACert;
    438442    }
    439443
    440     CertList = (EFI_SIGNATURE_LIST *) (CACert + (CACertSize - ItemDataSize));
     444    CertList = (EFI_SIGNATURE_LIST *)(CACert + (CACertSize - ItemDataSize));
    441445
    442446    if (CertList->SignatureListSize < sizeof (EFI_SIGNATURE_LIST)) {
    443       DEBUG ((DEBUG_ERROR,
     447      DEBUG ((
     448        DEBUG_ERROR,
    444449        "%a: SignatureListSize too small for EFI_SIGNATURE_LIST\n",
    445         __FUNCTION__));
     450        __FUNCTION__
     451        ));
    446452      goto FreeCACert;
    447453    }
    448454
    449455    if (CertList->SignatureListSize > ItemDataSize) {
    450       DEBUG ((DEBUG_ERROR, "%a: truncated EFI_SIGNATURE_LIST body\n",
    451         __FUNCTION__));
     456      DEBUG ((
     457        DEBUG_ERROR,
     458        "%a: truncated EFI_SIGNATURE_LIST body\n",
     459        __FUNCTION__
     460        ));
    452461      goto FreeCACert;
    453462    }
    454463
    455464    if (!CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {
    456       DEBUG ((DEBUG_ERROR, "%a: only X509 certificates are supported\n",
    457         __FUNCTION__));
     465      DEBUG ((
     466        DEBUG_ERROR,
     467        "%a: only X509 certificates are supported\n",
     468        __FUNCTION__
     469        ));
    458470      Status = EFI_UNSUPPORTED;
    459471      goto FreeCACert;
    … …  
    461473
    462474    if (CertList->SignatureHeaderSize != 0) {
    463       DEBUG ((DEBUG_ERROR, "%a: SignatureHeaderSize must be 0 for X509\n",
    464         __FUNCTION__));
     475      DEBUG ((
     476        DEBUG_ERROR,
     477        "%a: SignatureHeaderSize must be 0 for X509\n",
     478        __FUNCTION__
     479        ));
    465480      goto FreeCACert;
    466481    }
    467482
    468483    if (CertList->SignatureSize < sizeof (EFI_SIGNATURE_DATA)) {
    469       DEBUG ((DEBUG_ERROR,
    470         "%a: SignatureSize too small for EFI_SIGNATURE_DATA\n", __FUNCTION__));
     484      DEBUG ((
     485        DEBUG_ERROR,
     486        "%a: SignatureSize too small for EFI_SIGNATURE_DATA\n",
     487        __FUNCTION__
     488        ));
    471489      goto FreeCACert;
    472490    }
    … …  
    475493                            sizeof (EFI_SIGNATURE_LIST));
    476494    if (CertArraySizeInBytes % CertList->SignatureSize != 0) {
    477       DEBUG ((DEBUG_ERROR,
     495      DEBUG ((
     496        DEBUG_ERROR,
    478497        "%a: EFI_SIGNATURE_DATA array not a multiple of SignatureSize\n",
    479         __FUNCTION__));
     498        __FUNCTION__
     499        ));
    480500      goto FreeCACert;
    481501    }
    482502
    483     CertCount += CertArraySizeInBytes / CertList->SignatureSize;
     503    CertCount    += CertArraySizeInBytes / CertList->SignatureSize;
    484504    ItemDataSize -= CertList->SignatureListSize;
    485505  }
     506
    486507  if (CertCount == 0) {
    487508    DEBUG ((DEBUG_ERROR, "%a: no X509 certificates provided\n", __FUNCTION__));
    … …  
    492513  // Enumerate all data and erasing the target item.
    493514  //
    494   ItemDataSize = (UINT32) CACertSize;
    495   CertList = (EFI_SIGNATURE_LIST *) CACert;
     515  ItemDataSize = (UINT32)CACertSize;
     516  CertList     = (EFI_SIGNATURE_LIST *)CACert;
    496517  while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {
    497     Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
    498     CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
     518    Cert      = (EFI_SIGNATURE_DATA *)((UINT8 *)CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
     519    CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
    499520    for (Index = 0; Index < CertCount; Index++) {
    500521      //
    … …  
    511532      }
    512533
    513       Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);
     534      Cert = (EFI_SIGNATURE_DATA *)((UINT8 *)Cert + CertList->SignatureSize);
    514535    }
    515536
    516537    ItemDataSize -= CertList->SignatureListSize;
    517     CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
     538    CertList      = (EFI_SIGNATURE_LIST *)((UINT8 *)CertList + CertList->SignatureListSize);
    518539  }
    519540
    … …  
    538559EFI_STATUS
    539560TlsConfigCipherList (
    540   IN OUT HTTP_PROTOCOL      *HttpInstance
     561  IN OUT HTTP_PROTOCOL  *HttpInstance
    541562  )
    542563{
    543   EFI_STATUS          Status;
    544   UINT8               *CipherList;
    545   UINTN               CipherListSize;
     564  EFI_STATUS  Status;
     565  UINT8       *CipherList;
     566  UINTN       CipherListSize;
    546567
    547568  CipherList     = NULL;
    … …  
    551572  // Try to read the HttpTlsCipherList variable.
    552573  //
    553   Status  = gRT->GetVariable (
    554                    EDKII_HTTP_TLS_CIPHER_LIST_VARIABLE,
    555                    &gEdkiiHttpTlsCipherListGuid,
    556                    NULL,
    557                    &CipherListSize,
    558                    NULL
    559                    );
     574  Status = gRT->GetVariable (
     575                  EDKII_HTTP_TLS_CIPHER_LIST_VARIABLE,
     576                  &gEdkiiHttpTlsCipherListGuid,
     577                  NULL,
     578                  &CipherListSize,
     579                  NULL
     580                  );
    560581  ASSERT (EFI_ERROR (Status));
    561582  if (Status != EFI_BUFFER_TOO_SMALL) {
    … …  
    616637EFIAPI
    617638TlsConfigureSession (
    618   IN OUT HTTP_PROTOCOL      *HttpInstance
     639  IN OUT HTTP_PROTOCOL  *HttpInstance
    619640  )
    620641{
    621   EFI_STATUS                 Status;
     642  EFI_STATUS  Status;
    622643
    623644  //
    … …  
    626647  HttpInstance->TlsConfigData.ConnectionEnd       = EfiTlsClient;
    627648  HttpInstance->TlsConfigData.VerifyMethod        = EFI_TLS_VERIFY_PEER;
    628   HttpInstance->TlsConfigData.VerifyHost.Flags    = EFI_TLS_VERIFY_FLAG_NO_WILDCARDS;
     649  HttpInstance->TlsConfigData.VerifyHost.Flags    = EFI_TLS_VERIFY_FLAG_NONE;
    629650  HttpInstance->TlsConfigData.VerifyHost.HostName = HttpInstance->RemoteHost;
    630651  HttpInstance->TlsConfigData.SessionState        = EfiTlsSessionNotStarted;
    … …  
    680701  //
    681702  Status = TlsConfigCipherList (HttpInstance);
    682   if (EFI_ERROR (Status) && Status != EFI_NOT_FOUND) {
    683     DEBUG ((EFI_D_ERROR, "TlsConfigCipherList: return %r error.\n", Status));
     703  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
     704    DEBUG ((DEBUG_ERROR, "TlsConfigCipherList: return %r error.\n", Status));
    684705    return Status;
    685706  }
    … …  
    690711  Status = TlsConfigCertificate (HttpInstance);
    691712  if (EFI_ERROR (Status)) {
    692     DEBUG ((EFI_D_ERROR, "TLS Certificate Config Error!\n"));
     713    DEBUG ((DEBUG_ERROR, "TLS Certificate Config Error!\n"));
    693714    return Status;
    694715  }
    … …  
    726747EFIAPI
    727748TlsCommonTransmit (
    728   IN OUT HTTP_PROTOCOL      *HttpInstance,
    729   IN     NET_BUF            *Packet
     749  IN OUT HTTP_PROTOCOL  *HttpInstance,
     750  IN     NET_BUF        *Packet
    730751  )
    731752{
    732   EFI_STATUS                Status;
    733   VOID                      *Data;
    734   UINTN                     Size;
     753  EFI_STATUS  Status;
     754  VOID        *Data;
     755  UINTN       Size;
    735756
    736757  if ((HttpInstance == NULL) || (Packet == NULL)) {
    … …  
    752773
    753774  if (!HttpInstance->LocalAddressIsIPv6) {
    754     ((EFI_TCP4_TRANSMIT_DATA *) Data)->Push        = TRUE;
    755     ((EFI_TCP4_TRANSMIT_DATA *) Data)->Urgent      = FALSE;
    756     ((EFI_TCP4_TRANSMIT_DATA *) Data)->DataLength = Packet->TotalSize;
     775    ((EFI_TCP4_TRANSMIT_DATA *)Data)->Push       = TRUE;
     776    ((EFI_TCP4_TRANSMIT_DATA *)Data)->Urgent     = FALSE;
     777    ((EFI_TCP4_TRANSMIT_DATA *)Data)->DataLength = Packet->TotalSize;
    757778
    758779    //
    759780    // Build the fragment table.
    760781    //
    761     ((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentCount = Packet->BlockOpNum;
     782    ((EFI_TCP4_TRANSMIT_DATA *)Data)->FragmentCount = Packet->BlockOpNum;
    762783
    763784    NetbufBuildExt (
    764785      Packet,
    765       (NET_FRAGMENT *) &((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentTable[0],
    766       &((EFI_TCP4_TRANSMIT_DATA *) Data)->FragmentCount
     786      (NET_FRAGMENT *)&((EFI_TCP4_TRANSMIT_DATA *)Data)->FragmentTable[0],
     787      &((EFI_TCP4_TRANSMIT_DATA *)Data)->FragmentCount
    767788      );
    768789
    769     HttpInstance->Tcp4TlsTxToken.Packet.TxData = (EFI_TCP4_TRANSMIT_DATA *) Data;
     790    HttpInstance->Tcp4TlsTxToken.Packet.TxData = (EFI_TCP4_TRANSMIT_DATA *)Data;
    770791
    771792    Status = EFI_DEVICE_ERROR;
    … …  
    774795    // Transmit the packet.
    775796    //
    776     Status  = HttpInstance->Tcp4->Transmit (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsTxToken);
     797    Status = HttpInstance->Tcp4->Transmit (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsTxToken);
    777798    if (EFI_ERROR (Status)) {
    778799      goto ON_EXIT;
    … …  
    784805
    785806    HttpInstance->TlsIsTxDone = FALSE;
    786     Status = HttpInstance->Tcp4TlsTxToken.CompletionToken.Status;
     807    Status                    = HttpInstance->Tcp4TlsTxToken.CompletionToken.Status;
    787808  } else {
    788     ((EFI_TCP6_TRANSMIT_DATA *) Data)->Push        = TRUE;
    789     ((EFI_TCP6_TRANSMIT_DATA *) Data)->Urgent      = FALSE;
    790     ((EFI_TCP6_TRANSMIT_DATA *) Data)->DataLength = Packet->TotalSize;
     809    ((EFI_TCP6_TRANSMIT_DATA *)Data)->Push       = TRUE;
     810    ((EFI_TCP6_TRANSMIT_DATA *)Data)->Urgent     = FALSE;
     811    ((EFI_TCP6_TRANSMIT_DATA *)Data)->DataLength = Packet->TotalSize;
    791812
    792813    //
    793814    // Build the fragment table.
    794815    //
    795     ((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentCount = Packet->BlockOpNum;
     816    ((EFI_TCP6_TRANSMIT_DATA *)Data)->FragmentCount = Packet->BlockOpNum;
    796817
    797818    NetbufBuildExt (
    798819      Packet,
    799       (NET_FRAGMENT *) &((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentTable[0],
    800       &((EFI_TCP6_TRANSMIT_DATA *) Data)->FragmentCount
     820      (NET_FRAGMENT *)&((EFI_TCP6_TRANSMIT_DATA *)Data)->FragmentTable[0],
     821      &((EFI_TCP6_TRANSMIT_DATA *)Data)->FragmentCount
    801822      );
    802823
    803     HttpInstance->Tcp6TlsTxToken.Packet.TxData = (EFI_TCP6_TRANSMIT_DATA *) Data;
     824    HttpInstance->Tcp6TlsTxToken.Packet.TxData = (EFI_TCP6_TRANSMIT_DATA *)Data;
    804825
    805826    Status = EFI_DEVICE_ERROR;
    … …  
    808829    // Transmit the packet.
    809830    //
    810     Status  = HttpInstance->Tcp6->Transmit (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsTxToken);
     831    Status = HttpInstance->Tcp6->Transmit (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsTxToken);
    811832    if (EFI_ERROR (Status)) {
    812833      goto ON_EXIT;
    … …  
    818839
    819840    HttpInstance->TlsIsTxDone = FALSE;
    820     Status = HttpInstance->Tcp6TlsTxToken.CompletionToken.Status;
     841    Status                    = HttpInstance->Tcp6TlsTxToken.CompletionToken.Status;
    821842  }
    822843
    … …  
    844865EFIAPI
    845866TlsCommonReceive (
    846   IN OUT HTTP_PROTOCOL      *HttpInstance,
    847   IN     NET_BUF            *Packet,
    848   IN     EFI_EVENT          Timeout
     867  IN OUT HTTP_PROTOCOL  *HttpInstance,
     868  IN     NET_BUF        *Packet,
     869  IN     EFI_EVENT      Timeout
    849870  )
    850871{
    851   EFI_TCP4_RECEIVE_DATA     *Tcp4RxData;
    852   EFI_TCP6_RECEIVE_DATA     *Tcp6RxData;
    853   EFI_STATUS                Status;
    854   NET_FRAGMENT              *Fragment;
    855   UINT32                    FragmentCount;
    856   UINT32                    CurrentFragment;
     872  EFI_TCP4_RECEIVE_DATA  *Tcp4RxData;
     873  EFI_TCP6_RECEIVE_DATA  *Tcp6RxData;
     874  EFI_STATUS             Status;
     875  NET_FRAGMENT           *Fragment;
     876  UINT32                 FragmentCount;
     877  UINT32                 CurrentFragment;
    857878
    858879  Tcp4RxData = NULL;
    … …  
    880901      return EFI_INVALID_PARAMETER;
    881902    }
    882     Tcp4RxData->FragmentCount         = 1;
     903
     904    Tcp4RxData->FragmentCount = 1;
    883905  } else {
    884906    Tcp6RxData = HttpInstance->Tcp6TlsRxToken.Packet.RxData;
    … …  
    886908      return EFI_INVALID_PARAMETER;
    887909    }
    888     Tcp6RxData->FragmentCount         = 1;
    889   }
    890 
    891   CurrentFragment               = 0;
    892   Status                        = EFI_SUCCESS;
     910
     911    Tcp6RxData->FragmentCount = 1;
     912  }
     913
     914  CurrentFragment = 0;
     915  Status          = EFI_SUCCESS;
    893916
    894917  while (CurrentFragment < FragmentCount) {
    895918    if (!HttpInstance->LocalAddressIsIPv6) {
    896       Tcp4RxData->DataLength                       = Fragment[CurrentFragment].Len;
    897       Tcp4RxData->FragmentTable[0].FragmentLength  = Fragment[CurrentFragment].Len;
    898       Tcp4RxData->FragmentTable[0].FragmentBuffer  = Fragment[CurrentFragment].Bulk;
    899       Status = HttpInstance->Tcp4->Receive (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsRxToken);
     919      Tcp4RxData->DataLength                      = Fragment[CurrentFragment].Len;
     920      Tcp4RxData->FragmentTable[0].FragmentLength = Fragment[CurrentFragment].Len;
     921      Tcp4RxData->FragmentTable[0].FragmentBuffer = Fragment[CurrentFragment].Bulk;
     922      Status                                      = HttpInstance->Tcp4->Receive (HttpInstance->Tcp4, &HttpInstance->Tcp4TlsRxToken);
    900923    } else {
    901       Tcp6RxData->DataLength                       = Fragment[CurrentFragment].Len;
    902       Tcp6RxData->FragmentTable[0].FragmentLength  = Fragment[CurrentFragment].Len;
    903       Tcp6RxData->FragmentTable[0].FragmentBuffer  = Fragment[CurrentFragment].Bulk;
    904       Status = HttpInstance->Tcp6->Receive (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsRxToken);
    905     }
     924      Tcp6RxData->DataLength                      = Fragment[CurrentFragment].Len;
     925      Tcp6RxData->FragmentTable[0].FragmentLength = Fragment[CurrentFragment].Len;
     926      Tcp6RxData->FragmentTable[0].FragmentBuffer = Fragment[CurrentFragment].Bulk;
     927      Status                                      = HttpInstance->Tcp6->Receive (HttpInstance->Tcp6, &HttpInstance->Tcp6TlsRxToken);
     928    }
     929
    906930    if (EFI_ERROR (Status)) {
    907931      goto ON_EXIT;
    … …  
    9891013EFIAPI
    9901014TlsReceiveOnePdu (
    991   IN OUT HTTP_PROTOCOL      *HttpInstance,
    992      OUT NET_BUF            **Pdu,
    993   IN     EFI_EVENT          Timeout
     1015  IN OUT HTTP_PROTOCOL  *HttpInstance,
     1016  OUT NET_BUF           **Pdu,
     1017  IN     EFI_EVENT      Timeout
    9941018  )
    9951019{
    996   EFI_STATUS      Status;
    997 
    998   LIST_ENTRY      *NbufList;
    999 
    1000   UINT32          Len;
    1001 
    1002   NET_BUF           *PduHdr;
    1003   UINT8             *Header;
    1004   TLS_RECORD_HEADER RecordHeader;
    1005 
    1006   NET_BUF           *DataSeg;
     1020  EFI_STATUS  Status;
     1021
     1022  LIST_ENTRY  *NbufList;
     1023
     1024  UINT32  Len;
     1025
     1026  NET_BUF            *PduHdr;
     1027  UINT8              *Header;
     1028  TLS_RECORD_HEADER  RecordHeader;
     1029
     1030  NET_BUF  *DataSeg;
    10071031
    10081032  NbufList = NULL;
    … …  
    10211045  // Allocate buffer to receive one TLS header.
    10221046  //
    1023   Len     = TLS_RECORD_HEADER_LENGTH;
    1024   PduHdr  = NetbufAlloc (Len);
     1047  Len    = TLS_RECORD_HEADER_LENGTH;
     1048  PduHdr = NetbufAlloc (Len);
    10251049  if (PduHdr == NULL) {
    10261050    Status = EFI_OUT_OF_RESOURCES;
    … …  
    10421066  }
    10431067
    1044   RecordHeader = *(TLS_RECORD_HEADER *) Header;
    1045   if ((RecordHeader.ContentType == TlsContentTypeHandshake ||
    1046     RecordHeader.ContentType == TlsContentTypeAlert ||
    1047     RecordHeader.ContentType == TlsContentTypeChangeCipherSpec ||
    1048     RecordHeader.ContentType == TlsContentTypeApplicationData) &&
    1049     (RecordHeader.Version.Major == 0x03) && /// Major versions are same.
    1050     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
    1051     RecordHeader.Version.Minor ==TLS11_PROTOCOL_VERSION_MINOR ||
    1052     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
    1053    ) {
     1068  RecordHeader = *(TLS_RECORD_HEADER *)Header;
     1069  if (((RecordHeader.ContentType == TlsContentTypeHandshake) ||
     1070       (RecordHeader.ContentType == TlsContentTypeAlert) ||
     1071       (RecordHeader.ContentType == TlsContentTypeChangeCipherSpec) ||
     1072       (RecordHeader.ContentType == TlsContentTypeApplicationData)) &&
     1073      (RecordHeader.Version.Major == 0x03) && /// Major versions are same.
     1074      ((RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR) ||
     1075       (RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR) ||
     1076       (RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR))
     1077      )
     1078  {
    10541079    InsertTailList (NbufList, &PduHdr->List);
    10551080  } else {
    … …  
    10581083  }
    10591084
    1060   Len = SwapBytes16(RecordHeader.Length);
     1085  Len = SwapBytes16 (RecordHeader.Length);
    10611086  if (Len == 0) {
    10621087    //
    … …  
    11231148EFIAPI
    11241149TlsConnectSession (
    1125   IN  HTTP_PROTOCOL            *HttpInstance,
    1126   IN  EFI_EVENT                Timeout
     1150  IN  HTTP_PROTOCOL  *HttpInstance,
     1151  IN  EFI_EVENT      Timeout
    11271152  )
    11281153{
    1129   EFI_STATUS              Status;
    1130   UINT8                   *BufferOut;
    1131   UINTN                   BufferOutSize;
    1132   NET_BUF                 *PacketOut;
    1133   UINT8                   *DataOut;
    1134   NET_BUF                 *Pdu;
    1135   UINT8                   *BufferIn;
    1136   UINTN                   BufferInSize;
    1137   UINT8                   *GetSessionDataBuffer;
    1138   UINTN                   GetSessionDataBufferSize;
    1139 
    1140   BufferOut    = NULL;
    1141   PacketOut    = NULL;
    1142   DataOut      = NULL;
    1143   Pdu          = NULL;
    1144   BufferIn     = NULL;
     1154  EFI_STATUS  Status;
     1155  UINT8       *BufferOut;
     1156  UINTN       BufferOutSize;
     1157  NET_BUF     *PacketOut;
     1158  UINT8       *DataOut;
     1159  NET_BUF     *Pdu;
     1160  UINT8       *BufferIn;
     1161  UINTN       BufferInSize;
     1162  UINT8       *GetSessionDataBuffer;
     1163  UINTN       GetSessionDataBufferSize;
     1164
     1165  BufferOut = NULL;
     1166  PacketOut = NULL;
     1167  DataOut   = NULL;
     1168  Pdu       = NULL;
     1169  BufferIn  = NULL;
    11451170
    11461171  //
    … …  
    11481173  //
    11491174  HttpInstance->TlsSessionState = EfiTlsSessionNotStarted;
    1150   Status = HttpInstance->Tls->SetSessionData (
    1151                                 HttpInstance->Tls,
    1152                                 EfiTlsSessionState,
    1153                                 &(HttpInstance->TlsSessionState),
    1154                                 sizeof (EFI_TLS_SESSION_STATE)
    1155                                 );
     1175  Status                        = HttpInstance->Tls->SetSessionData (
     1176                                                       HttpInstance->Tls,
     1177                                                       EfiTlsSessionState,
     1178                                                       &(HttpInstance->TlsSessionState),
     1179                                                       sizeof (EFI_TLS_SESSION_STATE)
     1180                                                       );
    11561181  if (EFI_ERROR (Status)) {
    11571182    return Status;
    … …  
    11621187  //
    11631188  BufferOutSize = DEF_BUF_LEN;
    1164   BufferOut = AllocateZeroPool (BufferOutSize);
     1189  BufferOut     = AllocateZeroPool (BufferOutSize);
    11651190  if (BufferOut == NULL) {
    11661191    Status = EFI_OUT_OF_RESOURCES;
    … …  
    11911216                                  );
    11921217  }
     1218
    11931219  if (EFI_ERROR (Status)) {
    11941220    FreePool (BufferOut);
    … …  
    11991225  // Transmit ClientHello
    12001226  //
    1201   PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
    1202   DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
     1227  PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
     1228  DataOut   = NetbufAllocSpace (PacketOut, (UINT32)BufferOutSize, NET_BUF_TAIL);
    12031229  if (DataOut == NULL) {
    12041230    FreePool (BufferOut);
    … …  
    12161242  }
    12171243
    1218   while(HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring && \
    1219     ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
     1244  while (HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring && \
     1245         ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout))))
     1246  {
    12201247    //
    12211248    // Receive one TLS record.
    … …  
    12271254
    12281255    BufferInSize = Pdu->TotalSize;
    1229     BufferIn = AllocateZeroPool (BufferInSize);
     1256    BufferIn     = AllocateZeroPool (BufferInSize);
    12301257    if (BufferIn == NULL) {
    12311258      NetbufFree (Pdu);
    … …  
    12421269    //
    12431270    BufferOutSize = DEF_BUF_LEN;
    1244     BufferOut = AllocateZeroPool (BufferOutSize);
     1271    BufferOut     = AllocateZeroPool (BufferOutSize);
    12451272    if (BufferOut == NULL) {
    1246       Status = EFI_OUT_OF_RESOURCES;
    1247       return Status;
    1248     }
    1249 
    1250     Status = HttpInstance->Tls->BuildResponsePacket (
    1251                                   HttpInstance->Tls,
    1252                                   BufferIn,
    1253                                   BufferInSize,
    1254                                   BufferOut,
    1255                                   &BufferOutSize
    1256                                   );
    1257     if (Status == EFI_BUFFER_TOO_SMALL) {
    1258        FreePool (BufferOut);
    1259        BufferOut = AllocateZeroPool (BufferOutSize);
    1260        if (BufferOut == NULL) {
    1261          FreePool (BufferIn);
    1262          Status = EFI_OUT_OF_RESOURCES;
    1263          return Status;
    1264        }
    1265 
    1266        Status = HttpInstance->Tls->BuildResponsePacket (
    1267                                      HttpInstance->Tls,
    1268                                      BufferIn,
    1269                                      BufferInSize,
    1270                                      BufferOut,
    1271                                      &BufferOutSize
    1272                                      );
    1273     }
    1274 
    1275     FreePool (BufferIn);
    1276 
    1277     if (EFI_ERROR (Status)) {
    1278       FreePool (BufferOut);
    1279       return Status;
    1280     }
    1281 
    1282     if (BufferOutSize != 0) {
    1283       //
    1284       // Transmit the response packet.
    1285       //
    1286       PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
    1287       DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
    1288       if (DataOut == NULL) {
    1289         FreePool (BufferOut);
    1290         return EFI_OUT_OF_RESOURCES;
    1291       }
    1292 
    1293       CopyMem (DataOut, BufferOut, BufferOutSize);
    1294 
    1295       Status = TlsCommonTransmit (HttpInstance, PacketOut);
    1296 
    1297       NetbufFree (PacketOut);
    1298 
    1299       if (EFI_ERROR (Status)) {
    1300         FreePool (BufferOut);
    1301         return Status;
    1302       }
    1303     }
    1304 
    1305     FreePool (BufferOut);
    1306 
    1307     //
    1308     // Get the session state, then decide whether need to continue handle received packet.
    1309     //
    1310     GetSessionDataBufferSize = DEF_BUF_LEN;
    1311     GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
    1312     if (GetSessionDataBuffer == NULL) {
    1313       Status = EFI_OUT_OF_RESOURCES;
    1314       return Status;
    1315     }
    1316 
    1317     Status = HttpInstance->Tls->GetSessionData (
    1318                                   HttpInstance->Tls,
    1319                                   EfiTlsSessionState,
    1320                                   GetSessionDataBuffer,
    1321                                   &GetSessionDataBufferSize
    1322                                   );
    1323     if (Status == EFI_BUFFER_TOO_SMALL) {
    1324        FreePool (GetSessionDataBuffer);
    1325        GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
    1326        if (GetSessionDataBuffer == NULL) {
    1327          Status = EFI_OUT_OF_RESOURCES;
    1328          return Status;
    1329        }
    1330 
    1331        Status = HttpInstance->Tls->GetSessionData (
    1332                                      HttpInstance->Tls,
    1333                                      EfiTlsSessionState,
    1334                                      GetSessionDataBuffer,
    1335                                      &GetSessionDataBufferSize
    1336                                      );
    1337     }
    1338     if (EFI_ERROR (Status)) {
    1339       FreePool(GetSessionDataBuffer);
    1340       return Status;
    1341     }
    1342 
    1343     ASSERT(GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
    1344     HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *) GetSessionDataBuffer;
    1345 
    1346     FreePool (GetSessionDataBuffer);
    1347 
    1348     if(HttpInstance->TlsSessionState == EfiTlsSessionError) {
    1349       return EFI_ABORTED;
    1350     }
    1351   }
    1352 
    1353   if (HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring) {
    1354     Status = EFI_ABORTED;
    1355   }
    1356 
    1357   return Status;
    1358 }
    1359 
    1360 /**
    1361   Close the TLS session and send out the close notification message.
    1362 
    1363   @param[in]  HttpInstance       The HTTP instance private data.
    1364 
    1365   @retval EFI_SUCCESS            The TLS session is closed.
    1366   @retval EFI_INVALID_PARAMETER  HttpInstance is NULL.
    1367   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
    1368   @retval Others                 Other error as indicated.
    1369 
    1370 **/
    1371 EFI_STATUS
    1372 EFIAPI
    1373 TlsCloseSession (
    1374   IN  HTTP_PROTOCOL            *HttpInstance
    1375   )
    1376 {
    1377   EFI_STATUS      Status;
    1378 
    1379   UINT8           *BufferOut;
    1380   UINTN           BufferOutSize;
    1381 
    1382   NET_BUF         *PacketOut;
    1383   UINT8           *DataOut;
    1384 
    1385   Status    = EFI_SUCCESS;
    1386   BufferOut = NULL;
    1387   PacketOut = NULL;
    1388   DataOut   = NULL;
    1389 
    1390   if (HttpInstance == NULL) {
    1391     return EFI_INVALID_PARAMETER;
    1392   }
    1393 
    1394   HttpInstance->TlsSessionState = EfiTlsSessionClosing;
    1395 
    1396   Status = HttpInstance->Tls->SetSessionData (
    1397                                 HttpInstance->Tls,
    1398                                 EfiTlsSessionState,
    1399                                 &(HttpInstance->TlsSessionState),
    1400                                 sizeof (EFI_TLS_SESSION_STATE)
    1401                                 );
    1402   if (EFI_ERROR (Status)) {
    1403     return Status;
    1404   }
    1405 
    1406   BufferOutSize = DEF_BUF_LEN;
    1407   BufferOut = AllocateZeroPool (BufferOutSize);
    1408   if (BufferOut == NULL) {
    1409     Status = EFI_OUT_OF_RESOURCES;
    1410     return Status;
    1411   }
    1412 
    1413   Status = HttpInstance->Tls->BuildResponsePacket (
    1414                                 HttpInstance->Tls,
    1415                                 NULL,
    1416                                 0,
    1417                                 BufferOut,
    1418                                 &BufferOutSize
    1419                                 );
    1420   if (Status == EFI_BUFFER_TOO_SMALL) {
    1421     FreePool (BufferOut);
    1422     BufferOut = AllocateZeroPool (BufferOutSize);
    1423     if (BufferOut == NULL) {
    1424       Status = EFI_OUT_OF_RESOURCES;
    1425       return Status;
    1426     }
    1427 
    1428     Status = HttpInstance->Tls->BuildResponsePacket (
    1429                                   HttpInstance->Tls,
    1430                                   NULL,
    1431                                   0,
    1432                                   BufferOut,
    1433                                   &BufferOutSize
    1434                                   );
    1435   }
    1436 
    1437   if (EFI_ERROR (Status)) {
    1438     FreePool (BufferOut);
    1439     return Status;
    1440   }
    1441 
    1442   PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
    1443   DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
    1444   if (DataOut == NULL) {
    1445     FreePool (BufferOut);
    1446     return EFI_OUT_OF_RESOURCES;
    1447   }
    1448 
    1449   CopyMem (DataOut, BufferOut, BufferOutSize);
    1450 
    1451   Status = TlsCommonTransmit (HttpInstance, PacketOut);
    1452 
    1453   FreePool (BufferOut);
    1454   NetbufFree (PacketOut);
    1455 
    1456   return Status;
    1457 }
    1458 
    1459 /**
    1460   Process one message according to the CryptMode.
    1461 
    1462   @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
    1463   @param[in]           Message         Pointer to the message buffer needed to processed.
    1464                                        If ProcessMode is EfiTlsEncrypt, the message contain the TLS
    1465                                        header and plain text TLS APP payload.
    1466                                        If ProcessMode is EfiTlsDecrypt, the message contain the TLS
    1467                                        header and cipher text TLS APP payload.
    1468   @param[in]           MessageSize     Pointer to the message buffer size.
    1469   @param[in]           ProcessMode     Process mode.
    1470   @param[in, out]      Fragment        Only one Fragment returned after the Message is
    1471                                        processed successfully.
    1472                                        If ProcessMode is EfiTlsEncrypt, the fragment contain the TLS
    1473                                        header and cipher text TLS APP payload.
    1474                                        If ProcessMode is EfiTlsDecrypt, the fragment contain the TLS
    1475                                        header and plain text TLS APP payload.
    1476 
    1477   @retval EFI_SUCCESS          Message is processed successfully.
    1478   @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
    1479   @retval Others               Other errors as indicated.
    1480 
    1481 **/
    1482 EFI_STATUS
    1483 EFIAPI
    1484 TlsProcessMessage (
    1485   IN     HTTP_PROTOCOL            *HttpInstance,
    1486   IN     UINT8                    *Message,
    1487   IN     UINTN                    MessageSize,
    1488   IN     EFI_TLS_CRYPT_MODE       ProcessMode,
    1489   IN OUT NET_FRAGMENT             *Fragment
    1490   )
    1491 {
    1492   EFI_STATUS                      Status;
    1493   UINT8                           *Buffer;
    1494   UINT32                          BufferSize;
    1495   UINT32                          BytesCopied;
    1496   EFI_TLS_FRAGMENT_DATA           *FragmentTable;
    1497   UINT32                          FragmentCount;
    1498   EFI_TLS_FRAGMENT_DATA           *OriginalFragmentTable;
    1499   UINTN                           Index;
    1500 
    1501   Status                   = EFI_SUCCESS;
    1502   Buffer                   = NULL;
    1503   BufferSize               = 0;
    1504   BytesCopied              = 0;
    1505   FragmentTable            = NULL;
    1506   OriginalFragmentTable    = NULL;
    1507 
    1508   //
    1509   // Rebuild fragment table from BufferIn.
    1510   //
    1511   FragmentCount = 1;
    1512   FragmentTable = AllocateZeroPool (FragmentCount * sizeof (EFI_TLS_FRAGMENT_DATA));
    1513   if (FragmentTable == NULL) {
    1514     Status = EFI_OUT_OF_RESOURCES;
    1515     goto ON_EXIT;
    1516   }
    1517 
    1518   FragmentTable->FragmentLength = (UINT32) MessageSize;
    1519   FragmentTable->FragmentBuffer = Message;
    1520 
    1521   //
    1522   // Record the original FragmentTable.
    1523   //
    1524   OriginalFragmentTable = FragmentTable;
    1525 
    1526   //
    1527   // Process the Message.
    1528   //
    1529   Status = HttpInstance->Tls->ProcessPacket (
    1530                                 HttpInstance->Tls,
    1531                                 &FragmentTable,
    1532                                 &FragmentCount,
    1533                                 ProcessMode
    1534                                 );
    1535   if (EFI_ERROR (Status)) {
    1536     goto ON_EXIT;
    1537   }
    1538 
    1539   //
    1540   // Calculate the size according to FragmentTable.
    1541   //
    1542   for (Index = 0; Index < FragmentCount; Index++) {
    1543     BufferSize += FragmentTable[Index].FragmentLength;
    1544   }
    1545 
    1546   //
    1547   // Allocate buffer for processed data.
    1548   //
    1549   Buffer = AllocateZeroPool (BufferSize);
    1550   if (Buffer == NULL) {
    1551     Status = EFI_OUT_OF_RESOURCES;
    1552     goto ON_EXIT;
    1553   }
    1554 
    1555   //
    1556   // Copy the new FragmentTable buffer into Buffer.
    1557   //
    1558   for (Index = 0; Index < FragmentCount; Index++) {
    1559     CopyMem (
    1560       (Buffer + BytesCopied),
    1561       FragmentTable[Index].FragmentBuffer,
    1562       FragmentTable[Index].FragmentLength
    1563       );
    1564     BytesCopied += FragmentTable[Index].FragmentLength;
    1565 
    1566     //
    1567     // Free the FragmentBuffer since it has been copied.
    1568     //
    1569     FreePool (FragmentTable[Index].FragmentBuffer);
    1570   }
    1571 
    1572   Fragment->Len  = BufferSize;
    1573   Fragment->Bulk = Buffer;
    1574 
    1575 ON_EXIT:
    1576 
    1577   if (OriginalFragmentTable != NULL) {
    1578     if( FragmentTable == OriginalFragmentTable) {
    1579       FragmentTable = NULL;
    1580     }
    1581     FreePool (OriginalFragmentTable);
    1582     OriginalFragmentTable = NULL;
    1583   }
    1584 
    1585   //
    1586   // Caller has the responsibility to free the FragmentTable.
    1587   //
    1588   if (FragmentTable != NULL) {
    1589     FreePool (FragmentTable);
    1590     FragmentTable = NULL;
    1591   }
    1592 
    1593   return Status;
    1594 }
    1595 
    1596 /**
    1597   Receive one fragment decrypted from one TLS record.
    1598 
    1599   @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
    1600   @param[in, out]      Fragment        The received Fragment.
    1601   @param[in]           Timeout         The time to wait for connection done.
    1602 
    1603   @retval EFI_SUCCESS          One fragment is received.
    1604   @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources.
    1605   @retval EFI_ABORTED          Something wrong decryption the message.
    1606   @retval Others               Other errors as indicated.
    1607 
    1608 **/
    1609 EFI_STATUS
    1610 EFIAPI
    1611 HttpsReceive (
    1612   IN     HTTP_PROTOCOL         *HttpInstance,
    1613   IN OUT NET_FRAGMENT          *Fragment,
    1614   IN     EFI_EVENT             Timeout
    1615   )
    1616 {
    1617   EFI_STATUS                      Status;
    1618   NET_BUF                         *Pdu;
    1619   TLS_RECORD_HEADER               RecordHeader;
    1620   UINT8                           *BufferIn;
    1621   UINTN                           BufferInSize;
    1622   NET_FRAGMENT                    TempFragment;
    1623   UINT8                           *BufferOut;
    1624   UINTN                           BufferOutSize;
    1625   NET_BUF                         *PacketOut;
    1626   UINT8                           *DataOut;
    1627   UINT8                           *GetSessionDataBuffer;
    1628   UINTN                           GetSessionDataBufferSize;
    1629 
    1630   Status                   = EFI_SUCCESS;
    1631   Pdu                      = NULL;
    1632   BufferIn                 = NULL;
    1633   BufferInSize             = 0;
    1634   BufferOut                = NULL;
    1635   BufferOutSize            = 0;
    1636   PacketOut                = NULL;
    1637   DataOut                  = NULL;
    1638   GetSessionDataBuffer     = NULL;
    1639   GetSessionDataBufferSize = 0;
    1640 
    1641   //
    1642   // Receive only one TLS record
    1643   //
    1644   Status = TlsReceiveOnePdu (HttpInstance, &Pdu, Timeout);
    1645   if (EFI_ERROR (Status)) {
    1646     return Status;
    1647   }
    1648 
    1649   BufferInSize = Pdu->TotalSize;
    1650   BufferIn = AllocateZeroPool (BufferInSize);
    1651   if (BufferIn == NULL) {
    1652     Status = EFI_OUT_OF_RESOURCES;
    1653     NetbufFree (Pdu);
    1654     return Status;
    1655   }
    1656 
    1657   NetbufCopy (Pdu, 0, (UINT32) BufferInSize, BufferIn);
    1658 
    1659   NetbufFree (Pdu);
    1660 
    1661   //
    1662   // Handle Receive data.
    1663   //
    1664   RecordHeader = *(TLS_RECORD_HEADER *) BufferIn;
    1665 
    1666   if ((RecordHeader.ContentType == TlsContentTypeApplicationData) &&
    1667     (RecordHeader.Version.Major == 0x03) &&
    1668     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
    1669     RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR ||
    1670     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
    1671   ) {
    1672     //
    1673     // Decrypt Packet.
    1674     //
    1675     Status = TlsProcessMessage (
    1676                HttpInstance,
    1677                BufferIn,
    1678                BufferInSize,
    1679                EfiTlsDecrypt,
    1680                &TempFragment
    1681                );
    1682 
    1683     FreePool (BufferIn);
    1684 
    1685     if (EFI_ERROR (Status)) {
    1686       if (Status == EFI_ABORTED) {
    1687         //
    1688         // Something wrong decryption the message.
    1689         // BuildResponsePacket() will be called to generate Error Alert message and send it out.
    1690         //
    1691         BufferOutSize = DEF_BUF_LEN;
    1692         BufferOut = AllocateZeroPool (BufferOutSize);
    1693         if (BufferOut == NULL) {
    1694           Status = EFI_OUT_OF_RESOURCES;
    1695           return Status;
    1696         }
    1697 
    1698         Status = HttpInstance->Tls->BuildResponsePacket (
    1699                                       HttpInstance->Tls,
    1700                                       NULL,
    1701                                       0,
    1702                                       BufferOut,
    1703                                       &BufferOutSize
    1704                                       );
    1705         if (Status == EFI_BUFFER_TOO_SMALL) {
    1706           FreePool (BufferOut);
    1707           BufferOut = AllocateZeroPool (BufferOutSize);
    1708           if (BufferOut == NULL) {
    1709             Status = EFI_OUT_OF_RESOURCES;
    1710             return Status;
    1711           }
    1712 
    1713           Status = HttpInstance->Tls->BuildResponsePacket (
    1714                                         HttpInstance->Tls,
    1715                                         NULL,
    1716                                         0,
    1717                                         BufferOut,
    1718                                         &BufferOutSize
    1719                                         );
    1720         }
    1721         if (EFI_ERROR (Status)) {
    1722           FreePool(BufferOut);
    1723           return Status;
    1724         }
    1725 
    1726         if (BufferOutSize != 0) {
    1727           PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
    1728           DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
    1729           if (DataOut == NULL) {
    1730             FreePool (BufferOut);
    1731             return EFI_OUT_OF_RESOURCES;
    1732           }
    1733 
    1734           CopyMem (DataOut, BufferOut, BufferOutSize);
    1735 
    1736           Status = TlsCommonTransmit (HttpInstance, PacketOut);
    1737 
    1738           NetbufFree (PacketOut);
    1739         }
    1740 
    1741         FreePool(BufferOut);
    1742 
    1743         if (EFI_ERROR (Status)) {
    1744           return Status;
    1745         }
    1746 
    1747         return EFI_ABORTED;
    1748       }
    1749 
    1750       return Status;
    1751     }
    1752 
    1753     //
    1754     // Parsing buffer.
    1755     //
    1756     ASSERT (((TLS_RECORD_HEADER *) (TempFragment.Bulk))->ContentType == TlsContentTypeApplicationData);
    1757 
    1758     BufferInSize = ((TLS_RECORD_HEADER *) (TempFragment.Bulk))->Length;
    1759     BufferIn = AllocateZeroPool (BufferInSize);
    1760     if (BufferIn == NULL) {
    1761       Status = EFI_OUT_OF_RESOURCES;
    1762       return Status;
    1763     }
    1764 
    1765     CopyMem (BufferIn, TempFragment.Bulk + TLS_RECORD_HEADER_LENGTH, BufferInSize);
    1766 
    1767     //
    1768     // Free the buffer in TempFragment.
    1769     //
    1770     FreePool (TempFragment.Bulk);
    1771 
    1772   } else if ((RecordHeader.ContentType == TlsContentTypeAlert) &&
    1773     (RecordHeader.Version.Major == 0x03) &&
    1774     (RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR ||
    1775     RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR ||
    1776     RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR)
    1777     ) {
    1778     BufferOutSize = DEF_BUF_LEN;
    1779     BufferOut = AllocateZeroPool (BufferOutSize);
    1780     if (BufferOut == NULL) {
    1781       FreePool (BufferIn);
    17821273      Status = EFI_OUT_OF_RESOURCES;
    17831274      return Status;
    … …  
    18171308
    18181309    if (BufferOutSize != 0) {
    1819       PacketOut = NetbufAlloc ((UINT32) BufferOutSize);
    1820       DataOut = NetbufAllocSpace (PacketOut, (UINT32) BufferOutSize, NET_BUF_TAIL);
     1310      //
     1311      // Transmit the response packet.
     1312      //
     1313      PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
     1314      DataOut   = NetbufAllocSpace (PacketOut, (UINT32)BufferOutSize, NET_BUF_TAIL);
    18211315      if (DataOut == NULL) {
    18221316        FreePool (BufferOut);
    … …  
    18291323
    18301324      NetbufFree (PacketOut);
     1325
     1326      if (EFI_ERROR (Status)) {
     1327        FreePool (BufferOut);
     1328        return Status;
     1329      }
    18311330    }
    18321331
    … …  
    18341333
    18351334    //
    1836     // Get the session state.
     1335    // Get the session state, then decide whether need to continue handle received packet.
    18371336    //
    18381337    GetSessionDataBufferSize = DEF_BUF_LEN;
    1839     GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
     1338    GetSessionDataBuffer     = AllocateZeroPool (GetSessionDataBufferSize);
    18401339    if (GetSessionDataBuffer == NULL) {
    18411340      Status = EFI_OUT_OF_RESOURCES;
    … …  
    18501349                                  );
    18511350    if (Status == EFI_BUFFER_TOO_SMALL) {
    1852        FreePool (GetSessionDataBuffer);
    1853        GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
    1854        if (GetSessionDataBuffer == NULL) {
    1855          Status = EFI_OUT_OF_RESOURCES;
    1856          return Status;
    1857        }
    1858 
    1859        Status = HttpInstance->Tls->GetSessionData (
    1860                                      HttpInstance->Tls,
    1861                                      EfiTlsSessionState,
    1862                                      GetSessionDataBuffer,
    1863                                      &GetSessionDataBufferSize
    1864                                      );
    1865     }
     1351      FreePool (GetSessionDataBuffer);
     1352      GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
     1353      if (GetSessionDataBuffer == NULL) {
     1354        Status = EFI_OUT_OF_RESOURCES;
     1355        return Status;
     1356      }
     1357
     1358      Status = HttpInstance->Tls->GetSessionData (
     1359                                    HttpInstance->Tls,
     1360                                    EfiTlsSessionState,
     1361                                    GetSessionDataBuffer,
     1362                                    &GetSessionDataBufferSize
     1363                                    );
     1364    }
     1365
    18661366    if (EFI_ERROR (Status)) {
    18671367      FreePool (GetSessionDataBuffer);
    … …  
    18691369    }
    18701370
    1871     ASSERT(GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
    1872     HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *) GetSessionDataBuffer;
     1371    ASSERT (GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
     1372    HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *)GetSessionDataBuffer;
    18731373
    18741374    FreePool (GetSessionDataBuffer);
    18751375
    1876     if(HttpInstance->TlsSessionState == EfiTlsSessionError) {
    1877       DEBUG ((EFI_D_ERROR, "TLS Session State Error!\n"));
     1376    if (HttpInstance->TlsSessionState == EfiTlsSessionError) {
    18781377      return EFI_ABORTED;
    18791378    }
    1880 
    1881     BufferIn = NULL;
    1882     BufferInSize = 0;
    1883   }
    1884 
    1885   Fragment->Bulk = BufferIn;
    1886   Fragment->Len = (UINT32) BufferInSize;
     1379  }
     1380
     1381  if (HttpInstance->TlsSessionState != EfiTlsSessionDataTransferring) {
     1382    Status = EFI_ABORTED;
     1383  }
    18871384
    18881385  return Status;
    18891386}
    18901387
     1388/**
     1389  Close the TLS session and send out the close notification message.
     1390
     1391  @param[in]  HttpInstance       The HTTP instance private data.
     1392
     1393  @retval EFI_SUCCESS            The TLS session is closed.
     1394  @retval EFI_INVALID_PARAMETER  HttpInstance is NULL.
     1395  @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
     1396  @retval Others                 Other error as indicated.
     1397
     1398**/
     1399EFI_STATUS
     1400EFIAPI
     1401TlsCloseSession (
     1402  IN  HTTP_PROTOCOL  *HttpInstance
     1403  )
     1404{
     1405  EFI_STATUS  Status;
     1406
     1407  UINT8  *BufferOut;
     1408  UINTN  BufferOutSize;
     1409
     1410  NET_BUF  *PacketOut;
     1411  UINT8    *DataOut;
     1412
     1413  Status    = EFI_SUCCESS;
     1414  BufferOut = NULL;
     1415  PacketOut = NULL;
     1416  DataOut   = NULL;
     1417
     1418  if (HttpInstance == NULL) {
     1419    return EFI_INVALID_PARAMETER;
     1420  }
     1421
     1422  HttpInstance->TlsSessionState = EfiTlsSessionClosing;
     1423
     1424  Status = HttpInstance->Tls->SetSessionData (
     1425                                HttpInstance->Tls,
     1426                                EfiTlsSessionState,
     1427                                &(HttpInstance->TlsSessionState),
     1428                                sizeof (EFI_TLS_SESSION_STATE)
     1429                                );
     1430  if (EFI_ERROR (Status)) {
     1431    return Status;
     1432  }
     1433
     1434  BufferOutSize = DEF_BUF_LEN;
     1435  BufferOut     = AllocateZeroPool (BufferOutSize);
     1436  if (BufferOut == NULL) {
     1437    Status = EFI_OUT_OF_RESOURCES;
     1438    return Status;
     1439  }
     1440
     1441  Status = HttpInstance->Tls->BuildResponsePacket (
     1442                                HttpInstance->Tls,
     1443                                NULL,
     1444                                0,
     1445                                BufferOut,
     1446                                &BufferOutSize
     1447                                );
     1448  if (Status == EFI_BUFFER_TOO_SMALL) {
     1449    FreePool (BufferOut);
     1450    BufferOut = AllocateZeroPool (BufferOutSize);
     1451    if (BufferOut == NULL) {
     1452      Status = EFI_OUT_OF_RESOURCES;
     1453      return Status;
     1454    }
     1455
     1456    Status = HttpInstance->Tls->BuildResponsePacket (
     1457                                  HttpInstance->Tls,
     1458                                  NULL,
     1459                                  0,
     1460                                  BufferOut,
     1461                                  &BufferOutSize
     1462                                  );
     1463  }
     1464
     1465  if (EFI_ERROR (Status)) {
     1466    FreePool (BufferOut);
     1467    return Status;
     1468  }
     1469
     1470  PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
     1471  DataOut   = NetbufAllocSpace (PacketOut, (UINT32)BufferOutSize, NET_BUF_TAIL);
     1472  if (DataOut == NULL) {
     1473    FreePool (BufferOut);
     1474    return EFI_OUT_OF_RESOURCES;
     1475  }
     1476
     1477  CopyMem (DataOut, BufferOut, BufferOutSize);
     1478
     1479  Status = TlsCommonTransmit (HttpInstance, PacketOut);
     1480
     1481  FreePool (BufferOut);
     1482  NetbufFree (PacketOut);
     1483
     1484  return Status;
     1485}
     1486
     1487/**
     1488  Process one message according to the CryptMode.
     1489
     1490  @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
     1491  @param[in]           Message         Pointer to the message buffer needed to processed.
     1492                                       If ProcessMode is EfiTlsEncrypt, the message contain the TLS
     1493                                       header and plain text TLS APP payload.
     1494                                       If ProcessMode is EfiTlsDecrypt, the message contain the TLS
     1495                                       header and cipher text TLS APP payload.
     1496  @param[in]           MessageSize     Pointer to the message buffer size.
     1497  @param[in]           ProcessMode     Process mode.
     1498  @param[in, out]      Fragment        Only one Fragment returned after the Message is
     1499                                       processed successfully.
     1500                                       If ProcessMode is EfiTlsEncrypt, the fragment contain the TLS
     1501                                       header and cipher text TLS APP payload.
     1502                                       If ProcessMode is EfiTlsDecrypt, the fragment contain the TLS
     1503                                       header and plain text TLS APP payload.
     1504
     1505  @retval EFI_SUCCESS          Message is processed successfully.
     1506  @retval EFI_OUT_OF_RESOURCES   Can't allocate memory resources.
     1507  @retval Others               Other errors as indicated.
     1508
     1509**/
     1510EFI_STATUS
     1511EFIAPI
     1512TlsProcessMessage (
     1513  IN     HTTP_PROTOCOL       *HttpInstance,
     1514  IN     UINT8               *Message,
     1515  IN     UINTN               MessageSize,
     1516  IN     EFI_TLS_CRYPT_MODE  ProcessMode,
     1517  IN OUT NET_FRAGMENT        *Fragment
     1518  )
     1519{
     1520  EFI_STATUS             Status;
     1521  UINT8                  *Buffer;
     1522  UINT32                 BufferSize;
     1523  UINT32                 BytesCopied;
     1524  EFI_TLS_FRAGMENT_DATA  *FragmentTable;
     1525  UINT32                 FragmentCount;
     1526  EFI_TLS_FRAGMENT_DATA  *OriginalFragmentTable;
     1527  UINTN                  Index;
     1528
     1529  Status                = EFI_SUCCESS;
     1530  Buffer                = NULL;
     1531  BufferSize            = 0;
     1532  BytesCopied           = 0;
     1533  FragmentTable         = NULL;
     1534  OriginalFragmentTable = NULL;
     1535
     1536  //
     1537  // Rebuild fragment table from BufferIn.
     1538  //
     1539  FragmentCount = 1;
     1540  FragmentTable = AllocateZeroPool (FragmentCount * sizeof (EFI_TLS_FRAGMENT_DATA));
     1541  if (FragmentTable == NULL) {
     1542    Status = EFI_OUT_OF_RESOURCES;
     1543    goto ON_EXIT;
     1544  }
     1545
     1546  FragmentTable->FragmentLength = (UINT32)MessageSize;
     1547  FragmentTable->FragmentBuffer = Message;
     1548
     1549  //
     1550  // Record the original FragmentTable.
     1551  //
     1552  OriginalFragmentTable = FragmentTable;
     1553
     1554  //
     1555  // Process the Message.
     1556  //
     1557  Status = HttpInstance->Tls->ProcessPacket (
     1558                                HttpInstance->Tls,
     1559                                &FragmentTable,
     1560                                &FragmentCount,
     1561                                ProcessMode
     1562                                );
     1563  if (EFI_ERROR (Status)) {
     1564    goto ON_EXIT;
     1565  }
     1566
     1567  //
     1568  // Calculate the size according to FragmentTable.
     1569  //
     1570  for (Index = 0; Index < FragmentCount; Index++) {
     1571    BufferSize += FragmentTable[Index].FragmentLength;
     1572  }
     1573
     1574  //
     1575  // Allocate buffer for processed data.
     1576  //
     1577  Buffer = AllocateZeroPool (BufferSize);
     1578  if (Buffer == NULL) {
     1579    Status = EFI_OUT_OF_RESOURCES;
     1580    goto ON_EXIT;
     1581  }
     1582
     1583  //
     1584  // Copy the new FragmentTable buffer into Buffer.
     1585  //
     1586  for (Index = 0; Index < FragmentCount; Index++) {
     1587    CopyMem (
     1588      (Buffer + BytesCopied),
     1589      FragmentTable[Index].FragmentBuffer,
     1590      FragmentTable[Index].FragmentLength
     1591      );
     1592    BytesCopied += FragmentTable[Index].FragmentLength;
     1593
     1594    //
     1595    // Free the FragmentBuffer since it has been copied.
     1596    //
     1597    FreePool (FragmentTable[Index].FragmentBuffer);
     1598  }
     1599
     1600  Fragment->Len  = BufferSize;
     1601  Fragment->Bulk = Buffer;
     1602
     1603ON_EXIT:
     1604
     1605  if (OriginalFragmentTable != NULL) {
     1606    if ( FragmentTable == OriginalFragmentTable) {
     1607      FragmentTable = NULL;
     1608    }
     1609
     1610    FreePool (OriginalFragmentTable);
     1611    OriginalFragmentTable = NULL;
     1612  }
     1613
     1614  //
     1615  // Caller has the responsibility to free the FragmentTable.
     1616  //
     1617  if (FragmentTable != NULL) {
     1618    FreePool (FragmentTable);
     1619    FragmentTable = NULL;
     1620  }
     1621
     1622  return Status;
     1623}
     1624
     1625/**
     1626  Receive one fragment decrypted from one TLS record.
     1627
     1628  @param[in]           HttpInstance    Pointer to HTTP_PROTOCOL structure.
     1629  @param[in, out]      Fragment        The received Fragment.
     1630  @param[in]           Timeout         The time to wait for connection done.
     1631
     1632  @retval EFI_SUCCESS          One fragment is received.
     1633  @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources.
     1634  @retval EFI_ABORTED          Something wrong decryption the message.
     1635  @retval Others               Other errors as indicated.
     1636
     1637**/
     1638EFI_STATUS
     1639EFIAPI
     1640HttpsReceive (
     1641  IN     HTTP_PROTOCOL  *HttpInstance,
     1642  IN OUT NET_FRAGMENT   *Fragment,
     1643  IN     EFI_EVENT      Timeout
     1644  )
     1645{
     1646  EFI_STATUS         Status;
     1647  NET_BUF            *Pdu;
     1648  TLS_RECORD_HEADER  RecordHeader;
     1649  UINT8              *BufferIn;
     1650  UINTN              BufferInSize;
     1651  NET_FRAGMENT       TempFragment;
     1652  UINT8              *BufferOut;
     1653  UINTN              BufferOutSize;
     1654  NET_BUF            *PacketOut;
     1655  UINT8              *DataOut;
     1656  UINT8              *GetSessionDataBuffer;
     1657  UINTN              GetSessionDataBufferSize;
     1658
     1659  Status                   = EFI_SUCCESS;
     1660  Pdu                      = NULL;
     1661  BufferIn                 = NULL;
     1662  BufferInSize             = 0;
     1663  BufferOut                = NULL;
     1664  BufferOutSize            = 0;
     1665  PacketOut                = NULL;
     1666  DataOut                  = NULL;
     1667  GetSessionDataBuffer     = NULL;
     1668  GetSessionDataBufferSize = 0;
     1669
     1670  //
     1671  // Receive only one TLS record
     1672  //
     1673  Status = TlsReceiveOnePdu (HttpInstance, &Pdu, Timeout);
     1674  if (EFI_ERROR (Status)) {
     1675    return Status;
     1676  }
     1677
     1678  BufferInSize = Pdu->TotalSize;
     1679  BufferIn     = AllocateZeroPool (BufferInSize);
     1680  if (BufferIn == NULL) {
     1681    Status = EFI_OUT_OF_RESOURCES;
     1682    NetbufFree (Pdu);
     1683    return Status;
     1684  }
     1685
     1686  NetbufCopy (Pdu, 0, (UINT32)BufferInSize, BufferIn);
     1687
     1688  NetbufFree (Pdu);
     1689
     1690  //
     1691  // Handle Receive data.
     1692  //
     1693  RecordHeader = *(TLS_RECORD_HEADER *)BufferIn;
     1694
     1695  if ((RecordHeader.ContentType == TlsContentTypeApplicationData) &&
     1696      (RecordHeader.Version.Major == 0x03) &&
     1697      ((RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR) ||
     1698       (RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR) ||
     1699       (RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR))
     1700      )
     1701  {
     1702    //
     1703    // Decrypt Packet.
     1704    //
     1705    Status = TlsProcessMessage (
     1706               HttpInstance,
     1707               BufferIn,
     1708               BufferInSize,
     1709               EfiTlsDecrypt,
     1710               &TempFragment
     1711               );
     1712
     1713    FreePool (BufferIn);
     1714
     1715    if (EFI_ERROR (Status)) {
     1716      if (Status == EFI_ABORTED) {
     1717        //
     1718        // Something wrong decryption the message.
     1719        // BuildResponsePacket() will be called to generate Error Alert message and send it out.
     1720        //
     1721        BufferOutSize = DEF_BUF_LEN;
     1722        BufferOut     = AllocateZeroPool (BufferOutSize);
     1723        if (BufferOut == NULL) {
     1724          Status = EFI_OUT_OF_RESOURCES;
     1725          return Status;
     1726        }
     1727
     1728        Status = HttpInstance->Tls->BuildResponsePacket (
     1729                                      HttpInstance->Tls,
     1730                                      NULL,
     1731                                      0,
     1732                                      BufferOut,
     1733                                      &BufferOutSize
     1734                                      );
     1735        if (Status == EFI_BUFFER_TOO_SMALL) {
     1736          FreePool (BufferOut);
     1737          BufferOut = AllocateZeroPool (BufferOutSize);
     1738          if (BufferOut == NULL) {
     1739            Status = EFI_OUT_OF_RESOURCES;
     1740            return Status;
     1741          }
     1742
     1743          Status = HttpInstance->Tls->BuildResponsePacket (
     1744                                        HttpInstance->Tls,
     1745                                        NULL,
     1746                                        0,
     1747                                        BufferOut,
     1748                                        &BufferOutSize
     1749                                        );
     1750        }
     1751
     1752        if (EFI_ERROR (Status)) {
     1753          FreePool (BufferOut);
     1754          return Status;
     1755        }
     1756
     1757        if (BufferOutSize != 0) {
     1758          PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
     1759          DataOut   = NetbufAllocSpace (PacketOut, (UINT32)BufferOutSize, NET_BUF_TAIL);
     1760          if (DataOut == NULL) {
     1761            FreePool (BufferOut);
     1762            return EFI_OUT_OF_RESOURCES;
     1763          }
     1764
     1765          CopyMem (DataOut, BufferOut, BufferOutSize);
     1766
     1767          Status = TlsCommonTransmit (HttpInstance, PacketOut);
     1768
     1769          NetbufFree (PacketOut);
     1770        }
     1771
     1772        FreePool (BufferOut);
     1773
     1774        if (EFI_ERROR (Status)) {
     1775          return Status;
     1776        }
     1777
     1778        return EFI_ABORTED;
     1779      }
     1780
     1781      return Status;
     1782    }
     1783
     1784    //
     1785    // Parsing buffer.
     1786    //
     1787    ASSERT (((TLS_RECORD_HEADER *)(TempFragment.Bulk))->ContentType == TlsContentTypeApplicationData);
     1788
     1789    BufferInSize = ((TLS_RECORD_HEADER *)(TempFragment.Bulk))->Length;
     1790    BufferIn     = AllocateZeroPool (BufferInSize);
     1791    if (BufferIn == NULL) {
     1792      Status = EFI_OUT_OF_RESOURCES;
     1793      return Status;
     1794    }
     1795
     1796    CopyMem (BufferIn, TempFragment.Bulk + TLS_RECORD_HEADER_LENGTH, BufferInSize);
     1797
     1798    //
     1799    // Free the buffer in TempFragment.
     1800    //
     1801    FreePool (TempFragment.Bulk);
     1802  } else if ((RecordHeader.ContentType == TlsContentTypeAlert) &&
     1803             (RecordHeader.Version.Major == 0x03) &&
     1804             ((RecordHeader.Version.Minor == TLS10_PROTOCOL_VERSION_MINOR) ||
     1805              (RecordHeader.Version.Minor == TLS11_PROTOCOL_VERSION_MINOR) ||
     1806              (RecordHeader.Version.Minor == TLS12_PROTOCOL_VERSION_MINOR))
     1807             )
     1808  {
     1809    BufferOutSize = DEF_BUF_LEN;
     1810    BufferOut     = AllocateZeroPool (BufferOutSize);
     1811    if (BufferOut == NULL) {
     1812      FreePool (BufferIn);
     1813      Status = EFI_OUT_OF_RESOURCES;
     1814      return Status;
     1815    }
     1816
     1817    Status = HttpInstance->Tls->BuildResponsePacket (
     1818                                  HttpInstance->Tls,
     1819                                  BufferIn,
     1820                                  BufferInSize,
     1821                                  BufferOut,
     1822                                  &BufferOutSize
     1823                                  );
     1824    if (Status == EFI_BUFFER_TOO_SMALL) {
     1825      FreePool (BufferOut);
     1826      BufferOut = AllocateZeroPool (BufferOutSize);
     1827      if (BufferOut == NULL) {
     1828        FreePool (BufferIn);
     1829        Status = EFI_OUT_OF_RESOURCES;
     1830        return Status;
     1831      }
     1832
     1833      Status = HttpInstance->Tls->BuildResponsePacket (
     1834                                    HttpInstance->Tls,
     1835                                    BufferIn,
     1836                                    BufferInSize,
     1837                                    BufferOut,
     1838                                    &BufferOutSize
     1839                                    );
     1840    }
     1841
     1842    FreePool (BufferIn);
     1843
     1844    if (EFI_ERROR (Status)) {
     1845      FreePool (BufferOut);
     1846      return Status;
     1847    }
     1848
     1849    if (BufferOutSize != 0) {
     1850      PacketOut = NetbufAlloc ((UINT32)BufferOutSize);
     1851      DataOut   = NetbufAllocSpace (PacketOut, (UINT32)BufferOutSize, NET_BUF_TAIL);
     1852      if (DataOut == NULL) {
     1853        FreePool (BufferOut);
     1854        return EFI_OUT_OF_RESOURCES;
     1855      }
     1856
     1857      CopyMem (DataOut, BufferOut, BufferOutSize);
     1858
     1859      Status = TlsCommonTransmit (HttpInstance, PacketOut);
     1860
     1861      NetbufFree (PacketOut);
     1862    }
     1863
     1864    FreePool (BufferOut);
     1865
     1866    //
     1867    // Get the session state.
     1868    //
     1869    GetSessionDataBufferSize = DEF_BUF_LEN;
     1870    GetSessionDataBuffer     = AllocateZeroPool (GetSessionDataBufferSize);
     1871    if (GetSessionDataBuffer == NULL) {
     1872      Status = EFI_OUT_OF_RESOURCES;
     1873      return Status;
     1874    }
     1875
     1876    Status = HttpInstance->Tls->GetSessionData (
     1877                                  HttpInstance->Tls,
     1878                                  EfiTlsSessionState,
     1879                                  GetSessionDataBuffer,
     1880                                  &GetSessionDataBufferSize
     1881                                  );
     1882    if (Status == EFI_BUFFER_TOO_SMALL) {
     1883      FreePool (GetSessionDataBuffer);
     1884      GetSessionDataBuffer = AllocateZeroPool (GetSessionDataBufferSize);
     1885      if (GetSessionDataBuffer == NULL) {
     1886        Status = EFI_OUT_OF_RESOURCES;
     1887        return Status;
     1888      }
     1889
     1890      Status = HttpInstance->Tls->GetSessionData (
     1891                                    HttpInstance->Tls,
     1892                                    EfiTlsSessionState,
     1893                                    GetSessionDataBuffer,
     1894                                    &GetSessionDataBufferSize
     1895                                    );
     1896    }
     1897
     1898    if (EFI_ERROR (Status)) {
     1899      FreePool (GetSessionDataBuffer);
     1900      return Status;
     1901    }
     1902
     1903    ASSERT (GetSessionDataBufferSize == sizeof (EFI_TLS_SESSION_STATE));
     1904    HttpInstance->TlsSessionState = *(EFI_TLS_SESSION_STATE *)GetSessionDataBuffer;
     1905
     1906    FreePool (GetSessionDataBuffer);
     1907
     1908    if (HttpInstance->TlsSessionState == EfiTlsSessionError) {
     1909      DEBUG ((DEBUG_ERROR, "TLS Session State Error!\n"));
     1910      return EFI_ABORTED;
     1911    }
     1912
     1913    BufferIn     = NULL;
     1914    BufferInSize = 0;
     1915  }
     1916
     1917  Fragment->Bulk = BufferIn;
     1918  Fragment->Len  = (UINT32)BufferInSize;
     1919
     1920  return Status;
     1921}
Note: See TracChangeset for help on using the changeset viewer.

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