[mirror_edk2.git] / NetworkPkg / HttpDxe / HttpProto.c

/** @file\r
  Miscellaneous routines for HttpDxe driver.\r
\r
Copyright (c) 2015 - 2021, Intel Corporation. All rights reserved.<BR>\r
(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "HttpDriver.h"\r
\r
/**\r
  The common notify function used in HTTP driver.\r
\r
  @param[in]  Event   The event signaled.\r
  @param[in]  Context The context.\r
\r
**/\r
VOID\r
EFIAPI\r
HttpCommonNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  if ((Event == NULL) || (Context == NULL)) {\r
    return;\r
  }\r
\r
  *((BOOLEAN *)Context) = TRUE;\r
}\r
\r
/**\r
  The notify function associated with Tx4Token for Tcp4->Transmit() or Tx6Token for Tcp6->Transmit().\r
\r
  @param[in]  Context The context.\r
\r
**/\r
VOID\r
EFIAPI\r
HttpTcpTransmitNotifyDpc (\r
  IN VOID  *Context\r
  )\r
{\r
  HTTP_TOKEN_WRAP  *Wrap;\r
  HTTP_PROTOCOL    *HttpInstance;\r
\r
  if (Context == NULL) {\r
    return;\r
  }\r
\r
  Wrap         = (HTTP_TOKEN_WRAP *)Context;\r
  HttpInstance = Wrap->HttpInstance;\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    Wrap->HttpToken->Status = Wrap->TcpWrap.Tx4Token.CompletionToken.Status;\r
    gBS->SignalEvent (Wrap->HttpToken->Event);\r
\r
    //\r
    // Free resources.\r
    //\r
    if (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {\r
      FreePool (Wrap->TcpWrap.Tx4Token.Packet.TxData->FragmentTable[0].FragmentBuffer);\r
    }\r
\r
    if (Wrap->TcpWrap.Tx4Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Wrap->TcpWrap.Tx4Token.CompletionToken.Event);\r
    }\r
  } else {\r
    Wrap->HttpToken->Status = Wrap->TcpWrap.Tx6Token.CompletionToken.Status;\r
    gBS->SignalEvent (Wrap->HttpToken->Event);\r
\r
    //\r
    // Free resources.\r
    //\r
    if (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer != NULL) {\r
      FreePool (Wrap->TcpWrap.Tx6Token.Packet.TxData->FragmentTable[0].FragmentBuffer);\r
    }\r
\r
    if (Wrap->TcpWrap.Tx6Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Wrap->TcpWrap.Tx6Token.CompletionToken.Event);\r
    }\r
  }\r
\r
  Wrap->TcpWrap.IsTxDone = TRUE;\r
\r
  //\r
  // Check pending TxTokens and sent out.\r
  //\r
  NetMapIterate (&Wrap->HttpInstance->TxTokens, HttpTcpTransmit, NULL);\r
}\r
\r
/**\r
  Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK.\r
\r
  @param  Event                 The receive event delivered to TCP for transmit.\r
  @param  Context               Context for the callback.\r
\r
**/\r
VOID\r
EFIAPI\r
HttpTcpTransmitNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  //\r
  // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK\r
  //\r
  QueueDpc (TPL_CALLBACK, HttpTcpTransmitNotifyDpc, Context);\r
}\r
\r
/**\r
  The notify function associated with Rx4Token for Tcp4->Receive () or Rx6Token for Tcp6->Receive().\r
\r
  @param[in]  Context The context.\r
\r
**/\r
VOID\r
EFIAPI\r
HttpTcpReceiveNotifyDpc (\r
  IN VOID  *Context\r
  )\r
{\r
  HTTP_TOKEN_WRAP  *Wrap;\r
  NET_MAP_ITEM     *Item;\r
  UINTN            Length;\r
  EFI_STATUS       Status;\r
  HTTP_PROTOCOL    *HttpInstance;\r
  BOOLEAN          UsingIpv6;\r
\r
  if (Context == NULL) {\r
    return;\r
  }\r
\r
  Wrap         = (HTTP_TOKEN_WRAP *)Context;\r
  HttpInstance = Wrap->HttpInstance;\r
  UsingIpv6    = HttpInstance->LocalAddressIsIPv6;\r
\r
  if (UsingIpv6) {\r
    gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);\r
    Wrap->TcpWrap.Rx6Token.CompletionToken.Event = NULL;\r
\r
    if (EFI_ERROR (Wrap->TcpWrap.Rx6Token.CompletionToken.Status)) {\r
      DEBUG ((DEBUG_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx6Token.CompletionToken.Status));\r
      Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;\r
      gBS->SignalEvent (Wrap->HttpToken->Event);\r
\r
      Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);\r
      if (Item != NULL) {\r
        NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);\r
      }\r
\r
      FreePool (Wrap);\r
      Wrap = NULL;\r
\r
      return;\r
    }\r
  } else {\r
    gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);\r
    Wrap->TcpWrap.Rx4Token.CompletionToken.Event = NULL;\r
\r
    if (EFI_ERROR (Wrap->TcpWrap.Rx4Token.CompletionToken.Status)) {\r
      DEBUG ((DEBUG_ERROR, "HttpTcpReceiveNotifyDpc: %r!\n", Wrap->TcpWrap.Rx4Token.CompletionToken.Status));\r
      Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;\r
      gBS->SignalEvent (Wrap->HttpToken->Event);\r
\r
      Item = NetMapFindKey (&HttpInstance->RxTokens, Wrap->HttpToken);\r
      if (Item != NULL) {\r
        NetMapRemoveItem (&HttpInstance->RxTokens, Item, NULL);\r
      }\r
\r
      FreePool (Wrap);\r
      Wrap = NULL;\r
\r
      return;\r
    }\r
  }\r
\r
  //\r
  // Check whether we receive a complete HTTP message.\r
  //\r
  ASSERT (HttpInstance->MsgParser != NULL);\r
  if (UsingIpv6) {\r
    Length = (UINTN)Wrap->TcpWrap.Rx6Data.FragmentTable[0].FragmentLength;\r
  } else {\r
    Length = (UINTN)Wrap->TcpWrap.Rx4Data.FragmentTable[0].FragmentLength;\r
  }\r
\r
  //\r
  // Record the CallbackData data.\r
  //\r
  HttpInstance->CallbackData.Wrap            = (VOID *)Wrap;\r
  HttpInstance->CallbackData.ParseData       = Wrap->HttpToken->Message->Body;\r
  HttpInstance->CallbackData.ParseDataLength = Length;\r
\r
  //\r
  // Parse Body with CallbackData data.\r
  //\r
  Status = HttpParseMessageBody (\r
             HttpInstance->MsgParser,\r
             Length,\r
             Wrap->HttpToken->Message->Body\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return;\r
  }\r
\r
  if (HttpIsMessageComplete (HttpInstance->MsgParser)) {\r
    //\r
    // Free the MsgParse since we already have a full HTTP message.\r
    //\r
    HttpFreeMsgParser (HttpInstance->MsgParser);\r
    HttpInstance->MsgParser = NULL;\r
  }\r
\r
  Wrap->HttpToken->Message->BodyLength = Length;\r
  ASSERT (HttpInstance->CacheBody == NULL);\r
  //\r
  // We receive part of header of next HTTP msg.\r
  //\r
  if (HttpInstance->NextMsg != NULL) {\r
    Wrap->HttpToken->Message->BodyLength = HttpInstance->NextMsg -\r
                                           (CHAR8 *)Wrap->HttpToken->Message->Body;\r
    HttpInstance->CacheLen = Length - Wrap->HttpToken->Message->BodyLength;\r
    if (HttpInstance->CacheLen != 0) {\r
      HttpInstance->CacheBody = AllocateZeroPool (HttpInstance->CacheLen);\r
      if (HttpInstance->CacheBody == NULL) {\r
        return;\r
      }\r
\r
      CopyMem (HttpInstance->CacheBody, HttpInstance->NextMsg, HttpInstance->CacheLen);\r
      HttpInstance->NextMsg     = HttpInstance->CacheBody;\r
      HttpInstance->CacheOffset = 0;\r
    }\r
  }\r
\r
  Item = NetMapFindKey (&Wrap->HttpInstance->RxTokens, Wrap->HttpToken);\r
  if (Item != NULL) {\r
    NetMapRemoveItem (&Wrap->HttpInstance->RxTokens, Item, NULL);\r
  }\r
\r
  Wrap->TcpWrap.IsRxDone = TRUE;\r
  if (UsingIpv6) {\r
    Wrap->HttpToken->Status = Wrap->TcpWrap.Rx6Token.CompletionToken.Status;\r
  } else {\r
    Wrap->HttpToken->Status = Wrap->TcpWrap.Rx4Token.CompletionToken.Status;\r
  }\r
\r
  gBS->SignalEvent (Wrap->HttpToken->Event);\r
\r
  //\r
  // Check pending RxTokens and receive the HTTP message.\r
  //\r
  NetMapIterate (&Wrap->HttpInstance->RxTokens, HttpTcpReceive, NULL);\r
\r
  FreePool (Wrap);\r
  Wrap = NULL;\r
}\r
\r
/**\r
  Request HttpTcpReceiveNotifyDpc as a DPC at TPL_CALLBACK.\r
\r
  @param  Event                 The receive event delivered to TCP for receive.\r
  @param  Context               Context for the callback.\r
\r
**/\r
VOID\r
EFIAPI\r
HttpTcpReceiveNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  //\r
  // Request HttpTcpTransmitNotifyDpc as a DPC at TPL_CALLBACK\r
  //\r
  QueueDpc (TPL_CALLBACK, HttpTcpReceiveNotifyDpc, Context);\r
}\r
\r
/**\r
  Create events for the TCP connection token and TCP close token.\r
\r
  @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.\r
\r
  @retval EFI_SUCCESS            The events are created successfully.\r
  @retval others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCreateTcpConnCloseEvent (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    //\r
    // Create events for various asynchronous operations.\r
    //\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsTcp4ConnDone,\r
                    &HttpInstance->Tcp4ConnToken.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ERROR;\r
    }\r
\r
    //\r
    // Initialize Tcp4CloseToken\r
    //\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsTcp4CloseDone,\r
                    &HttpInstance->Tcp4CloseToken.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ERROR;\r
    }\r
  } else {\r
    //\r
    // Create events for various asynchronous operations.\r
    //\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsTcp6ConnDone,\r
                    &HttpInstance->Tcp6ConnToken.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ERROR;\r
    }\r
\r
    //\r
    // Initialize Tcp6CloseToken\r
    //\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsTcp6CloseDone,\r
                    &HttpInstance->Tcp6CloseToken.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ERROR;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ERROR:\r
  //\r
  // Error handling\r
  //\r
  HttpCloseTcpConnCloseEvent (HttpInstance);\r
\r
  return Status;\r
}\r
\r
/**\r
  Close events in the TCP connection token and TCP close token.\r
\r
  @param[in]  HttpInstance   Pointer to HTTP_PROTOCOL structure.\r
\r
**/\r
VOID\r
HttpCloseTcpConnCloseEvent (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  ASSERT (HttpInstance != NULL);\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    if (NULL != HttpInstance->Tcp6ConnToken.CompletionToken.Event) {\r
      gBS->CloseEvent (HttpInstance->Tcp6ConnToken.CompletionToken.Event);\r
      HttpInstance->Tcp6ConnToken.CompletionToken.Event = NULL;\r
    }\r
\r
    if (NULL != HttpInstance->Tcp6CloseToken.CompletionToken.Event) {\r
      gBS->CloseEvent (HttpInstance->Tcp6CloseToken.CompletionToken.Event);\r
      HttpInstance->Tcp6CloseToken.CompletionToken.Event = NULL;\r
    }\r
  } else {\r
    if (NULL != HttpInstance->Tcp4ConnToken.CompletionToken.Event) {\r
      gBS->CloseEvent (HttpInstance->Tcp4ConnToken.CompletionToken.Event);\r
      HttpInstance->Tcp4ConnToken.CompletionToken.Event = NULL;\r
    }\r
\r
    if (NULL != HttpInstance->Tcp4CloseToken.CompletionToken.Event) {\r
      gBS->CloseEvent (HttpInstance->Tcp4CloseToken.CompletionToken.Event);\r
      HttpInstance->Tcp4CloseToken.CompletionToken.Event = NULL;\r
    }\r
  }\r
}\r
\r
/**\r
  Create event for the TCP transmit token.\r
\r
  @param[in]  Wrap               Point to HTTP token's wrap data.\r
\r
  @retval EFI_SUCCESS            The events is created successfully.\r
  @retval others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCreateTcpTxEvent (\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  EFI_STATUS           Status;\r
  HTTP_PROTOCOL        *HttpInstance;\r
  HTTP_TCP_TOKEN_WRAP  *TcpWrap;\r
\r
  HttpInstance = Wrap->HttpInstance;\r
  TcpWrap      = &Wrap->TcpWrap;\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpTcpTransmitNotify,\r
                    Wrap,\r
                    &TcpWrap->Tx4Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    TcpWrap->Tx4Data.Push                    = TRUE;\r
    TcpWrap->Tx4Data.Urgent                  = FALSE;\r
    TcpWrap->Tx4Data.FragmentCount           = 1;\r
    TcpWrap->Tx4Token.Packet.TxData          = &Wrap->TcpWrap.Tx4Data;\r
    TcpWrap->Tx4Token.CompletionToken.Status = EFI_NOT_READY;\r
  } else {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpTcpTransmitNotify,\r
                    Wrap,\r
                    &TcpWrap->Tx6Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    TcpWrap->Tx6Data.Push                    = TRUE;\r
    TcpWrap->Tx6Data.Urgent                  = FALSE;\r
    TcpWrap->Tx6Data.FragmentCount           = 1;\r
    TcpWrap->Tx6Token.Packet.TxData          = &Wrap->TcpWrap.Tx6Data;\r
    TcpWrap->Tx6Token.CompletionToken.Status = EFI_NOT_READY;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Create event for the TCP receive token which is used to receive HTTP header.\r
\r
  @param[in]  HttpInstance       Pointer to HTTP_PROTOCOL structure.\r
\r
  @retval EFI_SUCCESS            The events is created successfully.\r
  @retval others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCreateTcpRxEventForHeader (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsRxDone,\r
                    &HttpInstance->Rx4Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    HttpInstance->Rx4Data.FragmentCount           = 1;\r
    HttpInstance->Rx4Token.Packet.RxData          = &HttpInstance->Rx4Data;\r
    HttpInstance->Rx4Token.CompletionToken.Status = EFI_NOT_READY;\r
  } else {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpCommonNotify,\r
                    &HttpInstance->IsRxDone,\r
                    &HttpInstance->Rx6Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    HttpInstance->Rx6Data.FragmentCount           = 1;\r
    HttpInstance->Rx6Token.Packet.RxData          = &HttpInstance->Rx6Data;\r
    HttpInstance->Rx6Token.CompletionToken.Status = EFI_NOT_READY;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Create event for the TCP receive token which is used to receive HTTP body.\r
\r
  @param[in]  Wrap               Point to HTTP token's wrap data.\r
\r
  @retval EFI_SUCCESS            The events is created successfully.\r
  @retval others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCreateTcpRxEvent (\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  EFI_STATUS           Status;\r
  HTTP_PROTOCOL        *HttpInstance;\r
  HTTP_TCP_TOKEN_WRAP  *TcpWrap;\r
\r
  HttpInstance = Wrap->HttpInstance;\r
  TcpWrap      = &Wrap->TcpWrap;\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpTcpReceiveNotify,\r
                    Wrap,\r
                    &TcpWrap->Rx4Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    TcpWrap->Rx4Data.FragmentCount           = 1;\r
    TcpWrap->Rx4Token.Packet.RxData          = &Wrap->TcpWrap.Rx4Data;\r
    TcpWrap->Rx4Token.CompletionToken.Status = EFI_NOT_READY;\r
  } else {\r
    Status = gBS->CreateEvent (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    HttpTcpReceiveNotify,\r
                    Wrap,\r
                    &TcpWrap->Rx6Token.CompletionToken.Event\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    TcpWrap->Rx6Data.FragmentCount           = 1;\r
    TcpWrap->Rx6Token.Packet.RxData          = &Wrap->TcpWrap.Rx6Data;\r
    TcpWrap->Rx6Token.CompletionToken.Status = EFI_NOT_READY;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Close Events for Tcp Receive Tokens for HTTP body and HTTP header.\r
\r
  @param[in]  Wrap               Pointer to HTTP token's wrap data.\r
\r
**/\r
VOID\r
HttpCloseTcpRxEvent (\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  HTTP_PROTOCOL  *HttpInstance;\r
\r
  ASSERT (Wrap != NULL);\r
  HttpInstance = Wrap->HttpInstance;\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    if (Wrap->TcpWrap.Rx6Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Wrap->TcpWrap.Rx6Token.CompletionToken.Event);\r
    }\r
\r
    if (HttpInstance->Rx6Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (HttpInstance->Rx6Token.CompletionToken.Event);\r
      HttpInstance->Rx6Token.CompletionToken.Event = NULL;\r
    }\r
  } else {\r
    if (Wrap->TcpWrap.Rx4Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Wrap->TcpWrap.Rx4Token.CompletionToken.Event);\r
    }\r
\r
    if (HttpInstance->Rx4Token.CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (HttpInstance->Rx4Token.CompletionToken.Event);\r
      HttpInstance->Rx4Token.CompletionToken.Event = NULL;\r
    }\r
  }\r
}\r
\r
/**\r
  Initialize the HTTP_PROTOCOL structure to the unconfigured state.\r
\r
  @param[in, out]  HttpInstance         Pointer to HTTP_PROTOCOL structure.\r
  @param[in]       IpVersion            Indicate us TCP4 protocol or TCP6 protocol.\r
\r
  @retval EFI_SUCCESS       HTTP_PROTOCOL structure is initialized successfully.\r
  @retval Others            Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpInitProtocol (\r
  IN OUT HTTP_PROTOCOL  *HttpInstance,\r
  IN     BOOLEAN        IpVersion\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *Interface;\r
  BOOLEAN     UsingIpv6;\r
\r
  ASSERT (HttpInstance != NULL);\r
  UsingIpv6 = IpVersion;\r
\r
  if (!UsingIpv6) {\r
    //\r
    // Create TCP4 child.\r
    //\r
    Status = NetLibCreateServiceChild (\r
               HttpInstance->Service->ControllerHandle,\r
               HttpInstance->Service->Ip4DriverBindingHandle,\r
               &gEfiTcp4ServiceBindingProtocolGuid,\r
               &HttpInstance->Tcp4ChildHandle\r
               );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Tcp4ChildHandle,\r
                    &gEfiTcp4ProtocolGuid,\r
                    (VOID **)&Interface,\r
                    HttpInstance->Service->Ip4DriverBindingHandle,\r
                    HttpInstance->Service->ControllerHandle,\r
                    EFI_OPEN_PROTOCOL_BY_DRIVER\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Tcp4ChildHandle,\r
                    &gEfiTcp4ProtocolGuid,\r
                    (VOID **)&HttpInstance->Tcp4,\r
                    HttpInstance->Service->Ip4DriverBindingHandle,\r
                    HttpInstance->Handle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Service->Tcp4ChildHandle,\r
                    &gEfiTcp4ProtocolGuid,\r
                    (VOID **)&Interface,\r
                    HttpInstance->Service->Ip4DriverBindingHandle,\r
                    HttpInstance->Handle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
  } else {\r
    //\r
    // Create TCP6 Child.\r
    //\r
    Status = NetLibCreateServiceChild (\r
               HttpInstance->Service->ControllerHandle,\r
               HttpInstance->Service->Ip6DriverBindingHandle,\r
               &gEfiTcp6ServiceBindingProtocolGuid,\r
               &HttpInstance->Tcp6ChildHandle\r
               );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Tcp6ChildHandle,\r
                    &gEfiTcp6ProtocolGuid,\r
                    (VOID **)&Interface,\r
                    HttpInstance->Service->Ip6DriverBindingHandle,\r
                    HttpInstance->Service->ControllerHandle,\r
                    EFI_OPEN_PROTOCOL_BY_DRIVER\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Tcp6ChildHandle,\r
                    &gEfiTcp6ProtocolGuid,\r
                    (VOID **)&HttpInstance->Tcp6,\r
                    HttpInstance->Service->Ip6DriverBindingHandle,\r
                    HttpInstance->Handle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
\r
    Status = gBS->OpenProtocol (\r
                    HttpInstance->Service->Tcp6ChildHandle,\r
                    &gEfiTcp6ProtocolGuid,\r
                    (VOID **)&Interface,\r
                    HttpInstance->Service->Ip6DriverBindingHandle,\r
                    HttpInstance->Handle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
\r
    if (EFI_ERROR (Status)) {\r
      goto ON_ERROR;\r
    }\r
  }\r
\r
  HttpInstance->Url = AllocateZeroPool (HTTP_URL_BUFFER_LEN);\r
  if (HttpInstance->Url == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ON_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
\r
  if (HttpInstance->Tcp4ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Service->ControllerHandle\r
           );\r
\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
\r
    NetLibDestroyServiceChild (\r
      HttpInstance->Service->ControllerHandle,\r
      HttpInstance->Service->Ip4DriverBindingHandle,\r
      &gEfiTcp4ServiceBindingProtocolGuid,\r
      HttpInstance->Tcp4ChildHandle\r
      );\r
  }\r
\r
  if (HttpInstance->Service->Tcp4ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Service->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
  }\r
\r
  if (HttpInstance->Tcp6ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Service->ControllerHandle\r
           );\r
\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
\r
    NetLibDestroyServiceChild (\r
      HttpInstance->Service->ControllerHandle,\r
      HttpInstance->Service->Ip6DriverBindingHandle,\r
      &gEfiTcp6ServiceBindingProtocolGuid,\r
      HttpInstance->Tcp6ChildHandle\r
      );\r
  }\r
\r
  if (HttpInstance->Service->Tcp6ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Service->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Clean up the HTTP child, release all the resources used by it.\r
\r
  @param[in]  HttpInstance       The HTTP child to clean up.\r
\r
**/\r
VOID\r
HttpCleanProtocol (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  HttpCloseConnection (HttpInstance);\r
\r
  HttpCloseTcpConnCloseEvent (HttpInstance);\r
\r
  if (HttpInstance->TimeoutEvent != NULL) {\r
    gBS->CloseEvent (HttpInstance->TimeoutEvent);\r
    HttpInstance->TimeoutEvent = NULL;\r
  }\r
\r
  if (HttpInstance->CacheBody != NULL) {\r
    FreePool (HttpInstance->CacheBody);\r
    HttpInstance->CacheBody = NULL;\r
    HttpInstance->NextMsg   = NULL;\r
  }\r
\r
  if (HttpInstance->RemoteHost != NULL) {\r
    FreePool (HttpInstance->RemoteHost);\r
    HttpInstance->RemoteHost = NULL;\r
  }\r
\r
  if (HttpInstance->MsgParser != NULL) {\r
    HttpFreeMsgParser (HttpInstance->MsgParser);\r
    HttpInstance->MsgParser = NULL;\r
  }\r
\r
  if (HttpInstance->Url != NULL) {\r
    FreePool (HttpInstance->Url);\r
    HttpInstance->Url = NULL;\r
  }\r
\r
  NetMapClean (&HttpInstance->TxTokens);\r
  NetMapClean (&HttpInstance->RxTokens);\r
\r
  if ((HttpInstance->TlsSb != NULL) && (HttpInstance->TlsChildHandle != NULL)) {\r
    //\r
    // Destroy the TLS instance.\r
    //\r
    HttpInstance->TlsSb->DestroyChild (HttpInstance->TlsSb, HttpInstance->TlsChildHandle);\r
    HttpInstance->TlsChildHandle = NULL;\r
  }\r
\r
  if (HttpInstance->Tcp4ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Service->ControllerHandle\r
           );\r
\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
\r
    NetLibDestroyServiceChild (\r
      HttpInstance->Service->ControllerHandle,\r
      HttpInstance->Service->Ip4DriverBindingHandle,\r
      &gEfiTcp4ServiceBindingProtocolGuid,\r
      HttpInstance->Tcp4ChildHandle\r
      );\r
  }\r
\r
  if (HttpInstance->Service->Tcp4ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Service->Tcp4ChildHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           HttpInstance->Service->Ip4DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
  }\r
\r
  if (HttpInstance->Tcp6ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Service->ControllerHandle\r
           );\r
\r
    gBS->CloseProtocol (\r
           HttpInstance->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
\r
    NetLibDestroyServiceChild (\r
      HttpInstance->Service->ControllerHandle,\r
      HttpInstance->Service->Ip6DriverBindingHandle,\r
      &gEfiTcp6ServiceBindingProtocolGuid,\r
      HttpInstance->Tcp6ChildHandle\r
      );\r
  }\r
\r
  if (HttpInstance->Service->Tcp6ChildHandle != NULL) {\r
    gBS->CloseProtocol (\r
           HttpInstance->Service->Tcp6ChildHandle,\r
           &gEfiTcp6ProtocolGuid,\r
           HttpInstance->Service->Ip6DriverBindingHandle,\r
           HttpInstance->Handle\r
           );\r
  }\r
\r
  TlsCloseTxRxEvent (HttpInstance);\r
}\r
\r
/**\r
  Establish TCP connection with HTTP server.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
\r
  @retval EFI_SUCCESS            The TCP connection is established.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCreateConnection (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Connect to Http server\r
  //\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    HttpInstance->IsTcp4ConnDone                       = FALSE;\r
    HttpInstance->Tcp4ConnToken.CompletionToken.Status = EFI_NOT_READY;\r
    Status                                             = HttpInstance->Tcp4->Connect (HttpInstance->Tcp4, &HttpInstance->Tcp4ConnToken);\r
    HttpNotify (HttpEventConnectTcp, Status);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "HttpCreateConnection: Tcp4->Connect() = %r\n", Status));\r
      return Status;\r
    }\r
\r
    while (!HttpInstance->IsTcp4ConnDone) {\r
      HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);\r
    }\r
\r
    Status = HttpInstance->Tcp4ConnToken.CompletionToken.Status;\r
  } else {\r
    HttpInstance->IsTcp6ConnDone                       = FALSE;\r
    HttpInstance->Tcp6ConnToken.CompletionToken.Status = EFI_NOT_READY;\r
    Status                                             = HttpInstance->Tcp6->Connect (HttpInstance->Tcp6, &HttpInstance->Tcp6ConnToken);\r
    HttpNotify (HttpEventConnectTcp, Status);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "HttpCreateConnection: Tcp6->Connect() = %r\n", Status));\r
      return Status;\r
    }\r
\r
    while (!HttpInstance->IsTcp6ConnDone) {\r
      HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);\r
    }\r
\r
    Status = HttpInstance->Tcp6ConnToken.CompletionToken.Status;\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    HttpInstance->State = HTTP_STATE_TCP_CONNECTED;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Close existing TCP connection.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
\r
  @retval EFI_SUCCESS            The TCP connection is closed.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpCloseConnection (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if (HttpInstance->State == HTTP_STATE_TCP_CONNECTED) {\r
    if (HttpInstance->LocalAddressIsIPv6) {\r
      HttpInstance->Tcp6CloseToken.AbortOnClose = TRUE;\r
      HttpInstance->IsTcp6CloseDone             = FALSE;\r
      Status                                    = HttpInstance->Tcp6->Close (HttpInstance->Tcp6, &HttpInstance->Tcp6CloseToken);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
\r
      while (!HttpInstance->IsTcp6CloseDone) {\r
        HttpInstance->Tcp6->Poll (HttpInstance->Tcp6);\r
      }\r
    } else {\r
      HttpInstance->Tcp4CloseToken.AbortOnClose = TRUE;\r
      HttpInstance->IsTcp4CloseDone             = FALSE;\r
      Status                                    = HttpInstance->Tcp4->Close (HttpInstance->Tcp4, &HttpInstance->Tcp4CloseToken);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
\r
      while (!HttpInstance->IsTcp4CloseDone) {\r
        HttpInstance->Tcp4->Poll (HttpInstance->Tcp4);\r
      }\r
    }\r
  }\r
\r
  HttpInstance->State = HTTP_STATE_TCP_CLOSED;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Configure TCP4 protocol child.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
  @param[in]  Wrap               The HTTP token's wrap data.\r
\r
  @retval EFI_SUCCESS            The TCP4 protocol child is configured.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpConfigureTcp4 (\r
  IN  HTTP_PROTOCOL    *HttpInstance,\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  EFI_STATUS             Status;\r
  EFI_TCP4_CONFIG_DATA   *Tcp4CfgData;\r
  EFI_TCP4_ACCESS_POINT  *Tcp4AP;\r
  EFI_TCP4_OPTION        *Tcp4Option;\r
\r
  ASSERT (HttpInstance != NULL);\r
\r
  Tcp4CfgData = &HttpInstance->Tcp4CfgData;\r
  ZeroMem (Tcp4CfgData, sizeof (EFI_TCP4_CONFIG_DATA));\r
\r
  Tcp4CfgData->TypeOfService = HTTP_TOS_DEAULT;\r
  Tcp4CfgData->TimeToLive    = HTTP_TTL_DEAULT;\r
  Tcp4CfgData->ControlOption = &HttpInstance->Tcp4Option;\r
\r
  Tcp4AP                    = &Tcp4CfgData->AccessPoint;\r
  Tcp4AP->UseDefaultAddress = HttpInstance->IPv4Node.UseDefaultAddress;\r
  if (!Tcp4AP->UseDefaultAddress) {\r
    IP4_COPY_ADDRESS (&Tcp4AP->StationAddress, &HttpInstance->IPv4Node.LocalAddress);\r
    IP4_COPY_ADDRESS (&Tcp4AP->SubnetMask, &HttpInstance->IPv4Node.LocalSubnet);\r
  }\r
\r
  Tcp4AP->StationPort = HttpInstance->IPv4Node.LocalPort;\r
  Tcp4AP->RemotePort  = HttpInstance->RemotePort;\r
  Tcp4AP->ActiveFlag  = TRUE;\r
  IP4_COPY_ADDRESS (&Tcp4AP->RemoteAddress, &HttpInstance->RemoteAddr);\r
\r
  Tcp4Option                    = Tcp4CfgData->ControlOption;\r
  Tcp4Option->ReceiveBufferSize = HTTP_BUFFER_SIZE_DEAULT;\r
  Tcp4Option->SendBufferSize    = HTTP_BUFFER_SIZE_DEAULT;\r
  Tcp4Option->MaxSynBackLog     = HTTP_MAX_SYN_BACK_LOG;\r
  Tcp4Option->ConnectionTimeout = HTTP_CONNECTION_TIMEOUT;\r
  Tcp4Option->DataRetries       = HTTP_DATA_RETRIES;\r
  Tcp4Option->FinTimeout        = HTTP_FIN_TIMEOUT;\r
  Tcp4Option->KeepAliveProbes   = HTTP_KEEP_ALIVE_PROBES;\r
  Tcp4Option->KeepAliveTime     = HTTP_KEEP_ALIVE_TIME;\r
  Tcp4Option->KeepAliveInterval = HTTP_KEEP_ALIVE_INTERVAL;\r
  Tcp4Option->EnableNagle       = TRUE;\r
  Tcp4CfgData->ControlOption    = Tcp4Option;\r
\r
  if ((HttpInstance->State == HTTP_STATE_TCP_CONNECTED) ||\r
      (HttpInstance->State == HTTP_STATE_TCP_CLOSED))\r
  {\r
    Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, NULL);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "HttpConfigureTcp4(NULL) - %r\n", Status));\r
      return Status;\r
    }\r
\r
    HttpInstance->State = HTTP_STATE_TCP_UNCONFIGED;\r
  }\r
\r
  Status = HttpInstance->Tcp4->Configure (HttpInstance->Tcp4, Tcp4CfgData);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "HttpConfigureTcp4 - %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = HttpCreateTcpConnCloseEvent (HttpInstance);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = HttpCreateTcpTxEvent (Wrap);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  HttpInstance->State = HTTP_STATE_TCP_CONFIGED;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Configure TCP6 protocol child.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
  @param[in]  Wrap               The HTTP token's wrap data.\r
\r
  @retval EFI_SUCCESS            The TCP6 protocol child is configured.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpConfigureTcp6 (\r
  IN  HTTP_PROTOCOL    *HttpInstance,\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  EFI_STATUS             Status;\r
  EFI_TCP6_CONFIG_DATA   *Tcp6CfgData;\r
  EFI_TCP6_ACCESS_POINT  *Tcp6Ap;\r
  EFI_TCP6_OPTION        *Tcp6Option;\r
\r
  ASSERT (HttpInstance != NULL);\r
\r
  Tcp6CfgData = &HttpInstance->Tcp6CfgData;\r
  ZeroMem (Tcp6CfgData, sizeof (EFI_TCP6_CONFIG_DATA));\r
\r
  Tcp6CfgData->TrafficClass  = 0;\r
  Tcp6CfgData->HopLimit      = 255;\r
  Tcp6CfgData->ControlOption = &HttpInstance->Tcp6Option;\r
\r
  Tcp6Ap              = &Tcp6CfgData->AccessPoint;\r
  Tcp6Ap->ActiveFlag  = TRUE;\r
  Tcp6Ap->StationPort = HttpInstance->Ipv6Node.LocalPort;\r
  Tcp6Ap->RemotePort  = HttpInstance->RemotePort;\r
  IP6_COPY_ADDRESS (&Tcp6Ap->StationAddress, &HttpInstance->Ipv6Node.LocalAddress);\r
  IP6_COPY_ADDRESS (&Tcp6Ap->RemoteAddress, &HttpInstance->RemoteIpv6Addr);\r
\r
  Tcp6Option                    = Tcp6CfgData->ControlOption;\r
  Tcp6Option->ReceiveBufferSize = HTTP_BUFFER_SIZE_DEAULT;\r
  Tcp6Option->SendBufferSize    = HTTP_BUFFER_SIZE_DEAULT;\r
  Tcp6Option->MaxSynBackLog     = HTTP_MAX_SYN_BACK_LOG;\r
  Tcp6Option->ConnectionTimeout = HTTP_CONNECTION_TIMEOUT;\r
  Tcp6Option->DataRetries       = HTTP_DATA_RETRIES;\r
  Tcp6Option->FinTimeout        = HTTP_FIN_TIMEOUT;\r
  Tcp6Option->KeepAliveProbes   = HTTP_KEEP_ALIVE_PROBES;\r
  Tcp6Option->KeepAliveTime     = HTTP_KEEP_ALIVE_TIME;\r
  Tcp6Option->KeepAliveInterval = HTTP_KEEP_ALIVE_INTERVAL;\r
  Tcp6Option->EnableNagle       = TRUE;\r
\r
  Status = HttpInstance->Tcp6->Configure (HttpInstance->Tcp6, Tcp6CfgData);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "HttpConfigureTcp6 - %r\n", Status));\r
    return Status;\r
  }\r
\r
  Status = HttpCreateTcpConnCloseEvent (HttpInstance);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = HttpCreateTcpTxEvent (Wrap);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  HttpInstance->State = HTTP_STATE_TCP_CONFIGED;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Check existing TCP connection, if in error state, recover TCP4 connection. Then,\r
  connect one TLS session if required.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
\r
  @retval EFI_SUCCESS            The TCP connection is established.\r
  @retval EFI_NOT_READY          TCP4 protocol child is not created or configured.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpConnectTcp4 (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  EFI_TCP4_CONNECTION_STATE  Tcp4State;\r
\r
  if ((HttpInstance->State < HTTP_STATE_TCP_CONFIGED) || (HttpInstance->Tcp4 == NULL)) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  Status = HttpInstance->Tcp4->GetModeData (\r
                                 HttpInstance->Tcp4,\r
                                 &Tcp4State,\r
                                 NULL,\r
                                 NULL,\r
                                 NULL,\r
                                 NULL\r
                                 );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Tcp4 GetModeData fail - %x\n", Status));\r
    return Status;\r
  }\r
\r
  if (Tcp4State == Tcp4StateEstablished) {\r
    return EFI_SUCCESS;\r
  } else if (Tcp4State > Tcp4StateEstablished ) {\r
    HttpCloseConnection (HttpInstance);\r
  }\r
\r
  Status = HttpCreateConnection (HttpInstance);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Tcp4 Connection fail - %x\n", Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Tls session connection.\r
  //\r
  if (HttpInstance->UseHttps) {\r
    if (HttpInstance->TimeoutEvent == NULL) {\r
      //\r
      // Create TimeoutEvent for TLS connection.\r
      //\r
      Status = gBS->CreateEvent (\r
                      EVT_TIMER,\r
                      TPL_CALLBACK,\r
                      NULL,\r
                      NULL,\r
                      &HttpInstance->TimeoutEvent\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        TlsCloseTxRxEvent (HttpInstance);\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Start the timer, and wait Timeout seconds for connection.\r
    //\r
    Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);\r
    if (EFI_ERROR (Status)) {\r
      TlsCloseTxRxEvent (HttpInstance);\r
      return Status;\r
    }\r
\r
    Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);\r
    HttpNotify (HttpEventTlsConnectSession, Status);\r
\r
    gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);\r
\r
    if (EFI_ERROR (Status)) {\r
      TlsCloseTxRxEvent (HttpInstance);\r
      return Status;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Check existing TCP connection, if in error state, recover TCP6 connection. Then,\r
  connect one TLS session if required.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
\r
  @retval EFI_SUCCESS            The TCP connection is established.\r
  @retval EFI_NOT_READY          TCP6 protocol child is not created or configured.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpConnectTcp6 (\r
  IN  HTTP_PROTOCOL  *HttpInstance\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  EFI_TCP6_CONNECTION_STATE  Tcp6State;\r
\r
  if ((HttpInstance->State < HTTP_STATE_TCP_CONFIGED) || (HttpInstance->Tcp6 == NULL)) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  Status = HttpInstance->Tcp6->GetModeData (\r
                                 HttpInstance->Tcp6,\r
                                 &Tcp6State,\r
                                 NULL,\r
                                 NULL,\r
                                 NULL,\r
                                 NULL\r
                                 );\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Tcp6 GetModeData fail - %x\n", Status));\r
    return Status;\r
  }\r
\r
  if (Tcp6State == Tcp6StateEstablished) {\r
    return EFI_SUCCESS;\r
  } else if (Tcp6State > Tcp6StateEstablished ) {\r
    HttpCloseConnection (HttpInstance);\r
  }\r
\r
  Status = HttpCreateConnection (HttpInstance);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Tcp6 Connection fail - %x\n", Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Tls session connection.\r
  //\r
  if (HttpInstance->UseHttps) {\r
    if (HttpInstance->TimeoutEvent == NULL) {\r
      //\r
      // Create TimeoutEvent for TLS connection.\r
      //\r
      Status = gBS->CreateEvent (\r
                      EVT_TIMER,\r
                      TPL_CALLBACK,\r
                      NULL,\r
                      NULL,\r
                      &HttpInstance->TimeoutEvent\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        TlsCloseTxRxEvent (HttpInstance);\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Start the timer, and wait Timeout seconds for connection.\r
    //\r
    Status = gBS->SetTimer (HttpInstance->TimeoutEvent, TimerRelative, HTTP_CONNECTION_TIMEOUT * TICKS_PER_SECOND);\r
    if (EFI_ERROR (Status)) {\r
      TlsCloseTxRxEvent (HttpInstance);\r
      return Status;\r
    }\r
\r
    Status = TlsConnectSession (HttpInstance, HttpInstance->TimeoutEvent);\r
    HttpNotify (HttpEventTlsConnectSession, Status);\r
\r
    gBS->SetTimer (HttpInstance->TimeoutEvent, TimerCancel, 0);\r
\r
    if (EFI_ERROR (Status)) {\r
      TlsCloseTxRxEvent (HttpInstance);\r
      return Status;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Initialize Http session.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
  @param[in]  Wrap               The HTTP token's wrap data.\r
  @param[in]  Configure          The Flag indicates whether need to initialize session.\r
  @param[in]  TlsConfigure       The Flag indicates whether it's the new Tls session.\r
\r
  @retval EFI_SUCCESS            The initialization of session is done.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpInitSession (\r
  IN  HTTP_PROTOCOL    *HttpInstance,\r
  IN  HTTP_TOKEN_WRAP  *Wrap,\r
  IN  BOOLEAN          Configure,\r
  IN  BOOLEAN          TlsConfigure\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  ASSERT (HttpInstance != NULL);\r
\r
  //\r
  // Configure Tls session.\r
  //\r
  if (TlsConfigure) {\r
    Status = TlsConfigureSession (HttpInstance);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    //\r
    // Configure TCP instance.\r
    //\r
    if (Configure) {\r
      Status = HttpConfigureTcp4 (HttpInstance, Wrap);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Connect TCP.\r
    //\r
    Status = HttpConnectTcp4 (HttpInstance);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  } else {\r
    //\r
    // Configure TCP instance.\r
    //\r
    if (Configure) {\r
      Status = HttpConfigureTcp6 (HttpInstance, Wrap);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Connect TCP.\r
    //\r
    Status = HttpConnectTcp6 (HttpInstance);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Send the HTTP or HTTPS message through TCP4 or TCP6.\r
\r
  @param[in]  HttpInstance       The HTTP instance private data.\r
  @param[in]  Wrap               The HTTP token's wrap data.\r
  @param[in]  TxString           Buffer containing the HTTP message string.\r
  @param[in]  TxStringLen        Length of the HTTP message string in bytes.\r
\r
  @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit queue.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpTransmitTcp (\r
  IN  HTTP_PROTOCOL    *HttpInstance,\r
  IN  HTTP_TOKEN_WRAP  *Wrap,\r
  IN  UINT8            *TxString,\r
  IN  UINTN            TxStringLen\r
  )\r
{\r
  EFI_STATUS         Status;\r
  EFI_TCP4_IO_TOKEN  *Tx4Token;\r
  EFI_TCP4_PROTOCOL  *Tcp4;\r
  EFI_TCP6_IO_TOKEN  *Tx6Token;\r
  EFI_TCP6_PROTOCOL  *Tcp6;\r
  UINT8              *TlsRecord;\r
  UINT16             PayloadSize;\r
  NET_FRAGMENT       TempFragment;\r
  NET_FRAGMENT       Fragment;\r
  UINTN              RecordCount;\r
  UINTN              RemainingLen;\r
\r
  Status            = EFI_SUCCESS;\r
  TlsRecord         = NULL;\r
  PayloadSize       = 0;\r
  TempFragment.Len  = 0;\r
  TempFragment.Bulk = NULL;\r
  Fragment.Len      = 0;\r
  Fragment.Bulk     = NULL;\r
  RecordCount       = 0;\r
  RemainingLen      = 0;\r
\r
  //\r
  // Need to encrypt data.\r
  //\r
  if (HttpInstance->UseHttps) {\r
    //\r
    // Allocate enough buffer for each TLS plaintext records.\r
    //\r
    TlsRecord = AllocateZeroPool (TLS_RECORD_HEADER_LENGTH + TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH);\r
    if (TlsRecord == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      return Status;\r
    }\r
\r
    //\r
    // Allocate enough buffer for all TLS ciphertext records.\r
    //\r
    RecordCount   = TxStringLen / TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH + 1;\r
    Fragment.Bulk = AllocateZeroPool (RecordCount * (TLS_RECORD_HEADER_LENGTH + TLS_CIPHERTEXT_RECORD_MAX_PAYLOAD_LENGTH));\r
    if (Fragment.Bulk == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto ON_ERROR;\r
    }\r
\r
    //\r
    // Encrypt each TLS plaintext records.\r
    //\r
    RemainingLen = TxStringLen;\r
    while (RemainingLen != 0) {\r
      PayloadSize = (UINT16)MIN (TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH, RemainingLen);\r
\r
      ((TLS_RECORD_HEADER *)TlsRecord)->ContentType   = TlsContentTypeApplicationData;\r
      ((TLS_RECORD_HEADER *)TlsRecord)->Version.Major = HttpInstance->TlsConfigData.Version.Major;\r
      ((TLS_RECORD_HEADER *)TlsRecord)->Version.Minor = HttpInstance->TlsConfigData.Version.Minor;\r
      ((TLS_RECORD_HEADER *)TlsRecord)->Length        = PayloadSize;\r
\r
      CopyMem (TlsRecord + TLS_RECORD_HEADER_LENGTH, TxString + (TxStringLen - RemainingLen), PayloadSize);\r
\r
      Status = TlsProcessMessage (\r
                 HttpInstance,\r
                 TlsRecord,\r
                 TLS_RECORD_HEADER_LENGTH + PayloadSize,\r
                 EfiTlsEncrypt,\r
                 &TempFragment\r
                 );\r
      if (EFI_ERROR (Status)) {\r
        goto ON_ERROR;\r
      }\r
\r
      //\r
      // Record the processed/encrypted Packet.\r
      //\r
      CopyMem (Fragment.Bulk + Fragment.Len, TempFragment.Bulk, TempFragment.Len);\r
      Fragment.Len += TempFragment.Len;\r
\r
      FreePool (TempFragment.Bulk);\r
      TempFragment.Len  = 0;\r
      TempFragment.Bulk = NULL;\r
\r
      RemainingLen -= (UINTN)PayloadSize;\r
      ZeroMem (TlsRecord, TLS_RECORD_HEADER_LENGTH + TLS_PLAINTEXT_RECORD_MAX_PAYLOAD_LENGTH);\r
    }\r
\r
    FreePool (TlsRecord);\r
    TlsRecord = NULL;\r
  }\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    Tcp4     = HttpInstance->Tcp4;\r
    Tx4Token = &Wrap->TcpWrap.Tx4Token;\r
\r
    if (HttpInstance->UseHttps) {\r
      Tx4Token->Packet.TxData->DataLength                      = Fragment.Len;\r
      Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = Fragment.Len;\r
      Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)Fragment.Bulk;\r
    } else {\r
      Tx4Token->Packet.TxData->DataLength                      = (UINT32)TxStringLen;\r
      Tx4Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32)TxStringLen;\r
      Tx4Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)TxString;\r
    }\r
\r
    Tx4Token->CompletionToken.Status = EFI_NOT_READY;\r
\r
    Wrap->TcpWrap.IsTxDone = FALSE;\r
    Status                 = Tcp4->Transmit (Tcp4, Tx4Token);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "Transmit failed: %r\n", Status));\r
      goto ON_ERROR;\r
    }\r
  } else {\r
    Tcp6     = HttpInstance->Tcp6;\r
    Tx6Token = &Wrap->TcpWrap.Tx6Token;\r
\r
    if (HttpInstance->UseHttps) {\r
      Tx6Token->Packet.TxData->DataLength                      = Fragment.Len;\r
      Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = Fragment.Len;\r
      Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)Fragment.Bulk;\r
    } else {\r
      Tx6Token->Packet.TxData->DataLength                      = (UINT32)TxStringLen;\r
      Tx6Token->Packet.TxData->FragmentTable[0].FragmentLength = (UINT32)TxStringLen;\r
      Tx6Token->Packet.TxData->FragmentTable[0].FragmentBuffer = (VOID *)TxString;\r
    }\r
\r
    Tx6Token->CompletionToken.Status = EFI_NOT_READY;\r
\r
    Wrap->TcpWrap.IsTxDone = FALSE;\r
    Status                 = Tcp6->Transmit (Tcp6, Tx6Token);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "Transmit failed: %r\n", Status));\r
      goto ON_ERROR;\r
    }\r
  }\r
\r
  return Status;\r
\r
ON_ERROR:\r
\r
  if (HttpInstance->UseHttps) {\r
    if (TlsRecord != NULL) {\r
      FreePool (TlsRecord);\r
      TlsRecord = NULL;\r
    }\r
\r
    if (Fragment.Bulk != NULL) {\r
      FreePool (Fragment.Bulk);\r
      Fragment.Bulk = NULL;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Check whether the user's token or event has already\r
  been enqueue on HTTP Tx or Rx Token list.\r
\r
  @param[in]  Map                The container of either user's transmit or receive\r
                                 token.\r
  @param[in]  Item               Current item to check against.\r
  @param[in]  Context            The Token to check against.\r
\r
  @retval EFI_ACCESS_DENIED      The token or event has already been enqueued in IP\r
  @retval EFI_SUCCESS            The current item isn't the same token/event as the\r
                                 context.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HttpTokenExist (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Context\r
  )\r
{\r
  EFI_HTTP_TOKEN  *Token;\r
  EFI_HTTP_TOKEN  *TokenInItem;\r
\r
  Token       = (EFI_HTTP_TOKEN *)Context;\r
  TokenInItem = (EFI_HTTP_TOKEN *)Item->Key;\r
\r
  if ((Token == TokenInItem) || (Token->Event == TokenInItem->Event)) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Check whether the HTTP message associated with Tx4Token or Tx6Token is already sent out.\r
\r
  @param[in]  Map                The container of Tx4Token or Tx6Token.\r
  @param[in]  Item               Current item to check against.\r
  @param[in]  Context            The Token to check against.\r
\r
  @retval EFI_NOT_READY          The HTTP message is still queued in the list.\r
  @retval EFI_SUCCESS            The HTTP message has been sent out.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HttpTcpNotReady (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Context\r
  )\r
{\r
  HTTP_TOKEN_WRAP  *ValueInItem;\r
\r
  ValueInItem = (HTTP_TOKEN_WRAP *)Item->Value;\r
\r
  if (!ValueInItem->TcpWrap.IsTxDone) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Transmit the HTTP or HTTPS message by processing the associated HTTP token.\r
\r
  @param[in]  Map                The container of Tx4Token or Tx6Token.\r
  @param[in]  Item               Current item to check against.\r
  @param[in]  Context            The Token to check against.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.\r
  @retval EFI_SUCCESS            The HTTP message is queued into TCP transmit\r
                                 queue.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HttpTcpTransmit (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Context\r
  )\r
{\r
  HTTP_TOKEN_WRAP  *ValueInItem;\r
  EFI_STATUS       Status;\r
  CHAR8            *RequestMsg;\r
  CHAR8            *Url;\r
  UINTN            UrlSize;\r
  UINTN            RequestMsgSize;\r
\r
  RequestMsg = NULL;\r
\r
  ValueInItem = (HTTP_TOKEN_WRAP *)Item->Value;\r
  if (ValueInItem->TcpWrap.IsTxDone) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Parse the URI of the remote host.\r
  //\r
  UrlSize = StrLen (ValueInItem->HttpToken->Message->Data.Request->Url) + 1;\r
  Url     = AllocatePool (UrlSize);\r
  if (Url == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  UnicodeStrToAsciiStrS (ValueInItem->HttpToken->Message->Data.Request->Url, Url, UrlSize);\r
\r
  //\r
  // Create request message.\r
  //\r
  Status = HttpGenRequestMessage (\r
             ValueInItem->HttpToken->Message,\r
             Url,\r
             &RequestMsg,\r
             &RequestMsgSize\r
             );\r
  FreePool (Url);\r
\r
  if (EFI_ERROR (Status) || (NULL == RequestMsg)) {\r
    return Status;\r
  }\r
\r
  ASSERT (RequestMsg != NULL);\r
\r
  //\r
  // Transmit the request message.\r
  //\r
  Status = HttpTransmitTcp (\r
             ValueInItem->HttpInstance,\r
             ValueInItem,\r
             (UINT8 *)RequestMsg,\r
             RequestMsgSize\r
             );\r
  FreePool (RequestMsg);\r
  return Status;\r
}\r
\r
/**\r
  Receive the HTTP response by processing the associated HTTP token.\r
\r
  @param[in]  Map                The container of Rx4Token or Rx6Token.\r
  @param[in]  Item               Current item to check against.\r
  @param[in]  Context            The Token to check against.\r
\r
  @retval EFI_SUCCESS            The HTTP response is queued into TCP receive\r
                                 queue.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HttpTcpReceive (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Context\r
  )\r
{\r
  //\r
  // Process the queued HTTP response.\r
  //\r
  return HttpResponseWorker ((HTTP_TOKEN_WRAP *)Item->Value);\r
}\r
\r
/**\r
  Receive the HTTP header by processing the associated HTTP token.\r
\r
  @param[in]       HttpInstance     The HTTP instance private data.\r
  @param[in, out]  SizeofHeaders    The HTTP header length.\r
  @param[in, out]  BufferSize       The size of buffer to cache the header message.\r
  @param[in]       Timeout          The time to wait for receiving the header packet.\r
\r
  @retval EFI_SUCCESS               The HTTP header is received.\r
  @retval Others                    Other errors as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpTcpReceiveHeader (\r
  IN  HTTP_PROTOCOL  *HttpInstance,\r
  IN  OUT UINTN      *SizeofHeaders,\r
  IN  OUT UINTN      *BufferSize,\r
  IN  EFI_EVENT      Timeout\r
  )\r
{\r
  EFI_STATUS         Status;\r
  EFI_TCP4_IO_TOKEN  *Rx4Token;\r
  EFI_TCP4_PROTOCOL  *Tcp4;\r
  EFI_TCP6_IO_TOKEN  *Rx6Token;\r
  EFI_TCP6_PROTOCOL  *Tcp6;\r
  CHAR8              **EndofHeader;\r
  CHAR8              **HttpHeaders;\r
  CHAR8              *Buffer;\r
  NET_FRAGMENT       Fragment;\r
\r
  ASSERT (HttpInstance != NULL);\r
\r
  EndofHeader   = HttpInstance->EndofHeader;\r
  HttpHeaders   = HttpInstance->HttpHeaders;\r
  Tcp4          = HttpInstance->Tcp4;\r
  Tcp6          = HttpInstance->Tcp6;\r
  Buffer        = NULL;\r
  Rx4Token      = NULL;\r
  Rx6Token      = NULL;\r
  Fragment.Len  = 0;\r
  Fragment.Bulk = NULL;\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    ASSERT (Tcp6 != NULL);\r
  } else {\r
    ASSERT (Tcp4 != NULL);\r
  }\r
\r
  if (!HttpInstance->UseHttps) {\r
    Status = HttpCreateTcpRxEventForHeader (HttpInstance);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  if (!HttpInstance->LocalAddressIsIPv6) {\r
    if (!HttpInstance->UseHttps) {\r
      Rx4Token                                                 = &HttpInstance->Rx4Token;\r
      Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);\r
      if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.\r
    //\r
    while (*EndofHeader == NULL) {\r
      if (!HttpInstance->UseHttps) {\r
        HttpInstance->IsRxDone                                   = FALSE;\r
        Rx4Token->Packet.RxData->DataLength                      = DEF_BUF_LEN;\r
        Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;\r
        Status                                                   = Tcp4->Receive (Tcp4, Rx4Token);\r
        if (EFI_ERROR (Status)) {\r
          DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));\r
          return Status;\r
        }\r
\r
        while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {\r
          Tcp4->Poll (Tcp4);\r
        }\r
\r
        if (!HttpInstance->IsRxDone) {\r
          //\r
          // Cancel the Token before close its Event.\r
          //\r
          Tcp4->Cancel (HttpInstance->Tcp4, &Rx4Token->CompletionToken);\r
          gBS->CloseEvent (Rx4Token->CompletionToken.Event);\r
          Rx4Token->CompletionToken.Status = EFI_TIMEOUT;\r
        }\r
\r
        Status = Rx4Token->CompletionToken.Status;\r
        if (EFI_ERROR (Status)) {\r
          return Status;\r
        }\r
\r
        Fragment.Len  = Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength;\r
        Fragment.Bulk = (UINT8 *)Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer;\r
      } else {\r
        if (Fragment.Bulk != NULL) {\r
          FreePool (Fragment.Bulk);\r
          Fragment.Bulk = NULL;\r
        }\r
\r
        Status = HttpsReceive (HttpInstance, &Fragment, Timeout);\r
        if (EFI_ERROR (Status)) {\r
          DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));\r
          return Status;\r
        }\r
      }\r
\r
      //\r
      // Append the response string along with a Null-terminator.\r
      //\r
      *BufferSize = *SizeofHeaders + Fragment.Len;\r
      Buffer      = AllocatePool (*BufferSize + 1);\r
      if (Buffer == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        return Status;\r
      }\r
\r
      if (*HttpHeaders != NULL) {\r
        CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);\r
        FreePool (*HttpHeaders);\r
      }\r
\r
      CopyMem (\r
        Buffer + *SizeofHeaders,\r
        Fragment.Bulk,\r
        Fragment.Len\r
        );\r
      *(Buffer + *BufferSize) = '\0';\r
      *HttpHeaders            = Buffer;\r
      *SizeofHeaders          = *BufferSize;\r
\r
      //\r
      // Check whether we received end of HTTP headers.\r
      //\r
      *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);\r
    }\r
\r
    //\r
    // Free the buffer.\r
    //\r
    if ((Rx4Token != NULL) && (Rx4Token->Packet.RxData != NULL) && (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL)) {\r
      FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);\r
      Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;\r
      Fragment.Bulk                                            = NULL;\r
    }\r
\r
    if (Fragment.Bulk != NULL) {\r
      FreePool (Fragment.Bulk);\r
      Fragment.Bulk = NULL;\r
    }\r
  } else {\r
    if (!HttpInstance->UseHttps) {\r
      Rx6Token                                                 = &HttpInstance->Rx6Token;\r
      Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = AllocateZeroPool (DEF_BUF_LEN);\r
      if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.\r
    //\r
    while (*EndofHeader == NULL) {\r
      if (!HttpInstance->UseHttps) {\r
        HttpInstance->IsRxDone                                   = FALSE;\r
        Rx6Token->Packet.RxData->DataLength                      = DEF_BUF_LEN;\r
        Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = DEF_BUF_LEN;\r
        Status                                                   = Tcp6->Receive (Tcp6, Rx6Token);\r
        if (EFI_ERROR (Status)) {\r
          DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));\r
          return Status;\r
        }\r
\r
        while (!HttpInstance->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {\r
          Tcp6->Poll (Tcp6);\r
        }\r
\r
        if (!HttpInstance->IsRxDone) {\r
          //\r
          // Cancel the Token before close its Event.\r
          //\r
          Tcp6->Cancel (HttpInstance->Tcp6, &Rx6Token->CompletionToken);\r
          gBS->CloseEvent (Rx6Token->CompletionToken.Event);\r
          Rx6Token->CompletionToken.Status = EFI_TIMEOUT;\r
        }\r
\r
        Status = Rx6Token->CompletionToken.Status;\r
        if (EFI_ERROR (Status)) {\r
          return Status;\r
        }\r
\r
        Fragment.Len  = Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength;\r
        Fragment.Bulk = (UINT8 *)Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer;\r
      } else {\r
        if (Fragment.Bulk != NULL) {\r
          FreePool (Fragment.Bulk);\r
          Fragment.Bulk = NULL;\r
        }\r
\r
        Status = HttpsReceive (HttpInstance, &Fragment, Timeout);\r
        if (EFI_ERROR (Status)) {\r
          DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));\r
          return Status;\r
        }\r
      }\r
\r
      //\r
      // Append the response string along with a Null-terminator.\r
      //\r
      *BufferSize = *SizeofHeaders + Fragment.Len;\r
      Buffer      = AllocatePool (*BufferSize + 1);\r
      if (Buffer == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        return Status;\r
      }\r
\r
      if (*HttpHeaders != NULL) {\r
        CopyMem (Buffer, *HttpHeaders, *SizeofHeaders);\r
        FreePool (*HttpHeaders);\r
      }\r
\r
      CopyMem (\r
        Buffer + *SizeofHeaders,\r
        Fragment.Bulk,\r
        Fragment.Len\r
        );\r
      *(Buffer + *BufferSize) = '\0';\r
      *HttpHeaders            = Buffer;\r
      *SizeofHeaders          = *BufferSize;\r
\r
      //\r
      // Check whether we received end of HTTP headers.\r
      //\r
      *EndofHeader = AsciiStrStr (*HttpHeaders, HTTP_END_OF_HDR_STR);\r
    }\r
\r
    //\r
    // Free the buffer.\r
    //\r
    if ((Rx6Token != NULL) && (Rx6Token->Packet.RxData != NULL) && (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL)) {\r
      FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);\r
      Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;\r
      Fragment.Bulk                                            = NULL;\r
    }\r
\r
    if (Fragment.Bulk != NULL) {\r
      FreePool (Fragment.Bulk);\r
      Fragment.Bulk = NULL;\r
    }\r
  }\r
\r
  //\r
  // Skip the CRLF after the HTTP headers.\r
  //\r
  *EndofHeader = *EndofHeader + AsciiStrLen (HTTP_END_OF_HDR_STR);\r
\r
  *SizeofHeaders = *EndofHeader - *HttpHeaders;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Receive the HTTP body by processing the associated HTTP token.\r
\r
  @param[in]  Wrap               The HTTP token's wrap data.\r
  @param[in]  HttpMsg            The HTTP message data.\r
\r
  @retval EFI_SUCCESS            The HTTP body is received.\r
  @retval Others                 Other error as indicated.\r
\r
**/\r
EFI_STATUS\r
HttpTcpReceiveBody (\r
  IN  HTTP_TOKEN_WRAP   *Wrap,\r
  IN  EFI_HTTP_MESSAGE  *HttpMsg\r
  )\r
{\r
  EFI_STATUS         Status;\r
  HTTP_PROTOCOL      *HttpInstance;\r
  EFI_TCP6_PROTOCOL  *Tcp6;\r
  EFI_TCP6_IO_TOKEN  *Rx6Token;\r
  EFI_TCP4_PROTOCOL  *Tcp4;\r
  EFI_TCP4_IO_TOKEN  *Rx4Token;\r
\r
  HttpInstance = Wrap->HttpInstance;\r
  Tcp4         = HttpInstance->Tcp4;\r
  Tcp6         = HttpInstance->Tcp6;\r
  Rx4Token     = NULL;\r
  Rx6Token     = NULL;\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    ASSERT (Tcp6 != NULL);\r
  } else {\r
    ASSERT (Tcp4 != NULL);\r
  }\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    Rx6Token                                                 = &Wrap->TcpWrap.Rx6Token;\r
    Rx6Token->Packet.RxData->DataLength                      = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);\r
    Rx6Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);\r
    Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *)HttpMsg->Body;\r
    Rx6Token->CompletionToken.Status                         = EFI_NOT_READY;\r
\r
    Status = Tcp6->Receive (Tcp6, Rx6Token);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "Tcp6 receive failed: %r\n", Status));\r
      return Status;\r
    }\r
  } else {\r
    Rx4Token                                                 = &Wrap->TcpWrap.Rx4Token;\r
    Rx4Token->Packet.RxData->DataLength                      = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);\r
    Rx4Token->Packet.RxData->FragmentTable[0].FragmentLength = (UINT32)MIN (MAX_UINT32, HttpMsg->BodyLength);\r
    Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = (VOID *)HttpMsg->Body;\r
\r
    Rx4Token->CompletionToken.Status = EFI_NOT_READY;\r
    Status                           = Tcp4->Receive (Tcp4, Rx4Token);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "Tcp4 receive failed: %r\n", Status));\r
      return Status;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Clean up Tcp Tokens while the Tcp transmission error occurs.\r
\r
  @param[in]  Wrap               Pointer to HTTP token's wrap data.\r
\r
**/\r
VOID\r
HttpTcpTokenCleanup (\r
  IN  HTTP_TOKEN_WRAP  *Wrap\r
  )\r
{\r
  HTTP_PROTOCOL      *HttpInstance;\r
  EFI_TCP4_IO_TOKEN  *Rx4Token;\r
  EFI_TCP6_IO_TOKEN  *Rx6Token;\r
\r
  ASSERT (Wrap != NULL);\r
  HttpInstance = Wrap->HttpInstance;\r
  Rx4Token     = NULL;\r
  Rx6Token     = NULL;\r
\r
  if (HttpInstance->LocalAddressIsIPv6) {\r
    Rx6Token = &Wrap->TcpWrap.Rx6Token;\r
\r
    if (Rx6Token->CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Rx6Token->CompletionToken.Event);\r
      Rx6Token->CompletionToken.Event = NULL;\r
    }\r
\r
    FreePool (Wrap);\r
\r
    Rx6Token = &HttpInstance->Rx6Token;\r
\r
    if (Rx6Token->CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Rx6Token->CompletionToken.Event);\r
      Rx6Token->CompletionToken.Event = NULL;\r
    }\r
\r
    if (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {\r
      FreePool (Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer);\r
      Rx6Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;\r
    }\r
  } else {\r
    Rx4Token = &Wrap->TcpWrap.Rx4Token;\r
\r
    if (Rx4Token->CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Rx4Token->CompletionToken.Event);\r
      Rx4Token->CompletionToken.Event = NULL;\r
    }\r
\r
    FreePool (Wrap);\r
\r
    Rx4Token = &HttpInstance->Rx4Token;\r
\r
    if (Rx4Token->CompletionToken.Event != NULL) {\r
      gBS->CloseEvent (Rx4Token->CompletionToken.Event);\r
      Rx4Token->CompletionToken.Event = NULL;\r
    }\r
\r
    if (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer != NULL) {\r
      FreePool (Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer);\r
      Rx4Token->Packet.RxData->FragmentTable[0].FragmentBuffer = NULL;\r
    }\r
  }\r
}\r
\r
/**\r
  Send Events via EDKII_HTTP_CALLBACK_PROTOCOL.\r
\r
  @param[in]  Event               The event that occurs in the current state.\r
  @param[in]  EventStatus         The Status of Event, EFI_SUCCESS or other errors.\r
\r
**/\r
VOID\r
HttpNotify (\r
  IN  EDKII_HTTP_CALLBACK_EVENT  Event,\r
  IN  EFI_STATUS                 EventStatus\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  EFI_HANDLE                    *Handles;\r
  UINTN                         Index;\r
  UINTN                         HandleCount;\r
  EFI_HANDLE                    Handle;\r
  EDKII_HTTP_CALLBACK_PROTOCOL  *HttpCallback;\r
\r
  DEBUG ((DEBUG_INFO, "HttpNotify: Event - %d, EventStatus - %r\n", Event, EventStatus));\r
\r
  Handles     = NULL;\r
  HandleCount = 0;\r
  Status      = gBS->LocateHandleBuffer (\r
                       ByProtocol,\r
                       &gEdkiiHttpCallbackProtocolGuid,\r
                       NULL,\r
                       &HandleCount,\r
                       &Handles\r
                       );\r
  if (Status == EFI_SUCCESS) {\r
    for (Index = 0; Index < HandleCount; Index++) {\r
      Handle = Handles[Index];\r
      Status = gBS->HandleProtocol (\r
                      Handle,\r
                      &gEdkiiHttpCallbackProtocolGuid,\r
                      (VOID **)&HttpCallback\r
                      );\r
      if (Status == EFI_SUCCESS) {\r
        DEBUG ((DEBUG_INFO, "HttpNotify: Notifying %p\n", HttpCallback));\r
        HttpCallback->Callback (\r
                        HttpCallback,\r
                        Event,\r
                        EventStatus\r
                        );\r
      }\r
    }\r
\r
    FreePool (Handles);\r
  }\r
}\r