/** @file
  HttpDxe.h -- Header for HttpDxe

Copyright (c) HR650X BIOS Decompilation Project
**/

#ifndef __HTTPDXE_H__
#define __HTTPDXE_H__

#include "../uefi_headers/Uefi.h"

//
// Function Prototypes
//

EFI_STATUS
EFIAPI
DebugAssert(
  VOID
);

EFI_STATUS
EFIAPI
HttpDxeDriverEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
HttpDxeDriverEntry(
  VOID
);

EFI_STATUS
EFIAPI
HttpDriverBindingSupported(
  VOID
);

EFI_STATUS
EFIAPI
HttpDriverBindingStart(
  VOID
);

EFI_STATUS
EFIAPI
HttpDriverBindingStop(
  VOID
);

EFI_STATUS
EFIAPI
HttpServiceBindingCreateChild(
  VOID
);

EFI_STATUS
EFIAPI
HttpServiceBindingDestroyChild(
  VOID
);

EFI_STATUS
EFIAPI
HttpGetModeData(
  VOID
);

EFI_STATUS
EFIAPI
HtpConfigure(
  VOID
);

EFI_STATUS
EFIAPI
HttpRequest(
  VOID
);

EFI_STATUS
EFIAPI
HttpCancel(
  VOID
);

EFI_STATUS
EFIAPI
HttpResponse(
  VOID
);

EFI_STATUS
EFIAPI
HttpPoll(
  VOID
);

EFI_STATUS
EFIAPI
ComponentNameGetDriverName(
  VOID
);

EFI_STATUS
EFIAPI
ComponentNameGetControllerName(
  VOID
);

EFI_STATUS
EFIAPI
DriverConfigurationSetOptions(
  VOID
);

EFI_STATUS
EFIAPI
DriverConfigurationGetOptions(
  VOID
);

EFI_STATUS
EFIAPI
DriverConfigurationOptionsValid(
  VOID
);

EFI_STATUS
EFIAPI
HttpConfigureTcp4(
  VOID
);

EFI_STATUS
EFIAPI
HttpConfigureTcp6(
  VOID
);

EFI_STATUS
EFIAPI
HttpCloseConnection(
  VOID
);

EFI_STATUS
EFIAPI
HttpCancelAllTokens(
  VOID
);

EFI_STATUS
EFIAPI
HttpSendMessage(
  VOID
);

EFI_STATUS
EFIAPI
HttpReceiveMessage(
  VOID
);

EFI_STATUS
EFIAPI
HttpTcpReceiveNotify(
  VOID
);

EFI_STATUS
EFIAPI
HttpTcpReceiveNotifyDpc(
  VOID
);

EFI_STATUS
EFIAPI
HttpDns(
  VOID
);

EFI_STATUS
EFIAPI
HttpTlsConnect(
  VOID
);

EFI_STATUS
EFIAPI
HttpTlsClose(
  VOID
);

EFI_STATUS
EFIAPI
HttpTlsIsSessionActive(
  VOID
);

EFI_STATUS
EFIAPI
HttpInitSession(
  VOID
);

EFI_STATUS
EFIAPI
HttpCreateEvent(
  VOID
);

EFI_STATUS
EFIAPI
HttpGenerateRequest(
  VOID
);

EFI_STATUS
EFIAPI
HttpFreeRequestString(
  VOID
);

EFI_STATUS
EFIAPI
HttpSetResponseStatus(
  VOID
);

EFI_STATUS
EFIAPI
HttpFreeResponse(
  VOID
);

EFI_STATUS
EFIAPI
StrLenS(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrLenS(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrDecimalToUintnS(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrHexToUintnS(
  VOID
);

EFI_STATUS
EFIAPI
UnicodeStrToAsciiStrS(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrToUnicodeStrS(
  VOID
);

EFI_STATUS
EFIAPI
InitializeListHead(
  VOID
);

EFI_STATUS
EFIAPI
InsertHeadList(
  VOID
);

EFI_STATUS
EFIAPI
InsertTailList(
  VOID
);

EFI_STATUS
EFIAPI
IsListEmpty(
  VOID
);

EFI_STATUS
EFIAPI
InternalBaseLibIsListValid(
  VOID
);

EFI_STATUS
EFIAPI
GUIDs (from .rdata section)(
  VOID
);

EFI_STATUS
EFIAPI
gEfiLoadedImageProtocolGuid =(
  VOID
);

EFI_STATUS
EFIAPI
AMI HTTP protocol GUIDs(
  VOID
);

EFI_STATUS
EFIAPI
gAmiHttpServiceBindingProtocolGuid =(
  VOID
);

EFI_STATUS
EFIAPI
Protocol function table (installed on child handle)(
  VOID
);

EFI_STATUS
EFIAPI
mHttpProtocolTemplate = {(
  VOID
);

EFI_STATUS
EFIAPI
Binding Protocol function table(
  VOID
);

EFI_STATUS
EFIAPI
mDriverBinding = {(
  VOID
);

EFI_STATUS
EFIAPI
NULL,  // ImageHandle (filled in at entry)(
  VOID
);

EFI_STATUS
EFIAPI
(filled in by Install)(
  VOID
);

EFI_STATUS
EFIAPI
Name 2 Protocol(
  VOID
);

EFI_STATUS
EFIAPI
mComponentName2 = {(
  VOID
);

EFI_STATUS
EFIAPI
Languages(
  VOID
);

EFI_STATUS
EFIAPI
Driver Configuration 2 Protocol(
  VOID
);

EFI_STATUS
EFIAPI
mDriverConfiguration2 = {(
  VOID
);

EFI_STATUS
EFIAPI
Binding Protocol - installed per controller handle(
  VOID
);

EFI_STATUS
EFIAPI
mHttpServiceBinding = {(
  VOID
);

EFI_STATUS
EFIAPI
/ ASSERT support protocol GUID(
  VOID
);

EFI_STATUS
EFIAPI
gDebugProtocolGuid = {(
  VOID
);

EFI_STATUS
EFIAPI
macro with debug output(
  VOID
);

EFI_STATUS
EFIAPI
CPU index via CMOS port 0x70/0x71(
  VOID
);

EFI_STATUS
EFIAPI
= IoRead8 (0x70) & 0x80 | 0x4B;(
  VOID
);

EFI_STATUS
EFIAPI
protocol only if CPU index is valid (1-3)(
  VOID
);

EFI_STATUS
EFIAPI
((CpuIndex - 1) <= 0xFD) {(
  VOID
);

EFI_STATUS
EFIAPI
ENTRY POINT(
  VOID
);

EFI_STATUS
EFIAPI
library globals(
  VOID
);

EFI_STATUS
EFIAPI
(ImageHandle, SystemTable);(
  VOID
);

EFI_STATUS
EFIAPI
Loaded Image Protocol for this driver(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->OpenProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
the driver's unload handler(
  VOID
);

EFI_STATUS
EFIAPI
all driver protocols(
  VOID
);

EFI_STATUS
EFIAPI
HttpDxeDriverEntry (ImageHandle);(
  VOID
);

EFI_STATUS
EFIAPI
the DPC protocol(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->LocateProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
Driver Binding, Component Name, and Driver Configuration(
  VOID
);

EFI_STATUS
EFIAPI
= EfiLibInstallAllDriverProtocols2 ((
  VOID
);

EFI_STATUS
EFIAPI
Component Name(
  VOID
);

EFI_STATUS
EFIAPI
BINDING PROTOCOL(
  VOID
);

EFI_STATUS
EFIAPI
if controller already has our HTTP service binding protocol(
  VOID
);

EFI_STATUS
EFIAPI
and initialize service instance(
  VOID
);

EFI_STATUS
EFIAPI
= (HTTP_SERVICE *) AllocateZeroPool (sizeof (HTTP_SERVICE));(
  VOID
);

EFI_STATUS
EFIAPI
all handles on the system(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->LoocateHandleBuffer ((
  VOID
);

EFI_STATUS
EFIAPI
handles for child handles of this driver's controller(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < HandleCount; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
driver binding protocol(
  VOID
);

EFI_STATUS
EFIAPI
if this handle's parent is our controller(
  VOID
);

EFI_STATUS
EFIAPI
(LoadedImage->ParentDeviceHandle == ControllerHandle) {(
  VOID
);

EFI_STATUS
EFIAPI
a child handle - install our protocols on it(
  VOID
);

EFI_STATUS
EFIAPI
IP4 Config2 protocol on child(
  VOID
);

EFI_STATUS
EFIAPI
the service binding protocol on the parent(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->InstallMultipleProtocolInterfaces ((
  VOID
);

EFI_STATUS
EFIAPI
if we installed a service binding(
  VOID
);

EFI_STATUS
EFIAPI
(!EFI_ERROR (Status)) {(
  VOID
);

EFI_STATUS
EFIAPI
handles again to propagate IP4 Config2 and TCP protocols(
  VOID
);

EFI_STATUS
EFIAPI
(ChildIndex = 0; ChildIndex < HandleCount; ChildIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
Ip4Config2(
  VOID
);

EFI_STATUS
EFIAPI
Ip4Config2 on our child(
  VOID
);

EFI_STATUS
EFIAPI
our driver binding context from the controller(
  VOID
);

EFI_STATUS
EFIAPI
all child instances if requested(
  VOID
);

EFI_STATUS
EFIAPI
(NumberOfChildren == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
all children(
  VOID
);

EFI_STATUS
EFIAPI
(!IsListEmpty (&HttpService->ChildrenList)) {(
  VOID
);

EFI_STATUS
EFIAPI
our protocols from the controller(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->UninstallMultipleProtocolInterfaces ((
  VOID
);

EFI_STATUS
EFIAPI
the service instance(
  VOID
);

EFI_STATUS
EFIAPI
(HttpService);(
  VOID
);

EFI_STATUS
EFIAPI
specific children(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < NumberOfChildren; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
service instance from the protocol(
  VOID
);

EFI_STATUS
EFIAPI
= BASE_CR (This, HTTP_SERVICE, ServiceBinding);(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP instance(
  VOID
);

EFI_STATUS
EFIAPI
= (HTTP_INSTANCE *) AllocateZeroPool (sizeof (HTTP_INSTANCE));(
  VOID
);

EFI_STATUS
EFIAPI
instance fields(
  VOID
);

EFI_STATUS
EFIAPI
configured yet(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP protocol template(
  VOID
);

EFI_STATUS
EFIAPI
(&Instance->HttpProtocol, &mHttpProtocolTemplate, sizeof (EFI_HTTP_PROTOCOL));(
  VOID
);

EFI_STATUS
EFIAPI
request and response net buffers(
  VOID
);

EFI_STATUS
EFIAPI
(&Instance->RequestMap);(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP Utilities protocol for message parsing(
  VOID
);

EFI_STATUS
EFIAPI
a handle for the child(
  VOID
);

EFI_STATUS
EFIAPI
instance to service's child list(
  VOID
);

EFI_STATUS
EFIAPI
(&HttpService->ChildrenList, &Instance->Link);(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP protocol from child handle(
  VOID
);

EFI_STATUS
EFIAPI
instance signature(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->Signature != HTTP_INSTANCE_SIGNATURE) {(
  VOID
);

EFI_STATUS
EFIAPI
and clean up TCP connections(
  VOID
);

EFI_STATUS
EFIAPI
= HttpCloseConnection (Instance);(
  VOID
);

EFI_STATUS
EFIAPI
up any cached body data(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->CacheBody != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
up message parser(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->MsgParser != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
from parent's child list(
  VOID
);

EFI_STATUS
EFIAPI
(&Instance->Link);(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP protocol and free the instance(
  VOID
);

EFI_STATUS
EFIAPI
PROTOCOL IMPLEMENTATION(
  VOID
);

EFI_STATUS
EFIAPI
the stored configuration(
  VOID
);

EFI_STATUS
EFIAPI
other fields...(
  VOID
);

EFI_STATUS
EFIAPI
already configured, close existing connection(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->LocalAddressIsConfigured) {(
  VOID
);

EFI_STATUS
EFIAPI
configuration(
  VOID
);

EFI_STATUS
EFIAPI
Tcp6(
  VOID
);

EFI_STATUS
EFIAPI
= HttpConfigureTcp6 (Instance);(
  VOID
);

EFI_STATUS
EFIAPI
Tcp4(
  VOID
);

EFI_STATUS
EFIAPI
= HttpConfigureTcp4 (Instance);(
  VOID
);

EFI_STATUS
EFIAPI
state(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->Service == NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
token wrapper(
  VOID
);

EFI_STATUS
EFIAPI
= (HTTP_TOKEN_WRAP *) AllocateZeroPool (sizeof (HTTP_TOKEN_WRAP));(
  VOID
);

EFI_STATUS
EFIAPI
if using HTTPS(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->UseHttps) {(
  VOID
);

EFI_STATUS
EFIAPI
handshake first(
  VOID
);

EFI_STATUS
EFIAPI
= HttpTlsConnect (Instance);(
  VOID
);

EFI_STATUS
EFIAPI
the request via TCP(
  VOID
);

EFI_STATUS
EFIAPI
= HttpSendMessage (Wrap);(
  VOID
);

EFI_STATUS
EFIAPI
concurrent request limit(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->ConcurrentRequestCount <= 1) {(
  VOID
);

EFI_STATUS
EFIAPI
up on failure(
  VOID
);

EFI_STATUS
EFIAPI
(Wrap->Tcp4Token.CompletionToken.Event != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
if the instance is configured for IPv6(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->LocalAddressIsIPv6 != 0 && Instance->LocalAddressIsIPv6 != 4) {(
  VOID
);

EFI_STATUS
EFIAPI
to the internal cancel handler(
  VOID
);

EFI_STATUS
EFIAPI
HttpCancelInternal (Instance, HttpToken);(
  VOID
);

EFI_STATUS
EFIAPI
input(
  VOID
);

EFI_STATUS
EFIAPI
(HttpToken->HttpMessage->Data == NULL && HttpToken->HttpMessage->BodyLength > 0) {(
  VOID
);

EFI_STATUS
EFIAPI
signature(
  VOID
);

EFI_STATUS
EFIAPI
token wrapper and add to response queue(
  VOID
);

EFI_STATUS
EFIAPI
the token wrapper to the response event list(
  VOID
);

EFI_STATUS
EFIAPI
= NetEventAdd ((
  VOID
);

EFI_STATUS
EFIAPI
using HTTPS, receive through TLS(
  VOID
);

EFI_STATUS
EFIAPI
TCP receive(
  VOID
);

EFI_STATUS
EFIAPI
(!Instance->LocalAddressIsConfigured) {(
  VOID
);

EFI_STATUS
EFIAPI
if instance has TCP protocol(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->LocalAddressIsIPv6) {(
  VOID
);

EFI_STATUS
EFIAPI
NAME PROTOCOL(
  VOID
);

EFI_STATUS
EFIAPI
if "en" language is supported(
  VOID
);

EFI_STATUS
EFIAPI
(AsciiStrCmp (Language, "en") != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
CONFIGURATION 2 PROTOCOL(
  VOID
);

EFI_STATUS
EFIAPI
CONNECTION MANAGEMENT (HttpProto.c)(
  VOID
);

EFI_STATUS
EFIAPI
TCP4 protocol on the child handle(
  VOID
);

EFI_STATUS
EFIAPI
= NetLibCreateServiceChild ((
  VOID
);

EFI_STATUS
EFIAPI
up for receive notification(
  VOID
);

EFI_STATUS
EFIAPI
= HttpCreateEvent ((
  VOID
);

EFI_STATUS
EFIAPI
TCP6 protocol on the child handle(
  VOID
);

EFI_STATUS
EFIAPI
pending callbacks(
  VOID
);

EFI_STATUS
EFIAPI
(Instance);(
  VOID
);

EFI_STATUS
EFIAPI
up cache(
  VOID
);

EFI_STATUS
EFIAPI
TCP protocols(
  VOID
);

EFI_STATUS
EFIAPI
(Instance->Tcp4 != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
cancel Tcp4 tokens(
  VOID
);

EFI_STATUS
EFIAPI
service child for Tcp4(
  VOID
);

EFI_STATUS
EFIAPI
((
  VOID
);

EFI_STATUS
EFIAPI
Tcp6 tokens(
  VOID
);

EFI_STATUS
EFIAPI
service child for Tcp6(
  VOID
);

EFI_STATUS
EFIAPI
through request map and cancel all pending tokens(
  VOID
);

EFI_STATUS
EFIAPI
response map too(
  VOID
);

EFI_STATUS
EFIAPI
MESSAGE SENDING / RECEIVING (HttpProto.c)(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP request string from the message(
  VOID
);

EFI_STATUS
EFIAPI
= HttpGenerateRequest ((
  VOID
);

EFI_STATUS
EFIAPI
via Tcp4 or Tcp6(
  VOID
);

EFI_STATUS
EFIAPI
up the TCP6 transmit token(
  VOID
);

EFI_STATUS
EFIAPI
be filled by caller(
  VOID
);

EFI_STATUS
EFIAPI
fragment from net buffer(
  VOID
);

EFI_STATUS
EFIAPI
via Tcp6(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->Tcp6->Transmit (Instance->Tcp6, Tcp6Token);(
  VOID
);

EFI_STATUS
EFIAPI
up the TCP4 transmit token(
  VOID
);

EFI_STATUS
EFIAPI
via Tcp4(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->Tcp4->Transmit (Instance->Tcp4, Tcp4Token);(
  VOID
);

EFI_STATUS
EFIAPI
the net buffer(
  VOID
);

EFI_STATUS
EFIAPI
(Nbuf);(
  VOID
);

EFI_STATUS
EFIAPI
up TCP6 receive token(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->Tcp6->Receive (Instance->Tcp6, Tcp6Token);(
  VOID
);

EFI_STATUS
EFIAPI
up TCP4 receive token(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->Tcp4->Receive (Instance->Tcp4, Tcp4Token);(
  VOID
);

EFI_STATUS
EFIAPI
RECEIVE NOTIFICATION (Event/DPC Hander)(
  VOID
);

EFI_STATUS
EFIAPI
a DPC for processing(
  VOID
);

EFI_STATUS
EFIAPI
the TCP receive status(
  VOID
);

EFI_STATUS
EFIAPI
received data through message parser(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->MsgParser;(
  VOID
);

EFI_STATUS
EFIAPI
the received data(
  VOID
);

EFI_STATUS
EFIAPI
= Instance->ReceiveBuffer;(
  VOID
);

EFI_STATUS
EFIAPI
data to HTTP parser(
  VOID
);

EFI_STATUS
EFIAPI
= HttpParseMessageBody (Parser, Data, &BufferLength);(
  VOID
);

EFI_STATUS
EFIAPI
if full response has been received(
  VOID
);

EFI_STATUS
EFIAPI
(HttpIsMessageComplete (Parser)) {(
  VOID
);

EFI_STATUS
EFIAPI
out response status(
  VOID
);

EFI_STATUS
EFIAPI
(Parser, &Instance->ResponseStatus);(
  VOID
);

EFI_STATUS
EFIAPI
body data(
  VOID
);

EFI_STATUS
EFIAPI
(Parser, &Instance->ResponseBodyLength);(
  VOID
);

EFI_STATUS
EFIAPI
completion to the token(
  VOID
);

EFI_STATUS
EFIAPI
the waiting token(
  VOID
);

EFI_STATUS
EFIAPI
(Wrap->HttpMsg->Data.Event != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
RESOLUTION (HttpDns.c)(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP Utilities protocol to resolve the host name(
  VOID
);

EFI_STATUS
EFIAPI
= sizeof (EFI_IP_ADDRESS);(
  VOID
);

EFI_STATUS
EFIAPI
TLS protocol(
  VOID
);

EFI_STATUS
EFIAPI
TLS session data(
  VOID
);

EFI_STATUS
EFIAPI
TLS handshake(
  VOID
);

EFI_STATUS
EFIAPI
= Tls->Connect (Tls, Instance->RemoteHost);(
  VOID
);

EFI_STATUS
EFIAPI
TLS session state(
  VOID
);

EFI_STATUS
EFIAPI
= sizeof (EFI_TLS_SESSION_STATE);(
  VOID
);

EFI_STATUS
EFIAPI
TLS data in instance(
  VOID
);

EFI_STATUS
EFIAPI
INITILIZATIONIZATION AND URL URL PARSING(
  VOID
);

EFI_STATUS
EFIAPI
for HTTPS protocol(
  VOID
);

EFI_STATUS
EFIAPI
(AsciiStrStr (Url, HTTPS_PREFIX) == Url) {(
  VOID
);

EFI_STATUS
EFIAPI
the URL(
  VOID
);

EFI_STATUS
EFIAPI
= HttpUrlParse ((
  VOID
);

EFI_STATUS
EFIAPI
= no path required(
  VOID
);

EFI_STATUS
EFIAPI
host name(
  VOID
);

EFI_STATUS
EFIAPI
DNS if host is not an IP address(
  VOID
);

EFI_STATUS
EFIAPI
(!HttpUrlIsIpAddress (Instance->RemoteHost)) {(
  VOID
);

EFI_STATUS
EFIAPI
resolved address(
  VOID
);

EFI_STATUS
EFIAPI
path if present(
  VOID
);

EFI_STATUS
EFIAPI
CREATION AND AND MAP MANAGEMENT(
  VOID
);

EFI_STATUS
EFIAPI
event for TCP receive(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->CreateEvent ((
  VOID
);

EFI_STATUS
EFIAPI
context, set later(
  VOID
);

EFI_STATUS
EFIAPI
MESSAGE GENERATION(
  VOID
);

EFI_STATUS
EFIAPI
total header size(
  VOID
);

EFI_STATUS
EFIAPI
= HttpCalculateHeaderSize (HttpMsg->Headers, HttpMsg->HeaderCount);(
  VOID
);

EFI_STATUS
EFIAPI
buffer for request string(
  VOID
);

EFI_STATUS
EFIAPI
= (CHARR *) AllocateZeroPool (HeaderSize + 256); // Extra for request line and CRLF(
  VOID
);

EFI_STATUS
EFIAPI
the HTTP request line (METHOD URI HTTP/1.1)(
  VOID
);

EFI_STATUS
EFIAPI
= HttpRenderRequestLine ((
  VOID
);

EFI_STATUS
EFIAPI
headers(
  VOID
);

EFI_STATUS
EFIAPI
= HttpRenderHeaders ((
  VOID
);

EFI_STATUS
EFIAPI
body(
  VOID
);

EFI_STATUS
EFIAPI
(HttpMsg->BodyLength > 0) {(
  VOID
);

EFI_STATUS
EFIAPI
net buffer from the request string(
  VOID
);

EFI_STATUS
EFIAPI
CODES(
  VOID
);

EFI_STATUS
EFIAPI
message parser(
  VOID
);

EFI_STATUS
EFIAPI
any cached body(
  VOID
);

EFI_STATUS
EFIAPI
FUNCTIONS (linked statically)(
  VOID
);

EFI_STATUS
EFIAPI
leading whitespace(
  VOID
);

EFI_STATUS
EFIAPI
(*String == ' ' || *String == '\t') {(
  VOID
);

EFI_STATUS
EFIAPI
leading zeros(
  VOID
);

EFI_STATUS
EFIAPI
(*String == '0') {(
  VOID
);

EFI_STATUS
EFIAPI
for 0x or 0X prefix(
  VOID
);

EFI_STATUS
EFIAPI
(*String == 'x' || *String == 'X') {(
  VOID
);

EFI_STATUS
EFIAPI
LIST UTILIIES(
  VOID
);

EFI_STATUS
EFIAPI
list validation(
  VOID
);

EFI_STATUS
EFIAPI
(ListHead);(
  VOID
);

#endif /* __HTTPDXE_H__ */