2 Implementation of EFI_HTTP_PROTOCOL protocol interfaces.
4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "HttpDriver.h"
18 EFI_HTTP_PROTOCOL mEfiHttpTemplate
= {
28 Returns the operational parameters for the current HTTP child instance.
30 The GetModeData() function is used to read the current mode data (operational
31 parameters) for this HTTP protocol instance.
33 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
34 @param[out] HttpConfigData Point to buffer for operational parameters of this
37 @retval EFI_SUCCESS Operation succeeded.
38 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
40 HttpConfigData is NULL.
41 HttpConfigData->AccessPoint is NULL.
42 @retval EFI_NOT_STARTED The HTTP instance is not configured.
48 IN EFI_HTTP_PROTOCOL
*This
,
49 OUT EFI_HTTP_CONFIG_DATA
*HttpConfigData
52 HTTP_PROTOCOL
*HttpInstance
;
54 if ((This
== NULL
) || (HttpConfigData
== NULL
)) {
55 return EFI_INVALID_PARAMETER
;
58 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
59 ASSERT (HttpInstance
!= NULL
);
61 if (HttpInstance
->State
< HTTP_STATE_HTTP_CONFIGED
) {
62 return EFI_NOT_STARTED
;
65 if (HttpConfigData
->AccessPoint
.IPv4Node
== NULL
) {
66 return EFI_INVALID_PARAMETER
;
69 HttpConfigData
->HttpVersion
= HttpInstance
->HttpVersion
;
70 HttpConfigData
->TimeOutMillisec
= HttpInstance
->TimeOutMillisec
;
71 HttpConfigData
->LocalAddressIsIPv6
= HttpInstance
->LocalAddressIsIPv6
;
74 HttpConfigData
->AccessPoint
.IPv4Node
,
75 &HttpInstance
->IPv4Node
,
76 sizeof (HttpInstance
->IPv4Node
)
83 Initialize or brutally reset the operational parameters for this EFI HTTP instance.
85 The Configure() function does the following:
86 When HttpConfigData is not NULL Initialize this EFI HTTP instance by configuring
87 timeout, local address, port, etc.
88 When HttpConfigData is NULL, reset this EFI HTTP instance by closing all active
89 connections with remote hosts, canceling all asynchronous tokens, and flush request
90 and response buffers without informing the appropriate hosts.
92 Except for GetModeData() and Configure(), No other EFI HTTP function can be executed
93 by this instance until the Configure() function is executed and returns successfully.
95 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
96 @param[in] HttpConfigData Pointer to the configure data to configure the instance.
98 @retval EFI_SUCCESS Operation succeeded.
99 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
101 HttpConfigData->LocalAddressIsIPv6 is FALSE and
102 HttpConfigData->IPv4Node is NULL.
103 HttpConfigData->LocalAddressIsIPv6 is TRUE and
104 HttpConfigData->IPv6Node is NULL.
105 @retval EFI_ALREADY_STARTED Reinitialize this HTTP instance without calling
106 Configure() with NULL to reset it.
107 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
108 @retval EFI_OUT_OF_RESOURCES Could not allocate enough system resources when
109 executing Configure().
110 @retval EFI_UNSUPPORTED One or more options in HttpConfigData are not supported
111 in the implementation.
116 IN EFI_HTTP_PROTOCOL
*This
,
117 IN EFI_HTTP_CONFIG_DATA
*HttpConfigData
120 HTTP_PROTOCOL
*HttpInstance
;
124 return EFI_INVALID_PARAMETER
;
127 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
128 ASSERT (HttpInstance
!= NULL
&& HttpInstance
->Service
!= NULL
);
130 if (HttpConfigData
!= NULL
) {
132 // Check input parameters.
134 if (HttpConfigData
->LocalAddressIsIPv6
) {
135 if (HttpConfigData
->AccessPoint
.IPv6Node
== NULL
) {
136 return EFI_INVALID_PARAMETER
;
139 if (HttpConfigData
->AccessPoint
.IPv4Node
== NULL
) {
140 return EFI_INVALID_PARAMETER
;
144 // Now configure this HTTP instance.
146 if (HttpInstance
->State
!= HTTP_STATE_UNCONFIGED
) {
147 return EFI_ALREADY_STARTED
;
150 HttpInstance
->HttpVersion
= HttpConfigData
->HttpVersion
;
151 HttpInstance
->TimeOutMillisec
= HttpConfigData
->TimeOutMillisec
;
152 HttpInstance
->LocalAddressIsIPv6
= HttpConfigData
->LocalAddressIsIPv6
;
154 if (HttpConfigData
->LocalAddressIsIPv6
) {
155 return EFI_UNSUPPORTED
;
158 &HttpInstance
->IPv4Node
,
159 HttpConfigData
->AccessPoint
.IPv4Node
,
160 sizeof (HttpInstance
->IPv4Node
)
163 HttpInstance
->State
= HTTP_STATE_HTTP_CONFIGED
;
168 if (HttpInstance
->LocalAddressIsIPv6
) {
169 return EFI_UNSUPPORTED
;
171 HttpCleanProtocol (HttpInstance
);
172 Status
= HttpInitProtocol (HttpInstance
->Service
, HttpInstance
);
173 if (EFI_ERROR (Status
)) {
177 HttpInstance
->State
= HTTP_STATE_UNCONFIGED
;
185 The Request() function queues an HTTP request to this HTTP instance.
187 Similar to Transmit() function in the EFI TCP driver. When the HTTP request is sent
188 successfully, or if there is an error, Status in token will be updated and Event will
191 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
192 @param[in] Token Pointer to storage containing HTTP request token.
194 @retval EFI_SUCCESS Outgoing data was processed.
195 @retval EFI_NOT_STARTED This EFI HTTP Protocol instance has not been started.
196 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
197 @retval EFI_TIMEOUT Data was dropped out of the transmit or receive queue.
198 @retval EFI_OUT_OF_RESOURCES Could not allocate enough system resources.
199 @retval EFI_UNSUPPORTED The HTTP method is not supported in current
201 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
203 Token->Message is NULL.
204 Token->Message->Body is not NULL,
205 Token->Message->BodyLength is non-zero, and
206 Token->Message->Data is NULL, but a previous call to
207 Request()has not been completed successfully.
212 IN EFI_HTTP_PROTOCOL
*This
,
213 IN EFI_HTTP_TOKEN
*Token
216 EFI_HTTP_MESSAGE
*HttpMsg
;
217 EFI_HTTP_REQUEST_DATA
*Request
;
222 HTTP_PROTOCOL
*HttpInstance
;
228 HTTP_TOKEN_WRAP
*Wrap
;
229 HTTP_TCP_TOKEN_WRAP
*TcpWrap
;
232 if ((This
== NULL
) || (Token
== NULL
)) {
233 return EFI_INVALID_PARAMETER
;
236 HttpMsg
= Token
->Message
;
237 if ((HttpMsg
== NULL
) || (HttpMsg
->Headers
== NULL
)) {
238 return EFI_INVALID_PARAMETER
;
242 // Current implementation does not support POST/PUT method.
243 // If future version supports these two methods, Request could be NULL for a special case that to send large amounts
244 // of data. For this case, the implementation need check whether previous call to Request() has been completed or not.
247 Request
= HttpMsg
->Data
.Request
;
248 if ((Request
== NULL
) || (Request
->Url
== NULL
)) {
249 return EFI_INVALID_PARAMETER
;
253 // Only support GET and HEAD method in current implementation.
255 if ((Request
->Method
!= HttpMethodGet
) && (Request
->Method
!= HttpMethodHead
)) {
256 return EFI_UNSUPPORTED
;
259 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
260 ASSERT (HttpInstance
!= NULL
);
262 if (HttpInstance
->State
< HTTP_STATE_HTTP_CONFIGED
) {
263 return EFI_NOT_STARTED
;
266 if (HttpInstance
->LocalAddressIsIPv6
) {
267 return EFI_UNSUPPORTED
;
271 // Check whether the token already existed.
273 if (EFI_ERROR (NetMapIterate (&HttpInstance
->TxTokens
, HttpTokenExist
, Token
))) {
274 return EFI_ACCESS_DENIED
;
284 // Parse the URI of the remote host.
286 Url
= AllocatePool (StrLen (Request
->Url
) + 1);
288 return EFI_OUT_OF_RESOURCES
;
291 UnicodeStrToAsciiStr (Request
->Url
, Url
);
293 Status
= HttpParseUrl (Url
, (UINT32
) AsciiStrLen (Url
), FALSE
, &UrlParser
);
294 if (EFI_ERROR (Status
)) {
300 Status
= HttpUrlGetHostName (Url
, UrlParser
, &HostName
);
301 if (EFI_ERROR (Status
)) {
305 Status
= HttpUrlGetPort (Url
, UrlParser
, &RemotePort
);
306 if (EFI_ERROR (Status
)) {
307 RemotePort
= HTTP_DEFAULT_PORT
;
313 if (HttpInstance
->RemoteHost
== NULL
&& HttpInstance
->RemotePort
== 0) {
315 // Request() is called the first time.
319 if ((HttpInstance
->RemotePort
== RemotePort
) &&
320 (AsciiStrCmp (HttpInstance
->RemoteHost
, HostName
) == 0)) {
322 // Host Name and port number of the request URL are the same with previous call to Request().
323 // Check whether previous TCP packet sent out.
325 if (EFI_ERROR (NetMapIterate (&HttpInstance
->TxTokens
, HttpTcpNotReady
, NULL
))) {
327 // Wrap the HTTP token in HTTP_TOKEN_WRAP
329 Wrap
= AllocateZeroPool (sizeof (HTTP_TOKEN_WRAP
));
331 Status
= EFI_OUT_OF_RESOURCES
;
335 Wrap
->HttpToken
= Token
;
336 Wrap
->HttpInstance
= HttpInstance
;
338 Status
= HttpCreateTcp4TxEvent (Wrap
);
339 if (EFI_ERROR (Status
)) {
343 Status
= NetMapInsertTail (&HttpInstance
->TxTokens
, Token
, Wrap
);
344 if (EFI_ERROR (Status
)) {
348 Wrap
->TcpWrap
.Method
= Request
->Method
;
354 // Queue the HTTP token and return.
359 // Use existing TCP instance to transmit the packet.
366 // Need close existing TCP instance and create a new TCP instance for data transmit.
368 if (HttpInstance
->RemoteHost
!= NULL
) {
369 FreePool (HttpInstance
->RemoteHost
);
370 HttpInstance
->RemoteHost
= NULL
;
377 // Parse Url for IPv4 address, if failed, perform DNS resolution.
379 Status
= NetLibAsciiStrToIp4 (HostName
, &HttpInstance
->RemoteAddr
);
380 if (EFI_ERROR (Status
)) {
381 HostNameStr
= AllocateZeroPool ((AsciiStrLen (HostName
) + 1) * sizeof (UINT16
));
382 if (HostNameStr
== NULL
) {
383 Status
= EFI_OUT_OF_RESOURCES
;
387 AsciiStrToUnicodeStr (HostName
, HostNameStr
);
388 Status
= HttpDns4 (HttpInstance
, HostNameStr
, &HttpInstance
->RemoteAddr
);
389 FreePool (HostNameStr
);
390 if (EFI_ERROR (Status
)) {
396 // Save the RemotePort and RemoteHost.
398 ASSERT (HttpInstance
->RemoteHost
== NULL
);
399 HttpInstance
->RemotePort
= RemotePort
;
400 HttpInstance
->RemoteHost
= HostName
;
406 // The request URL is different from previous calls to Request(), close existing TCP instance.
408 ASSERT (HttpInstance
->Tcp4
!= NULL
);
409 HttpCloseConnection (HttpInstance
);
410 EfiHttpCancel (This
, NULL
);
414 // Wrap the HTTP token in HTTP_TOKEN_WRAP
416 Wrap
= AllocateZeroPool (sizeof (HTTP_TOKEN_WRAP
));
418 Status
= EFI_OUT_OF_RESOURCES
;
422 Wrap
->HttpToken
= Token
;
423 Wrap
->HttpInstance
= HttpInstance
;
424 Wrap
->TcpWrap
.Method
= Request
->Method
;
428 // Configure TCP instance.
430 Status
= HttpConfigureTcp4 (HttpInstance
, Wrap
);
431 if (EFI_ERROR (Status
)) {
437 Status
= HttpConnectTcp4 (HttpInstance
);
438 if (EFI_ERROR (Status
)) {
443 // For the new HTTP token, create TX TCP token events.
445 Status
= HttpCreateTcp4TxEvent (Wrap
);
446 if (EFI_ERROR (Status
)) {
452 // Create request message.
455 if (*FileUrl
!= '/') {
457 // Convert the absolute-URI to the absolute-path
459 while (*FileUrl
!= ':') {
462 if ((*(FileUrl
+1) == '/') && (*(FileUrl
+2) == '/')) {
464 while (*FileUrl
!= '/') {
468 Status
= EFI_INVALID_PARAMETER
;
472 RequestStr
= HttpGenRequestString (HttpInstance
, HttpMsg
, FileUrl
);
473 if (RequestStr
== NULL
) {
474 Status
= EFI_OUT_OF_RESOURCES
;
478 Status
= NetMapInsertTail (&HttpInstance
->TxTokens
, Token
, Wrap
);
479 if (EFI_ERROR (Status
)) {
484 if (HostName
!= NULL
) {
489 // Transmit the request message.
491 Status
= HttpTransmitTcp4 (
495 AsciiStrLen (RequestStr
)
497 if (EFI_ERROR (Status
)) {
504 NetMapRemoveTail (&HttpInstance
->TxTokens
, NULL
);
507 if (RequestStr
!= NULL
) {
508 FreePool (RequestStr
);
512 HttpCloseConnection (HttpInstance
);
516 HttpCloseTcp4ConnCloseEvent (HttpInstance
);
517 if (NULL
!= Wrap
->TcpWrap
.TxToken
.CompletionToken
.Event
) {
518 gBS
->CloseEvent (Wrap
->TcpWrap
.TxToken
.CompletionToken
.Event
);
519 Wrap
->TcpWrap
.TxToken
.CompletionToken
.Event
= NULL
;
526 if (HostName
!= NULL
) {
532 if (UrlParser
!= NULL
) {
533 HttpUrlFreeParser (UrlParser
);
541 Cancel a TxToken or RxToken.
543 @param[in] Map The HTTP instance's token queue.
544 @param[in] Item Object container for one HTTP token and token's wrap.
545 @param[in] Context The user's token to cancel.
547 @retval EFI_SUCCESS Continue to check the next Item.
548 @retval EFI_ABORTED The user's Token (Token != NULL) is cancelled.
555 IN NET_MAP_ITEM
*Item
,
560 EFI_HTTP_TOKEN
*Token
;
561 HTTP_TOKEN_WRAP
*Wrap
;
563 Token
= (EFI_HTTP_TOKEN
*) Context
;
566 // Return EFI_SUCCESS to check the next item in the map if
567 // this one doesn't match.
569 if ((Token
!= NULL
) && (Token
!= Item
->Key
)) {
573 Wrap
= (HTTP_TOKEN_WRAP
*) Item
->Value
;
574 ASSERT (Wrap
!= NULL
);
579 NetMapRemoveItem (Map
, Item
, NULL
);
581 if (Wrap
->TcpWrap
.TxToken
.CompletionToken
.Event
!= NULL
) {
582 gBS
->CloseEvent (Wrap
->TcpWrap
.TxToken
.CompletionToken
.Event
);
585 if (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
!= NULL
) {
586 gBS
->CloseEvent (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
);
589 if (Wrap
->TcpWrap
.RxToken
.Packet
.RxData
->FragmentTable
[0].FragmentBuffer
!= NULL
) {
590 FreePool (Wrap
->TcpWrap
.RxToken
.Packet
.RxData
->FragmentTable
[0].FragmentBuffer
);
596 // If only one item is to be cancel, return EFI_ABORTED to stop
597 // iterating the map any more.
607 Cancel the user's receive/transmit request. It is the worker function of
608 EfiHttpCancel API. If a matching token is found, it will call HttpCancelTokens to cancel the
611 @param[in] HttpInstance Pointer to HTTP_PROTOCOL structure.
612 @param[in] Token The token to cancel. If NULL, all token will be
615 @retval EFI_SUCCESS The token is cancelled.
616 @retval EFI_NOT_FOUND The asynchronous request or response token is not found.
617 @retval Others Other error as indicated.
622 IN HTTP_PROTOCOL
*HttpInstance
,
623 IN EFI_HTTP_TOKEN
*Token
629 // First check the tokens queued by EfiHttpRequest().
631 Status
= NetMapIterate (&HttpInstance
->TxTokens
, HttpCancelTokens
, Token
);
632 if (EFI_ERROR (Status
)) {
634 if (Status
== EFI_ABORTED
) {
643 // Then check the tokens queued by EfiHttpResponse().
645 Status
= NetMapIterate (&HttpInstance
->RxTokens
, HttpCancelTokens
, Token
);
646 if (EFI_ERROR (Status
)) {
648 if (Status
== EFI_ABORTED
) {
651 return EFI_NOT_FOUND
;
663 Abort an asynchronous HTTP request or response token.
665 The Cancel() function aborts a pending HTTP request or response transaction. If
666 Token is not NULL and the token is in transmit or receive queues when it is being
667 cancelled, its Token->Status will be set to EFI_ABORTED and then Token->Event will
668 be signaled. If the token is not in one of the queues, which usually means that the
669 asynchronous operation has completed, EFI_NOT_FOUND is returned. If Token is NULL,
670 all asynchronous tokens issued by Request() or Response() will be aborted.
672 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
673 @param[in] Token Point to storage containing HTTP request or response
676 @retval EFI_SUCCESS Request and Response queues are successfully flushed.
677 @retval EFI_INVALID_PARAMETER This is NULL.
678 @retval EFI_NOT_STARTED This instance hasn't been configured.
679 @retval EFI_NO_MAPPING When using the default address, configuration (DHCP,
680 BOOTP, RARP, etc.) hasn't finished yet.
681 @retval EFI_NOT_FOUND The asynchronous request or response token is not
683 @retval EFI_UNSUPPORTED The implementation does not support this function.
689 IN EFI_HTTP_PROTOCOL
*This
,
690 IN EFI_HTTP_TOKEN
*Token
693 HTTP_PROTOCOL
*HttpInstance
;
696 return EFI_INVALID_PARAMETER
;
699 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
700 ASSERT (HttpInstance
!= NULL
);
702 if (HttpInstance
->State
!= HTTP_STATE_TCP_CONNECTED
) {
703 return EFI_NOT_STARTED
;
706 return HttpCancel (HttpInstance
, Token
);
711 A callback function to intercept events during message parser.
713 This function will be invoked during HttpParseMessageBody() with various events type. An error
714 return status of the callback function will cause the HttpParseMessageBody() aborted.
716 @param[in] EventType Event type of this callback call.
717 @param[in] Data A pointer to data buffer.
718 @param[in] Length Length in bytes of the Data.
719 @param[in] Context Callback context set by HttpInitMsgParser().
721 @retval EFI_SUCCESS Continue to parser the message body.
726 HttpBodyParserCallback (
727 IN HTTP_BODY_PARSE_EVENT EventType
,
733 HTTP_TOKEN_WRAP
*Wrap
;
735 if (EventType
!= BodyParseEventOnComplete
) {
739 if (Data
== NULL
|| Length
!= 0 || Context
== NULL
) {
743 Wrap
= (HTTP_TOKEN_WRAP
*) Context
;
744 Wrap
->HttpInstance
->NextMsg
= Data
;
747 // Free TxToken since already received corrsponding HTTP response.
755 The work function of EfiHttpResponse().
757 @param[in] Wrap Pointer to HTTP token's wrap data.
759 @retval EFI_SUCCESS Allocation succeeded.
760 @retval EFI_OUT_OF_RESOURCES Failed to complete the opration due to lack of resources.
761 @retval EFI_NOT_READY Can't find a corresponding TxToken or
762 the EFI_HTTP_UTILITIES_PROTOCOL is not available.
767 IN HTTP_TOKEN_WRAP
*Wrap
771 EFI_HTTP_MESSAGE
*HttpMsg
;
772 EFI_TCP4_IO_TOKEN
*RxToken
;
773 EFI_TCP4_PROTOCOL
*Tcp4
;
782 CHAR8
*StatusCodeStr
;
784 HTTP_PROTOCOL
*HttpInstance
;
785 EFI_HTTP_TOKEN
*Token
;
787 HTTP_TOKEN_WRAP
*ValueInItem
;
790 if (Wrap
== NULL
|| Wrap
->HttpInstance
== NULL
) {
791 return EFI_INVALID_PARAMETER
;
794 HttpInstance
= Wrap
->HttpInstance
;
795 Token
= Wrap
->HttpToken
;
797 HttpMsg
= Token
->Message
;
799 Tcp4
= HttpInstance
->Tcp4
;
800 ASSERT (Tcp4
!= NULL
);
801 HttpMsg
->Headers
= NULL
;
808 if (HttpMsg
->Data
.Response
!= NULL
) {
810 // Need receive the HTTP headers, prepare buffer.
812 Status
= HttpCreateTcp4RxEventForHeader (HttpInstance
);
813 if (EFI_ERROR (Status
)) {
818 // Check whether we have cached header from previous call.
820 if ((HttpInstance
->CacheBody
!= NULL
) && (HttpInstance
->NextMsg
!= NULL
)) {
822 // The data is stored at [NextMsg, CacheBody + CacheLen].
824 HdrLen
= HttpInstance
->CacheBody
+ HttpInstance
->CacheLen
- HttpInstance
->NextMsg
;
825 HttpHeaders
= AllocateZeroPool (HdrLen
);
826 if (HttpHeaders
== NULL
) {
827 Status
= EFI_OUT_OF_RESOURCES
;
831 CopyMem (HttpHeaders
, HttpInstance
->NextMsg
, HdrLen
);
832 FreePool (HttpInstance
->CacheBody
);
833 HttpInstance
->CacheBody
= NULL
;
834 HttpInstance
->NextMsg
= NULL
;
835 HttpInstance
->CacheOffset
= 0;
836 SizeofHeaders
= HdrLen
;
837 BufferSize
= HttpInstance
->CacheLen
;
840 // Check whether we cached the whole HTTP headers.
842 EndofHeader
= AsciiStrStr (HttpHeaders
, HTTP_END_OF_HDR_STR
);
845 RxToken
= &HttpInstance
->RxToken
;
846 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
= AllocateZeroPool (DEF_BUF_LEN
);
847 if (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
== NULL
) {
848 Status
= EFI_OUT_OF_RESOURCES
;
853 // Receive the HTTP headers only when EFI_HTTP_RESPONSE_DATA is not NULL.
855 while (EndofHeader
== NULL
) {
856 HttpInstance
->IsRxDone
= FALSE
;
857 RxToken
->Packet
.RxData
->DataLength
= DEF_BUF_LEN
;
858 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentLength
= DEF_BUF_LEN
;
859 Status
= Tcp4
->Receive (Tcp4
, RxToken
);
860 if (EFI_ERROR (Status
)) {
861 DEBUG ((EFI_D_ERROR
, "Tcp4 receive failed: %r\n", Status
));
865 while (!HttpInstance
->IsRxDone
) {
869 Status
= RxToken
->CompletionToken
.Status
;
870 if (EFI_ERROR (Status
)) {
875 // Append the response string.
877 BufferSize
= SizeofHeaders
+ RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentLength
;
878 Buffer
= AllocateZeroPool (BufferSize
);
879 if (Buffer
== NULL
) {
880 Status
= EFI_OUT_OF_RESOURCES
;
884 if (HttpHeaders
!= NULL
) {
885 CopyMem (Buffer
, HttpHeaders
, SizeofHeaders
);
886 FreePool (HttpHeaders
);
890 Buffer
+ SizeofHeaders
,
891 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
,
892 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentLength
894 HttpHeaders
= Buffer
;
895 SizeofHeaders
= BufferSize
;
898 // Check whether we received end of HTTP headers.
900 EndofHeader
= AsciiStrStr (HttpHeaders
, HTTP_END_OF_HDR_STR
);
904 // Skip the CRLF after the HTTP headers.
906 EndofHeader
= EndofHeader
+ AsciiStrLen (HTTP_END_OF_HDR_STR
);
909 // Cache the part of body.
911 BodyLen
= BufferSize
- (EndofHeader
- HttpHeaders
);
913 if (HttpInstance
->CacheBody
!= NULL
) {
914 FreePool (HttpInstance
->CacheBody
);
917 HttpInstance
->CacheBody
= AllocateZeroPool (BodyLen
);
918 if (HttpInstance
->CacheBody
== NULL
) {
919 Status
= EFI_OUT_OF_RESOURCES
;
923 CopyMem (HttpInstance
->CacheBody
, EndofHeader
, BodyLen
);
924 HttpInstance
->CacheLen
= BodyLen
;
927 FreePool (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
);
928 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
= NULL
;
931 // Search for Status Code.
933 StatusCodeStr
= HttpHeaders
+ AsciiStrLen (HTTP_VERSION_STR
) + 1;
934 if (StatusCodeStr
== NULL
) {
938 StatusCode
= AsciiStrDecimalToUintn (StatusCodeStr
);
941 // Remove the first line of HTTP message, e.g. "HTTP/1.1 200 OK\r\n".
943 Tmp
= AsciiStrStr (HttpHeaders
, HTTP_CRLF_STR
);
948 Tmp
= Tmp
+ AsciiStrLen (HTTP_CRLF_STR
);
949 SizeofHeaders
= SizeofHeaders
- (Tmp
- HttpHeaders
);
950 HeaderTmp
= AllocateZeroPool (SizeofHeaders
);
951 if (HeaderTmp
== NULL
) {
955 CopyMem (HeaderTmp
, Tmp
, SizeofHeaders
);
956 FreePool (HttpHeaders
);
957 HttpHeaders
= HeaderTmp
;
960 // Check whether the EFI_HTTP_UTILITIES_PROTOCOL is available.
962 if (mHttpUtilities
== NULL
) {
963 Status
= EFI_NOT_READY
;
968 // Parse the HTTP header into array of key/value pairs.
970 Status
= mHttpUtilities
->Parse (
975 &HttpMsg
->HeaderCount
977 if (EFI_ERROR (Status
)) {
981 FreePool (HttpHeaders
);
984 HttpMsg
->Data
.Response
->StatusCode
= HttpMappingToStatusCode (StatusCode
);
987 // Init message-body parser by header information.
989 Status
= EFI_NOT_READY
;
991 NetMapRemoveHead (&HttpInstance
->TxTokens
, (VOID
**) &ValueInItem
);
992 if (ValueInItem
== NULL
) {
997 // The first TxToken not transmitted yet, insert back and return error.
999 if (!ValueInItem
->TcpWrap
.IsTxDone
) {
1003 Status
= HttpInitMsgParser (
1004 ValueInItem
->TcpWrap
.Method
,
1005 HttpMsg
->Data
.Response
->StatusCode
,
1006 HttpMsg
->HeaderCount
,
1008 HttpBodyParserCallback
,
1009 (VOID
*) ValueInItem
,
1010 &HttpInstance
->MsgParser
1012 if (EFI_ERROR (Status
)) {
1017 // Check whether we received a complete HTTP message.
1019 if (HttpInstance
->CacheBody
!= NULL
) {
1020 Status
= HttpParseMessageBody (HttpInstance
->MsgParser
, HttpInstance
->CacheLen
, HttpInstance
->CacheBody
);
1021 if (EFI_ERROR (Status
)) {
1025 if (HttpIsMessageComplete (HttpInstance
->MsgParser
)) {
1027 // Free the MsgParse since we already have a full HTTP message.
1029 HttpFreeMsgParser (HttpInstance
->MsgParser
);
1030 HttpInstance
->MsgParser
= NULL
;
1034 if ((HttpMsg
->Body
== NULL
) || (HttpMsg
->BodyLength
== 0)) {
1035 Status
= EFI_SUCCESS
;
1041 // Receive the response body.
1046 // First check whether we cached some data.
1048 if (HttpInstance
->CacheBody
!= NULL
) {
1050 // Calculate the length of the cached data.
1052 if (HttpInstance
->NextMsg
!= NULL
) {
1054 // We have a cached HTTP message which includes a part of HTTP header of next message.
1056 BodyLen
= HttpInstance
->NextMsg
- (HttpInstance
->CacheBody
+ HttpInstance
->CacheOffset
);
1058 BodyLen
= HttpInstance
->CacheLen
- HttpInstance
->CacheOffset
;
1063 // We have some cached data. Just copy the data and return.
1065 if (HttpMsg
->BodyLength
< BodyLen
) {
1066 CopyMem (HttpMsg
->Body
, HttpInstance
->CacheBody
+ HttpInstance
->CacheOffset
, HttpMsg
->BodyLength
);
1067 HttpInstance
->CacheOffset
= HttpInstance
->CacheOffset
+ HttpMsg
->BodyLength
;
1070 // Copy all cached data out.
1072 CopyMem (HttpMsg
->Body
, HttpInstance
->CacheBody
+ HttpInstance
->CacheOffset
, BodyLen
);
1073 HttpInstance
->CacheOffset
= BodyLen
+ HttpInstance
->CacheOffset
;
1074 HttpMsg
->BodyLength
= BodyLen
;
1076 if (HttpInstance
->NextMsg
== NULL
) {
1078 // There is no HTTP header of next message. Just free the cache buffer.
1080 FreePool (HttpInstance
->CacheBody
);
1081 HttpInstance
->CacheBody
= NULL
;
1082 HttpInstance
->NextMsg
= NULL
;
1083 HttpInstance
->CacheOffset
= 0;
1087 // Return since we aready received required data.
1089 Status
= EFI_SUCCESS
;
1093 if (BodyLen
== 0 && HttpInstance
->MsgParser
== NULL
) {
1095 // We received a complete HTTP message, and we don't have more data to return to caller.
1097 HttpMsg
->BodyLength
= 0;
1098 Status
= EFI_SUCCESS
;
1103 ASSERT (HttpInstance
->MsgParser
!= NULL
);
1106 // We still need receive more data when there is no cache data and MsgParser is not NULL;
1108 RxToken
= &Wrap
->TcpWrap
.RxToken
;
1110 RxToken
->Packet
.RxData
->DataLength
= (UINT32
) HttpMsg
->BodyLength
;
1111 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentLength
= (UINT32
) HttpMsg
->BodyLength
;
1112 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
= (VOID
*) HttpMsg
->Body
;
1114 RxToken
->CompletionToken
.Status
= EFI_NOT_READY
;
1115 Status
= Tcp4
->Receive (Tcp4
, RxToken
);
1116 if (EFI_ERROR (Status
)) {
1117 DEBUG ((EFI_D_ERROR
, "Tcp4 receive failed: %r\n", Status
));
1124 Item
= NetMapFindKey (&Wrap
->HttpInstance
->RxTokens
, Wrap
->HttpToken
);
1126 NetMapRemoveItem (&Wrap
->HttpInstance
->RxTokens
, Item
, NULL
);
1128 Token
->Status
= Status
;
1129 gBS
->SignalEvent (Token
->Event
);
1134 NetMapInsertHead (&HttpInstance
->TxTokens
, ValueInItem
->HttpToken
, ValueInItem
);
1138 if (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
!= NULL
) {
1139 gBS
->CloseEvent (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
);
1141 RxToken
= &Wrap
->TcpWrap
.RxToken
;
1142 if (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
!= NULL
) {
1143 FreePool (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
);
1144 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
= NULL
;
1149 if (HttpInstance
->RxToken
.CompletionToken
.Event
!= NULL
) {
1150 gBS
->CloseEvent (HttpInstance
->RxToken
.CompletionToken
.Event
);
1151 HttpInstance
->RxToken
.CompletionToken
.Event
= NULL
;
1154 RxToken
= &HttpInstance
->RxToken
;
1155 if (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
!= NULL
) {
1156 FreePool (RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
);
1157 RxToken
->Packet
.RxData
->FragmentTable
[0].FragmentBuffer
= NULL
;
1160 if (HttpHeaders
!= NULL
) {
1161 FreePool (HttpHeaders
);
1164 if (HttpMsg
->Headers
!= NULL
) {
1165 FreePool (HttpMsg
->Headers
);
1168 if (HttpInstance
->CacheBody
!= NULL
) {
1169 FreePool (HttpInstance
->CacheBody
);
1170 HttpInstance
->CacheBody
= NULL
;
1173 Token
->Status
= Status
;
1174 gBS
->SignalEvent (Token
->Event
);
1182 The Response() function queues an HTTP response to this HTTP instance, similar to
1183 Receive() function in the EFI TCP driver. When the HTTP request is sent successfully,
1184 or if there is an error, Status in token will be updated and Event will be signaled.
1186 The HTTP driver will queue a receive token to the underlying TCP instance. When data
1187 is received in the underlying TCP instance, the data will be parsed and Token will
1188 be populated with the response data. If the data received from the remote host
1189 contains an incomplete or invalid HTTP header, the HTTP driver will continue waiting
1190 (asynchronously) for more data to be sent from the remote host before signaling
1193 It is the responsibility of the caller to allocate a buffer for Body and specify the
1194 size in BodyLength. If the remote host provides a response that contains a content
1195 body, up to BodyLength bytes will be copied from the receive buffer into Body and
1196 BodyLength will be updated with the amount of bytes received and copied to Body. This
1197 allows the client to download a large file in chunks instead of into one contiguous
1198 block of memory. Similar to HTTP request, if Body is not NULL and BodyLength is
1199 non-zero and all other fields are NULL or 0, the HTTP driver will queue a receive
1200 token to underlying TCP instance. If data arrives in the receive buffer, up to
1201 BodyLength bytes of data will be copied to Body. The HTTP driver will then update
1202 BodyLength with the amount of bytes received and copied to Body.
1204 If the HTTP driver does not have an open underlying TCP connection with the host
1205 specified in the response URL, Request() will return EFI_ACCESS_DENIED. This is
1206 consistent with RFC 2616 recommendation that HTTP clients should attempt to maintain
1207 an open TCP connection between client and host.
1209 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
1210 @param[in] Token Pointer to storage containing HTTP response token.
1212 @retval EFI_SUCCESS Allocation succeeded.
1213 @retval EFI_NOT_STARTED This EFI HTTP Protocol instance has not been
1215 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
1218 Token->Message->Headers is NULL.
1219 Token->Message is NULL.
1220 Token->Message->Body is not NULL,
1221 Token->Message->BodyLength is non-zero, and
1222 Token->Message->Data is NULL, but a previous call to
1223 Response() has not been completed successfully.
1224 @retval EFI_OUT_OF_RESOURCES Could not allocate enough system resources.
1225 @retval EFI_ACCESS_DENIED An open TCP connection is not present with the host
1226 specified by response URL.
1231 IN EFI_HTTP_PROTOCOL
*This
,
1232 IN EFI_HTTP_TOKEN
*Token
1236 EFI_HTTP_MESSAGE
*HttpMsg
;
1237 HTTP_PROTOCOL
*HttpInstance
;
1238 HTTP_TOKEN_WRAP
*Wrap
;
1240 if ((This
== NULL
) || (Token
== NULL
)) {
1241 return EFI_INVALID_PARAMETER
;
1244 HttpMsg
= Token
->Message
;
1245 if (HttpMsg
== NULL
) {
1246 return EFI_INVALID_PARAMETER
;
1249 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
1250 ASSERT (HttpInstance
!= NULL
);
1252 if (HttpInstance
->State
!= HTTP_STATE_TCP_CONNECTED
) {
1253 return EFI_NOT_STARTED
;
1256 if (HttpInstance
->LocalAddressIsIPv6
) {
1257 return EFI_UNSUPPORTED
;
1261 // Check whether the token already existed.
1263 if (EFI_ERROR (NetMapIterate (&HttpInstance
->RxTokens
, HttpTokenExist
, Token
))) {
1264 return EFI_ACCESS_DENIED
;
1267 Wrap
= AllocateZeroPool (sizeof (HTTP_TOKEN_WRAP
));
1269 return EFI_OUT_OF_RESOURCES
;
1272 Wrap
->HttpInstance
= HttpInstance
;
1273 Wrap
->HttpToken
= Token
;
1275 Status
= HttpCreateTcp4RxEvent (Wrap
);
1276 if (EFI_ERROR (Status
)) {
1280 Status
= NetMapInsertTail (&HttpInstance
->RxTokens
, Token
, Wrap
);
1281 if (EFI_ERROR (Status
)) {
1286 // If already have pending RxTokens, return directly.
1288 if (NetMapGetCount (&HttpInstance
->RxTokens
) > 1) {
1292 return HttpResponseWorker (Wrap
);
1296 if (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
!= NULL
) {
1297 gBS
->CloseEvent (Wrap
->TcpWrap
.RxToken
.CompletionToken
.Event
);
1306 The Poll() function can be used by network drivers and applications to increase the
1307 rate that data packets are moved between the communication devices and the transmit
1310 In some systems, the periodic timer event in the managed network driver may not poll
1311 the underlying communications device fast enough to transmit and/or receive all data
1312 packets without missing incoming packets or dropping outgoing packets. Drivers and
1313 applications that are experiencing packet loss should try calling the Poll() function
1316 @param[in] This Pointer to EFI_HTTP_PROTOCOL instance.
1318 @retval EFI_SUCCESS Incoming or outgoing data was processed.
1319 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
1320 @retval EFI_INVALID_PARAMETER This is NULL.
1321 @retval EFI_NOT_READY No incoming or outgoing data is processed.
1322 @retval EFI_NOT_STARTED This EFI HTTP Protocol instance has not been started.
1328 IN EFI_HTTP_PROTOCOL
*This
1331 HTTP_PROTOCOL
*HttpInstance
;
1334 return EFI_INVALID_PARAMETER
;
1337 HttpInstance
= HTTP_INSTANCE_FROM_PROTOCOL (This
);
1338 ASSERT (HttpInstance
!= NULL
);
1340 if (HttpInstance
->LocalAddressIsIPv6
) {
1341 return EFI_UNSUPPORTED
;
1344 if (HttpInstance
->Tcp4
== NULL
|| HttpInstance
->State
!= HTTP_STATE_TCP_CONNECTED
) {
1345 return EFI_NOT_STARTED
;
1348 return HttpInstance
->Tcp4
->Poll (HttpInstance
->Tcp4
);