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