2 This library is used to share code between UEFI network stack modules.
3 It provides the helper routines to parse the HTTP message byte stream.
5 Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
6 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at<BR>
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "DxeHttpLib.h"
22 Decode a percent-encoded URI component to the ASCII character.
24 Decode the input component in Buffer according to RFC 3986. The caller is responsible to make
25 sure ResultBuffer points to a buffer with size equal or greater than ((AsciiStrSize (Buffer))
28 @param[in] Buffer The pointer to a percent-encoded URI component.
29 @param[in] BufferLength Length of Buffer in bytes.
30 @param[out] ResultBuffer Point to the buffer to store the decode result.
31 @param[out] ResultLength Length of decoded string in ResultBuffer in bytes.
33 @retval EFI_SUCCESS Successfully decoded the URI.
34 @retval EFI_INVALID_PARAMETER Buffer is not a valid percent-encoded string.
41 IN UINT32 BufferLength
,
42 OUT CHAR8
*ResultBuffer
,
43 OUT UINT32
*ResultLength
50 if (Buffer
== NULL
|| BufferLength
== 0 || ResultBuffer
== NULL
) {
51 return EFI_INVALID_PARAMETER
;
57 while (Index
< BufferLength
) {
58 if (Buffer
[Index
] == '%') {
59 if (!NET_IS_HEX_CHAR (Buffer
[Index
+1]) || !NET_IS_HEX_CHAR (Buffer
[Index
+2])) {
60 return EFI_INVALID_PARAMETER
;
62 HexStr
[0] = Buffer
[Index
+1];
63 HexStr
[1] = Buffer
[Index
+2];
64 ResultBuffer
[Offset
] = (CHAR8
) AsciiStrHexToUintn (HexStr
);
67 ResultBuffer
[Offset
] = Buffer
[Index
];
73 *ResultLength
= (UINT32
) Offset
;
79 This function return the updated state according to the input state and next character of
82 @param[in] Char Next character.
83 @param[in] State Current value of the parser state machine.
84 @param[in] IsRightBracket TRUE if there is an sign ']' in the authority component and
85 indicates the next part is ':' before Port.
87 @return Updated state value.
90 NetHttpParseAuthorityChar (
92 IN HTTP_URL_PARSE_STATE State
,
93 IN BOOLEAN
*IsRightBracket
99 // The authority component is preceded by a double slash ("//") and is
100 // terminated by the next slash ("/"), question mark ("?"), or number
101 // sign ("#") character, or by the end of the URI.
103 if (Char
== ' ' || Char
== '\r' || Char
== '\n') {
104 return UrlParserStateMax
;
108 // authority = [ userinfo "@" ] host [ ":" port ]
111 case UrlParserUserInfo
:
113 return UrlParserHostStart
;
118 case UrlParserHostStart
:
120 return UrlParserHostIpv6
;
124 return UrlParserPortStart
;
127 return UrlParserHost
;
129 case UrlParserHostIpv6
:
131 *IsRightBracket
= TRUE
;
134 if (Char
== ':' && *IsRightBracket
) {
135 return UrlParserPortStart
;
137 return UrlParserHostIpv6
;
140 case UrlParserPortStart
:
141 return UrlParserPort
;
151 This function parse the authority component of the input URL and update the parser.
153 @param[in] Url The pointer to a HTTP URL string.
154 @param[in] FoundAt TRUE if there is an at sign ('@') in the authority component.
155 @param[in, out] UrlParser Pointer to the buffer of the parse result.
157 @retval EFI_SUCCESS Successfully parse the authority.
158 @retval Other Error happened.
162 NetHttpParseAuthority (
165 IN OUT HTTP_URL_PARSER
*UrlParser
171 HTTP_URL_PARSE_STATE State
;
174 BOOLEAN IsrightBracket
;
176 ASSERT ((UrlParser
->FieldBitMap
& BIT (HTTP_URI_FIELD_AUTHORITY
)) != 0);
179 // authority = [ userinfo "@" ] host [ ":" port ]
182 State
= UrlParserUserInfo
;
184 State
= UrlParserHost
;
187 IsrightBracket
= FALSE
;
188 Field
= HTTP_URI_FIELD_MAX
;
190 Authority
= Url
+ UrlParser
->FieldData
[HTTP_URI_FIELD_AUTHORITY
].Offset
;
191 Length
= UrlParser
->FieldData
[HTTP_URI_FIELD_AUTHORITY
].Length
;
192 for (Char
= Authority
; Char
< Authority
+ Length
; Char
++) {
193 State
= NetHttpParseAuthorityChar (*Char
, State
, &IsrightBracket
);
195 case UrlParserStateMax
:
196 return EFI_INVALID_PARAMETER
;
198 case UrlParserHostStart
:
199 case UrlParserPortStart
:
202 case UrlParserUserInfo
:
203 Field
= HTTP_URI_FIELD_USERINFO
;
207 Field
= HTTP_URI_FIELD_HOST
;
210 case UrlParserHostIpv6
:
211 Field
= HTTP_URI_FIELD_HOST
;
215 Field
= HTTP_URI_FIELD_PORT
;
223 // Field not changed, count the length.
225 ASSERT (Field
< HTTP_URI_FIELD_MAX
);
226 if (Field
== OldField
) {
227 UrlParser
->FieldData
[Field
].Length
++;
234 UrlParser
->FieldBitMap
|= BIT (Field
);
235 UrlParser
->FieldData
[Field
].Offset
= (UINT32
) (Char
- Url
);
236 UrlParser
->FieldData
[Field
].Length
= 1;
244 This function return the updated state according to the input state and next character of a URL.
246 @param[in] Char Next character.
247 @param[in] State Current value of the parser state machine.
249 @return Updated state value.
253 NetHttpParseUrlChar (
255 IN HTTP_URL_PARSE_STATE State
258 if (Char
== ' ' || Char
== '\r' || Char
== '\n') {
259 return UrlParserStateMax
;
263 // http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
265 // Request-URI = "*" | absolute-URI | path-absolute | authority
267 // absolute-URI = scheme ":" hier-part [ "?" query ]
268 // path-absolute = "/" [ segment-nz *( "/" segment ) ]
269 // authority = [ userinfo "@" ] host [ ":" port ]
272 case UrlParserUrlStart
:
273 if (Char
== '*' || Char
== '/') {
274 return UrlParserPath
;
276 return UrlParserScheme
;
278 case UrlParserScheme
:
280 return UrlParserSchemeColon
;
284 case UrlParserSchemeColon
:
286 return UrlParserSchemeColonSlash
;
290 case UrlParserSchemeColonSlash
:
292 return UrlParserSchemeColonSlashSlash
;
296 case UrlParserAtInAuthority
:
298 return UrlParserStateMax
;
301 case UrlParserAuthority
:
302 case UrlParserSchemeColonSlashSlash
:
304 return UrlParserAtInAuthority
;
307 return UrlParserPath
;
310 return UrlParserQueryStart
;
313 return UrlParserFragmentStart
;
315 return UrlParserAuthority
;
319 return UrlParserQueryStart
;
322 return UrlParserFragmentStart
;
327 case UrlParserQueryStart
:
329 return UrlParserFragmentStart
;
331 return UrlParserQuery
;
333 case UrlParserFragmentStart
:
334 return UrlParserFragment
;
343 Create a URL parser for the input URL string.
345 This function will parse and dereference the input HTTP URL into it components. The original
346 content of the URL won't be modified and the result will be returned in UrlParser, which can
347 be used in other functions like NetHttpUrlGetHostName().
349 @param[in] Url The pointer to a HTTP URL string.
350 @param[in] Length Length of Url in bytes.
351 @param[in] IsConnectMethod Whether the Url is used in HTTP CONNECT method or not.
352 @param[out] UrlParser Pointer to the returned buffer to store the parse result.
354 @retval EFI_SUCCESS Successfully dereferenced the HTTP URL.
355 @retval EFI_INVALID_PARAMETER UrlParser is NULL or Url is not a valid HTTP URL.
356 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
364 IN BOOLEAN IsConnectMethod
,
368 HTTP_URL_PARSE_STATE State
;
374 HTTP_URL_PARSER
*Parser
;
376 if (Url
== NULL
|| Length
== 0 || UrlParser
== NULL
) {
377 return EFI_INVALID_PARAMETER
;
380 Parser
= AllocateZeroPool (sizeof (HTTP_URL_PARSER
));
381 if (Parser
== NULL
) {
382 return EFI_OUT_OF_RESOURCES
;
385 if (IsConnectMethod
) {
387 // According to RFC 2616, the authority form is only used by the CONNECT method.
389 State
= UrlParserAuthority
;
391 State
= UrlParserUrlStart
;
394 Field
= HTTP_URI_FIELD_MAX
;
397 for (Char
= Url
; Char
< Url
+ Length
; Char
++) {
399 // Update state machine accoring to next char.
401 State
= NetHttpParseUrlChar (*Char
, State
);
404 case UrlParserStateMax
:
405 return EFI_INVALID_PARAMETER
;
407 case UrlParserSchemeColon
:
408 case UrlParserSchemeColonSlash
:
409 case UrlParserSchemeColonSlashSlash
:
410 case UrlParserQueryStart
:
411 case UrlParserFragmentStart
:
413 // Skip all the delimiting char: "://" "?" "@"
417 case UrlParserScheme
:
418 Field
= HTTP_URI_FIELD_SCHEME
;
421 case UrlParserAtInAuthority
:
423 case UrlParserAuthority
:
424 Field
= HTTP_URI_FIELD_AUTHORITY
;
428 Field
= HTTP_URI_FIELD_PATH
;
432 Field
= HTTP_URI_FIELD_QUERY
;
435 case UrlParserFragment
:
436 Field
= HTTP_URI_FIELD_FRAGMENT
;
444 // Field not changed, count the length.
446 ASSERT (Field
< HTTP_URI_FIELD_MAX
);
447 if (Field
== OldField
) {
448 Parser
->FieldData
[Field
].Length
++;
455 Parser
->FieldBitMap
|= BIT (Field
);
456 Parser
->FieldData
[Field
].Offset
= (UINT32
) (Char
- Url
);
457 Parser
->FieldData
[Field
].Length
= 1;
462 // If has authority component, continue to parse the username, host and port.
464 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_AUTHORITY
)) != 0) {
465 Status
= NetHttpParseAuthority (Url
, FoundAt
, Parser
);
466 if (EFI_ERROR (Status
)) {
476 Get the Hostname from a HTTP URL.
478 This function will return the HostName according to the Url and previous parse result ,and
479 it is the caller's responsibility to free the buffer returned in *HostName.
481 @param[in] Url The pointer to a HTTP URL string.
482 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
483 @param[out] HostName Pointer to a buffer to store the HostName.
485 @retval EFI_SUCCESS Successfully get the required component.
486 @retval EFI_INVALID_PARAMETER Uri is NULL or HostName is NULL or UrlParser is invalid.
487 @retval EFI_NOT_FOUND No hostName component in the URL.
488 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
502 HTTP_URL_PARSER
*Parser
;
504 if (Url
== NULL
|| UrlParser
== NULL
|| HostName
== NULL
) {
505 return EFI_INVALID_PARAMETER
;
508 Parser
= (HTTP_URL_PARSER
*) UrlParser
;
510 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_HOST
)) == 0) {
511 return EFI_NOT_FOUND
;
514 Name
= AllocatePool (Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Length
+ 1);
516 return EFI_OUT_OF_RESOURCES
;
519 Status
= UriPercentDecode (
520 Url
+ Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Offset
,
521 Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Length
,
525 if (EFI_ERROR (Status
)) {
529 Name
[ResultLength
] = '\0';
536 Get the IPv4 address from a HTTP URL.
538 This function will return the IPv4 address according to the Url and previous parse result.
540 @param[in] Url The pointer to a HTTP URL string.
541 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
542 @param[out] Ip4Address Pointer to a buffer to store the IP address.
544 @retval EFI_SUCCESS Successfully get the required component.
545 @retval EFI_INVALID_PARAMETER Uri is NULL or Ip4Address is NULL or UrlParser is invalid.
546 @retval EFI_NOT_FOUND No IPv4 address component in the URL.
547 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
555 OUT EFI_IPv4_ADDRESS
*Ip4Address
561 HTTP_URL_PARSER
*Parser
;
563 if (Url
== NULL
|| UrlParser
== NULL
|| Ip4Address
== NULL
) {
564 return EFI_INVALID_PARAMETER
;
567 Parser
= (HTTP_URL_PARSER
*) UrlParser
;
569 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_HOST
)) == 0) {
570 return EFI_INVALID_PARAMETER
;
573 Ip4String
= AllocatePool (Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Length
+ 1);
574 if (Ip4String
== NULL
) {
575 return EFI_OUT_OF_RESOURCES
;
578 Status
= UriPercentDecode (
579 Url
+ Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Offset
,
580 Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Length
,
584 if (EFI_ERROR (Status
)) {
588 Ip4String
[ResultLength
] = '\0';
589 Status
= NetLibAsciiStrToIp4 (Ip4String
, Ip4Address
);
590 FreePool (Ip4String
);
596 Get the IPv6 address from a HTTP URL.
598 This function will return the IPv6 address according to the Url and previous parse result.
600 @param[in] Url The pointer to a HTTP URL string.
601 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
602 @param[out] Ip6Address Pointer to a buffer to store the IP address.
604 @retval EFI_SUCCESS Successfully get the required component.
605 @retval EFI_INVALID_PARAMETER Uri is NULL or Ip6Address is NULL or UrlParser is invalid.
606 @retval EFI_NOT_FOUND No IPv6 address component in the URL.
607 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
615 OUT EFI_IPv6_ADDRESS
*Ip6Address
623 HTTP_URL_PARSER
*Parser
;
625 if (Url
== NULL
|| UrlParser
== NULL
|| Ip6Address
== NULL
) {
626 return EFI_INVALID_PARAMETER
;
629 Parser
= (HTTP_URL_PARSER
*) UrlParser
;
631 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_HOST
)) == 0) {
632 return EFI_INVALID_PARAMETER
;
636 // IP-literal = "[" ( IPv6address / IPvFuture ) "]"
638 Length
= Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Length
;
640 return EFI_INVALID_PARAMETER
;
643 Ptr
= Url
+ Parser
->FieldData
[HTTP_URI_FIELD_HOST
].Offset
;
644 if ((Ptr
[0] != '[') || (Ptr
[Length
- 1] != ']')) {
645 return EFI_INVALID_PARAMETER
;
648 Ip6String
= AllocatePool (Length
);
649 if (Ip6String
== NULL
) {
650 return EFI_OUT_OF_RESOURCES
;
653 Status
= UriPercentDecode (
659 if (EFI_ERROR (Status
)) {
663 Ip6String
[ResultLength
] = '\0';
664 Status
= NetLibAsciiStrToIp6 (Ip6String
, Ip6Address
);
665 FreePool (Ip6String
);
671 Get the port number from a HTTP URL.
673 This function will return the port number according to the Url and previous parse result.
675 @param[in] Url The pointer to a HTTP URL string.
676 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
677 @param[out] Port Pointer to a buffer to store the port number.
679 @retval EFI_SUCCESS Successfully get the required component.
680 @retval EFI_INVALID_PARAMETER Uri is NULL or Port is NULL or UrlParser is invalid.
681 @retval EFI_NOT_FOUND No port number in the URL.
682 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
696 HTTP_URL_PARSER
*Parser
;
698 if (Url
== NULL
|| UrlParser
== NULL
|| Port
== NULL
) {
699 return EFI_INVALID_PARAMETER
;
702 Parser
= (HTTP_URL_PARSER
*) UrlParser
;
704 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_PORT
)) == 0) {
705 return EFI_INVALID_PARAMETER
;
708 PortString
= AllocatePool (Parser
->FieldData
[HTTP_URI_FIELD_PORT
].Length
+ 1);
709 if (PortString
== NULL
) {
710 return EFI_OUT_OF_RESOURCES
;
713 Status
= UriPercentDecode (
714 Url
+ Parser
->FieldData
[HTTP_URI_FIELD_PORT
].Offset
,
715 Parser
->FieldData
[HTTP_URI_FIELD_PORT
].Length
,
719 if (EFI_ERROR (Status
)) {
723 PortString
[ResultLength
] = '\0';
724 *Port
= (UINT16
) AsciiStrDecimalToUintn (Url
+ Parser
->FieldData
[HTTP_URI_FIELD_PORT
].Offset
);
730 Get the Path from a HTTP URL.
732 This function will return the Path according to the Url and previous parse result,and
733 it is the caller's responsibility to free the buffer returned in *Path.
735 @param[in] Url The pointer to a HTTP URL string.
736 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
737 @param[out] Path Pointer to a buffer to store the Path.
739 @retval EFI_SUCCESS Successfully get the required component.
740 @retval EFI_INVALID_PARAMETER Uri is NULL or HostName is NULL or UrlParser is invalid.
741 @retval EFI_NOT_FOUND No hostName component in the URL.
742 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
756 HTTP_URL_PARSER
*Parser
;
758 if (Url
== NULL
|| UrlParser
== NULL
|| Path
== NULL
) {
759 return EFI_INVALID_PARAMETER
;
762 Parser
= (HTTP_URL_PARSER
*) UrlParser
;
764 if ((Parser
->FieldBitMap
& BIT (HTTP_URI_FIELD_PATH
)) == 0) {
765 return EFI_NOT_FOUND
;
768 PathStr
= AllocatePool (Parser
->FieldData
[HTTP_URI_FIELD_PATH
].Length
+ 1);
769 if (PathStr
== NULL
) {
770 return EFI_OUT_OF_RESOURCES
;
773 Status
= UriPercentDecode (
774 Url
+ Parser
->FieldData
[HTTP_URI_FIELD_PATH
].Offset
,
775 Parser
->FieldData
[HTTP_URI_FIELD_PATH
].Length
,
779 if (EFI_ERROR (Status
)) {
783 PathStr
[ResultLength
] = '\0';
789 Release the resource of the URL parser.
791 @param[in] UrlParser Pointer to the parser.
800 FreePool (UrlParser
);
804 Find a specified header field according to the field name.
806 @param[in] HeaderCount Number of HTTP header structures in Headers list.
807 @param[in] Headers Array containing list of HTTP headers.
808 @param[in] FieldName Null terminated string which describes a field name.
810 @return Pointer to the found header or NULL.
816 IN UINTN HeaderCount
,
817 IN EFI_HTTP_HEADER
*Headers
,
823 if (HeaderCount
== 0 || Headers
== NULL
|| FieldName
== NULL
) {
827 for (Index
= 0; Index
< HeaderCount
; Index
++){
829 // Field names are case-insensitive (RFC 2616).
831 if (AsciiStriCmp (Headers
[Index
].FieldName
, FieldName
) == 0) {
832 return &Headers
[Index
];
840 BodyParserBodyIdentity
,
841 BodyParserChunkSizeStart
,
843 BodyParserChunkSizeEndCR
,
844 BodyParserChunkExtStart
,
845 BodyParserChunkDataStart
,
846 BodyParserChunkDataEnd
,
847 BodyParserChunkDataEndCR
,
850 BodyParserLastCRLFEnd
,
853 } HTTP_BODY_PARSE_STATE
;
856 BOOLEAN IgnoreBody
; // "MUST NOT" include a message-body
857 BOOLEAN IsChunked
; // "chunked" transfer-coding.
858 BOOLEAN ContentLengthIsValid
;
859 UINTN ContentLength
; // Entity length (not the message-body length), invalid until ContentLengthIsValid is TRUE
861 HTTP_BODY_PARSER_CALLBACK Callback
;
863 UINTN ParsedBodyLength
;
864 HTTP_BODY_PARSE_STATE State
;
865 UINTN CurrentChunkSize
;
866 UINTN CurrentChunkParsedSize
;
871 Convert an Ascii char to its uppercase.
873 @param[in] Char Ascii character.
875 @return Uppercase value of the input Char.
883 if (Char
>= 'a' && Char
<= 'z') {
884 return Char
- ('a' - 'A');
891 Convert an hexadecimal char to a value of type UINTN.
893 @param[in] Char Ascii character.
895 @return Value translated from Char.
899 HttpIoHexCharToUintn (
903 if (Char
>= '0' && Char
<= '9') {
907 return (10 + HttpIoCharToUpper (Char
) - 'A');
911 Get the value of the content length if there is a "Content-Length" header.
913 @param[in] HeaderCount Number of HTTP header structures in Headers.
914 @param[in] Headers Array containing list of HTTP headers.
915 @param[out] ContentLength Pointer to save the value of the content length.
917 @retval EFI_SUCCESS Successfully get the content length.
918 @retval EFI_NOT_FOUND No "Content-Length" header in the Headers.
922 HttpIoParseContentLengthHeader (
923 IN UINTN HeaderCount
,
924 IN EFI_HTTP_HEADER
*Headers
,
925 OUT UINTN
*ContentLength
928 EFI_HTTP_HEADER
*Header
;
930 Header
= HttpFindHeader (HeaderCount
, Headers
, HTTP_HEADER_CONTENT_LENGTH
);
931 if (Header
== NULL
) {
932 return EFI_NOT_FOUND
;
935 *ContentLength
= AsciiStrDecimalToUintn (Header
->FieldValue
);
941 Check whether the HTTP message is using the "chunked" transfer-coding.
943 @param[in] HeaderCount Number of HTTP header structures in Headers.
944 @param[in] Headers Array containing list of HTTP headers.
946 @return The message is "chunked" transfer-coding (TRUE) or not (FALSE).
951 IN UINTN HeaderCount
,
952 IN EFI_HTTP_HEADER
*Headers
955 EFI_HTTP_HEADER
*Header
;
958 Header
= HttpFindHeader (HeaderCount
, Headers
, HTTP_HEADER_TRANSFER_ENCODING
);
959 if (Header
== NULL
) {
963 if (AsciiStriCmp (Header
->FieldValue
, "identity") != 0) {
971 Check whether the HTTP message should have a message-body.
973 @param[in] Method The HTTP method (e.g. GET, POST) for this HTTP message.
974 @param[in] StatusCode Response status code returned by the remote host.
976 @return The message should have a message-body (FALSE) or not (TRUE).
980 HttpIoNoMessageBody (
981 IN EFI_HTTP_METHOD Method
,
982 IN EFI_HTTP_STATUS_CODE StatusCode
987 // All responses to the HEAD request method
988 // MUST NOT include a message-body, even though the presence of entity-
989 // header fields might lead one to believe they do. All 1xx
990 // (informational), 204 (no content), and 304 (not modified) responses
991 // MUST NOT include a message-body. All other responses do include a
992 // message-body, although it MAY be of zero length.
994 if (Method
== HttpMethodHead
) {
998 if ((StatusCode
== HTTP_STATUS_100_CONTINUE
) ||
999 (StatusCode
== HTTP_STATUS_101_SWITCHING_PROTOCOLS
) ||
1000 (StatusCode
== HTTP_STATUS_204_NO_CONTENT
) ||
1001 (StatusCode
== HTTP_STATUS_304_NOT_MODIFIED
))
1010 Initialize a HTTP message-body parser.
1012 This function will create and initialize a HTTP message parser according to caller provided HTTP message
1013 header information. It is the caller's responsibility to free the buffer returned in *UrlParser by HttpFreeMsgParser().
1015 @param[in] Method The HTTP method (e.g. GET, POST) for this HTTP message.
1016 @param[in] StatusCode Response status code returned by the remote host.
1017 @param[in] HeaderCount Number of HTTP header structures in Headers.
1018 @param[in] Headers Array containing list of HTTP headers.
1019 @param[in] Callback Callback function that is invoked when parsing the HTTP message-body,
1020 set to NULL to ignore all events.
1021 @param[in] Context Pointer to the context that will be passed to Callback.
1022 @param[out] MsgParser Pointer to the returned buffer to store the message parser.
1024 @retval EFI_SUCCESS Successfully initialized the parser.
1025 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
1026 @retval EFI_INVALID_PARAMETER MsgParser is NULL or HeaderCount is not NULL but Headers is NULL.
1027 @retval Others Failed to initialize the parser.
1033 IN EFI_HTTP_METHOD Method
,
1034 IN EFI_HTTP_STATUS_CODE StatusCode
,
1035 IN UINTN HeaderCount
,
1036 IN EFI_HTTP_HEADER
*Headers
,
1037 IN HTTP_BODY_PARSER_CALLBACK Callback
,
1039 OUT VOID
**MsgParser
1043 HTTP_BODY_PARSER
*Parser
;
1045 if (HeaderCount
!= 0 && Headers
== NULL
) {
1046 return EFI_INVALID_PARAMETER
;
1049 if (MsgParser
== NULL
) {
1050 return EFI_INVALID_PARAMETER
;
1053 Parser
= AllocateZeroPool (sizeof (HTTP_BODY_PARSER
));
1054 if (Parser
== NULL
) {
1055 return EFI_OUT_OF_RESOURCES
;
1058 Parser
->State
= BodyParserBodyStart
;
1061 // Determine the message length according to RFC 2616.
1062 // 1. Check whether the message "MUST NOT" have a message-body.
1064 Parser
->IgnoreBody
= HttpIoNoMessageBody (Method
, StatusCode
);
1066 // 2. Check whether the message using "chunked" transfer-coding.
1068 Parser
->IsChunked
= HttpIoIsChunked (HeaderCount
, Headers
);
1070 // 3. Check whether the message has a Content-Length header field.
1072 Status
= HttpIoParseContentLengthHeader (HeaderCount
, Headers
, &Parser
->ContentLength
);
1073 if (!EFI_ERROR (Status
)) {
1074 Parser
->ContentLengthIsValid
= TRUE
;
1077 // 4. Range header is not supported now, so we won't meet media type "multipart/byteranges".
1078 // 5. By server closing the connection
1082 // Set state to skip body parser if the message shouldn't have a message body.
1084 if (Parser
->IgnoreBody
) {
1085 Parser
->State
= BodyParserComplete
;
1087 Parser
->Callback
= Callback
;
1088 Parser
->Context
= Context
;
1091 *MsgParser
= Parser
;
1098 Parse BodyLength of message-body. This function can be called repeatedly to parse the message-body partially.
1100 @param[in, out] MsgParser Pointer to the message parser.
1101 @param[in] BodyLength Length in bytes of the Body.
1102 @param[in] Body Pointer to the buffer of the message-body to be parsed.
1104 @retval EFI_SUCCESS Successfully parse the message-body.
1105 @retval EFI_INVALID_PARAMETER MsgParser is NULL or Body is NULL or BodyLength is 0.
1106 @retval Others Operation aborted.
1111 HttpParseMessageBody (
1112 IN OUT VOID
*MsgParser
,
1113 IN UINTN BodyLength
,
1118 UINTN RemainderLengthInThis
;
1119 UINTN LengthForCallback
;
1121 HTTP_BODY_PARSER
*Parser
;
1123 if (BodyLength
== 0 || Body
== NULL
) {
1124 return EFI_INVALID_PARAMETER
;
1127 if (MsgParser
== NULL
) {
1128 return EFI_INVALID_PARAMETER
;
1131 Parser
= (HTTP_BODY_PARSER
*) MsgParser
;
1133 if (Parser
->IgnoreBody
) {
1134 Parser
->State
= BodyParserComplete
;
1135 if (Parser
->Callback
!= NULL
) {
1136 Status
= Parser
->Callback (
1137 BodyParseEventOnComplete
,
1142 if (EFI_ERROR (Status
)) {
1149 if (Parser
->State
== BodyParserBodyStart
) {
1150 Parser
->ParsedBodyLength
= 0;
1151 if (Parser
->IsChunked
) {
1152 Parser
->State
= BodyParserChunkSizeStart
;
1154 Parser
->State
= BodyParserBodyIdentity
;
1159 // The message body might be truncated in anywhere, so we need to parse is byte-by-byte.
1161 for (Char
= Body
; Char
< Body
+ BodyLength
; ) {
1163 switch (Parser
->State
) {
1164 case BodyParserStateMax
:
1167 case BodyParserBodyIdentity
:
1169 // Identity transfer-coding, just notify user to save the body data.
1171 if (Parser
->Callback
!= NULL
) {
1172 Status
= Parser
->Callback (
1173 BodyParseEventOnData
,
1175 MIN (BodyLength
, Parser
->ContentLength
- Parser
->ParsedBodyLength
),
1178 if (EFI_ERROR (Status
)) {
1182 Char
+= MIN (BodyLength
, Parser
->ContentLength
- Parser
->ParsedBodyLength
);
1183 Parser
->ParsedBodyLength
+= MIN (BodyLength
, Parser
->ContentLength
- Parser
->ParsedBodyLength
);
1184 if (Parser
->ParsedBodyLength
== Parser
->ContentLength
) {
1185 Parser
->State
= BodyParserComplete
;
1186 if (Parser
->Callback
!= NULL
) {
1187 Status
= Parser
->Callback (
1188 BodyParseEventOnComplete
,
1193 if (EFI_ERROR (Status
)) {
1200 case BodyParserChunkSizeStart
:
1202 // First byte of chunk-size, the chunk-size might be truncated.
1204 Parser
->CurrentChunkSize
= 0;
1205 Parser
->State
= BodyParserChunkSize
;
1206 case BodyParserChunkSize
:
1207 if (!NET_IS_HEX_CHAR (*Char
)) {
1209 Parser
->State
= BodyParserChunkExtStart
;
1211 } else if (*Char
== '\r') {
1212 Parser
->State
= BodyParserChunkSizeEndCR
;
1215 Parser
->State
= BodyParserStateMax
;
1220 if (Parser
->CurrentChunkSize
> (((~((UINTN
) 0)) - 16) / 16)) {
1221 return EFI_INVALID_PARAMETER
;
1223 Parser
->CurrentChunkSize
= Parser
->CurrentChunkSize
* 16 + HttpIoHexCharToUintn (*Char
);
1227 case BodyParserChunkExtStart
:
1229 // Ignore all the chunk extensions.
1231 if (*Char
== '\r') {
1232 Parser
->State
= BodyParserChunkSizeEndCR
;
1237 case BodyParserChunkSizeEndCR
:
1238 if (*Char
!= '\n') {
1239 Parser
->State
= BodyParserStateMax
;
1243 if (Parser
->CurrentChunkSize
== 0) {
1245 // The last chunk has been parsed and now assumed the state
1246 // of HttpBodyParse is ParserLastCRLF. So it need to decide
1247 // whether the rest message is trailer or last CRLF in the next round.
1249 Parser
->ContentLengthIsValid
= TRUE
;
1250 Parser
->State
= BodyParserLastCRLF
;
1253 Parser
->State
= BodyParserChunkDataStart
;
1254 Parser
->CurrentChunkParsedSize
= 0;
1257 case BodyParserLastCRLF
:
1259 // Judge the byte is belong to the Last CRLF or trailer, and then
1260 // configure the state of HttpBodyParse to corresponding state.
1262 if (*Char
== '\r') {
1264 Parser
->State
= BodyParserLastCRLFEnd
;
1267 Parser
->State
= BodyParserTrailer
;
1271 case BodyParserLastCRLFEnd
:
1272 if (*Char
== '\n') {
1273 Parser
->State
= BodyParserComplete
;
1275 if (Parser
->Callback
!= NULL
) {
1276 Status
= Parser
->Callback (
1277 BodyParseEventOnComplete
,
1282 if (EFI_ERROR (Status
)) {
1288 Parser
->State
= BodyParserStateMax
;
1292 case BodyParserTrailer
:
1293 if (*Char
== '\r') {
1294 Parser
->State
= BodyParserChunkSizeEndCR
;
1299 case BodyParserChunkDataStart
:
1301 // First byte of chunk-data, the chunk data also might be truncated.
1303 RemainderLengthInThis
= BodyLength
- (Char
- Body
);
1304 LengthForCallback
= MIN (Parser
->CurrentChunkSize
- Parser
->CurrentChunkParsedSize
, RemainderLengthInThis
);
1305 if (Parser
->Callback
!= NULL
) {
1306 Status
= Parser
->Callback (
1307 BodyParseEventOnData
,
1312 if (EFI_ERROR (Status
)) {
1316 Char
+= LengthForCallback
;
1317 Parser
->ContentLength
+= LengthForCallback
;
1318 Parser
->CurrentChunkParsedSize
+= LengthForCallback
;
1319 if (Parser
->CurrentChunkParsedSize
== Parser
->CurrentChunkSize
) {
1320 Parser
->State
= BodyParserChunkDataEnd
;
1324 case BodyParserChunkDataEnd
:
1325 if (*Char
== '\r') {
1326 Parser
->State
= BodyParserChunkDataEndCR
;
1328 Parser
->State
= BodyParserStateMax
;
1333 case BodyParserChunkDataEndCR
:
1334 if (*Char
!= '\n') {
1335 Parser
->State
= BodyParserStateMax
;
1339 Parser
->State
= BodyParserChunkSizeStart
;
1348 if (Parser
->State
== BodyParserStateMax
) {
1356 Check whether the message-body is complete or not.
1358 @param[in] MsgParser Pointer to the message parser.
1360 @retval TRUE Message-body is complete.
1361 @retval FALSE Message-body is not complete.
1366 HttpIsMessageComplete (
1370 HTTP_BODY_PARSER
*Parser
;
1372 Parser
= (HTTP_BODY_PARSER
*) MsgParser
;
1374 if (Parser
->State
== BodyParserComplete
) {
1381 Get the content length of the entity.
1383 Note that in trunk transfer, the entity length is not valid until the whole message body is received.
1385 @param[in] MsgParser Pointer to the message parser.
1386 @param[out] ContentLength Pointer to store the length of the entity.
1388 @retval EFI_SUCCESS Successfully to get the entity length.
1389 @retval EFI_NOT_READY Entity length is not valid yet.
1390 @retval EFI_INVALID_PARAMETER MsgParser is NULL or ContentLength is NULL.
1395 HttpGetEntityLength (
1397 OUT UINTN
*ContentLength
1400 HTTP_BODY_PARSER
*Parser
;
1402 if (MsgParser
== NULL
|| ContentLength
== NULL
) {
1403 return EFI_INVALID_PARAMETER
;
1406 Parser
= (HTTP_BODY_PARSER
*) MsgParser
;
1408 if (!Parser
->ContentLengthIsValid
) {
1409 return EFI_NOT_READY
;
1412 *ContentLength
= Parser
->ContentLength
;
1417 Release the resource of the message parser.
1419 @param[in] MsgParser Pointer to the message parser.
1428 FreePool (MsgParser
);
1433 Get the next string, which is distinguished by specified seperator.
1435 @param[in] String Pointer to the string.
1436 @param[in] Seperator Specified seperator used to distinguish where is the beginning
1439 @return Pointer to the next string.
1440 @return NULL if not find or String is NULL.
1445 AsciiStrGetNextToken (
1446 IN CONST CHAR8
*String
,
1457 if (*Token
== Seperator
) {
1458 return (CHAR8
*)(Token
+ 1);
1465 Set FieldName and FieldValue into specified HttpHeader.
1467 @param[in,out] HttpHeader Specified HttpHeader.
1468 @param[in] FieldName FieldName of this HttpHeader, a NULL terminated ASCII string.
1469 @param[in] FieldValue FieldValue of this HttpHeader, a NULL terminated ASCII string.
1472 @retval EFI_SUCCESS The FieldName and FieldValue are set into HttpHeader successfully.
1473 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1478 HttpSetFieldNameAndValue (
1479 IN OUT EFI_HTTP_HEADER
*HttpHeader
,
1480 IN CONST CHAR8
*FieldName
,
1481 IN CONST CHAR8
*FieldValue
1484 UINTN FieldNameSize
;
1485 UINTN FieldValueSize
;
1487 if (HttpHeader
->FieldName
!= NULL
) {
1488 FreePool (HttpHeader
->FieldName
);
1490 if (HttpHeader
->FieldValue
!= NULL
) {
1491 FreePool (HttpHeader
->FieldValue
);
1494 FieldNameSize
= AsciiStrSize (FieldName
);
1495 HttpHeader
->FieldName
= AllocateZeroPool (FieldNameSize
);
1496 if (HttpHeader
->FieldName
== NULL
) {
1497 return EFI_OUT_OF_RESOURCES
;
1499 CopyMem (HttpHeader
->FieldName
, FieldName
, FieldNameSize
);
1500 HttpHeader
->FieldName
[FieldNameSize
- 1] = 0;
1502 FieldValueSize
= AsciiStrSize (FieldValue
);
1503 HttpHeader
->FieldValue
= AllocateZeroPool (FieldValueSize
);
1504 if (HttpHeader
->FieldValue
== NULL
) {
1505 return EFI_OUT_OF_RESOURCES
;
1507 CopyMem (HttpHeader
->FieldValue
, FieldValue
, FieldValueSize
);
1508 HttpHeader
->FieldValue
[FieldValueSize
- 1] = 0;
1514 Get one key/value header pair from the raw string.
1516 @param[in] String Pointer to the raw string.
1517 @param[out] FieldName Points directly to field name within 'HttpHeader'.
1518 @param[out] FieldValue Points directly to field value within 'HttpHeader'.
1520 @return Pointer to the next raw string.
1521 @return NULL if no key/value header pair from this raw string.
1526 HttpGetFieldNameAndValue (
1528 OUT CHAR8
**FieldName
,
1529 OUT CHAR8
**FieldValue
1532 CHAR8
*FieldNameStr
;
1533 CHAR8
*FieldValueStr
;
1536 if (String
== NULL
|| FieldName
== NULL
|| FieldValue
== NULL
) {
1542 FieldNameStr
= NULL
;
1543 FieldValueStr
= NULL
;
1547 // Each header field consists of a name followed by a colon (":") and the field value.
1549 FieldNameStr
= String
;
1550 FieldValueStr
= AsciiStrGetNextToken (FieldNameStr
, ':');
1551 if (FieldValueStr
== NULL
) {
1556 // Replace ':' with 0
1558 *(FieldValueStr
- 1) = 0;
1561 // The field value MAY be preceded by any amount of LWS, though a single SP is preferred.
1564 if (*FieldValueStr
== ' ' || *FieldValueStr
== '\t') {
1566 } else if (*FieldValueStr
== '\r' && *(FieldValueStr
+ 1) == '\n' &&
1567 (*(FieldValueStr
+ 2) == ' ' || *(FieldValueStr
+ 2) == '\t')) {
1568 FieldValueStr
= FieldValueStr
+ 3;
1575 // Header fields can be extended over multiple lines by preceding each extra
1576 // line with at least one SP or HT.
1578 StrPtr
= FieldValueStr
;
1580 StrPtr
= AsciiStrGetNextToken (StrPtr
, '\r');
1581 if (StrPtr
== NULL
|| *StrPtr
!= '\n') {
1586 } while (*StrPtr
== ' ' || *StrPtr
== '\t');
1589 // Replace '\r' with 0
1594 // Get FieldName and FieldValue.
1596 *FieldName
= FieldNameStr
;
1597 *FieldValue
= FieldValueStr
;
1603 Free existing HeaderFields.
1605 @param[in] HeaderFields Pointer to array of key/value header pairs waitting for free.
1606 @param[in] FieldCount The number of header pairs in HeaderFields.
1611 HttpFreeHeaderFields (
1612 IN EFI_HTTP_HEADER
*HeaderFields
,
1618 if (HeaderFields
!= NULL
) {
1619 for (Index
= 0; Index
< FieldCount
; Index
++) {
1620 if (HeaderFields
[Index
].FieldName
!= NULL
) {
1621 FreePool (HeaderFields
[Index
].FieldName
);
1623 if (HeaderFields
[Index
].FieldValue
!= NULL
) {
1624 FreePool (HeaderFields
[Index
].FieldValue
);
1628 FreePool (HeaderFields
);
1633 Generate HTTP request message.
1635 This function will allocate memory for the whole HTTP message and generate a
1636 well formatted HTTP Request message in it, include the Request-Line, header
1637 fields and also the message body. It is the caller's responsibility to free
1638 the buffer returned in *RequestMsg.
1640 @param[in] Message Pointer to the EFI_HTTP_MESSAGE structure which
1641 contains the required information to generate
1642 the HTTP request message.
1643 @param[in] Url The URL of a remote host.
1644 @param[out] RequestMsg Pointer to the created HTTP request message.
1645 NULL if any error occured.
1646 @param[out] RequestMsgSize Size of the RequestMsg (in bytes).
1648 @return EFI_SUCCESS If HTTP request string was created successfully
1649 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1650 @retval EFI_INVALID_PARAMETER The input arguments are invalid
1655 HttpGenRequestMessage (
1656 IN CONST EFI_HTTP_MESSAGE
*Message
,
1657 IN CONST CHAR8
*Url
,
1658 OUT CHAR8
**RequestMsg
,
1659 OUT UINTN
*RequestMsgSize
1669 EFI_HTTP_HEADER
**AppendList
;
1671 EFI_HTTP_UTILITIES_PROTOCOL
*HttpUtilitiesProtocol
;
1674 ASSERT (Message
!= NULL
);
1681 HttpUtilitiesProtocol
= NULL
;
1684 // Locate the HTTP_UTILITIES protocol.
1686 Status
= gBS
->LocateProtocol (
1687 &gEfiHttpUtilitiesProtocolGuid
,
1689 (VOID
**)&HttpUtilitiesProtocol
1692 if (EFI_ERROR (Status
)) {
1693 DEBUG ((DEBUG_ERROR
,"Failed to locate Http Utilities protocol. Status = %r.\n", Status
));
1698 // Build AppendList to send into HttpUtilitiesBuild
1700 AppendList
= AllocateZeroPool (sizeof (EFI_HTTP_HEADER
*) * (Message
->HeaderCount
));
1701 if (AppendList
== NULL
) {
1702 return EFI_OUT_OF_RESOURCES
;
1705 for(Index
= 0; Index
< Message
->HeaderCount
; Index
++){
1706 AppendList
[Index
] = &Message
->Headers
[Index
];
1710 // Build raw HTTP Headers
1712 Status
= HttpUtilitiesProtocol
->Build (
1713 HttpUtilitiesProtocol
,
1718 Message
->HeaderCount
,
1724 if (AppendList
!= NULL
) {
1725 FreePool (AppendList
);
1728 if (EFI_ERROR (Status
) || HttpHdr
== NULL
){
1733 // Calculate HTTP message length.
1735 MsgSize
= Message
->BodyLength
+ HTTP_METHOD_MAXIMUM_LEN
+ AsciiStrLen (Url
) +
1736 AsciiStrLen (HTTP_VERSION_CRLF_STR
) + HttpHdrSize
;
1739 *RequestMsg
= AllocateZeroPool (MsgSize
);
1740 if (*RequestMsg
== NULL
) {
1741 Status
= EFI_OUT_OF_RESOURCES
;
1745 RequestPtr
= *RequestMsg
;
1747 // Construct header request
1749 switch (Message
->Data
.Request
->Method
) {
1751 StrLength
= sizeof (HTTP_METHOD_GET
) - 1;
1752 CopyMem (RequestPtr
, HTTP_METHOD_GET
, StrLength
);
1753 RequestPtr
+= StrLength
;
1756 StrLength
= sizeof (HTTP_METHOD_PUT
) - 1;
1757 CopyMem (RequestPtr
, HTTP_METHOD_PUT
, StrLength
);
1758 RequestPtr
+= StrLength
;
1760 case HttpMethodPatch
:
1761 StrLength
= sizeof (HTTP_METHOD_PATCH
) - 1;
1762 CopyMem (RequestPtr
, HTTP_METHOD_PATCH
, StrLength
);
1763 RequestPtr
+= StrLength
;
1765 case HttpMethodPost
:
1766 StrLength
= sizeof (HTTP_METHOD_POST
) - 1;
1767 CopyMem (RequestPtr
, HTTP_METHOD_POST
, StrLength
);
1768 RequestPtr
+= StrLength
;
1770 case HttpMethodHead
:
1771 StrLength
= sizeof (HTTP_METHOD_HEAD
) - 1;
1772 CopyMem (RequestPtr
, HTTP_METHOD_HEAD
, StrLength
);
1773 RequestPtr
+= StrLength
;
1775 case HttpMethodDelete
:
1776 StrLength
= sizeof (HTTP_METHOD_DELETE
) - 1;
1777 CopyMem (RequestPtr
, HTTP_METHOD_DELETE
, StrLength
);
1778 RequestPtr
+= StrLength
;
1782 Status
= EFI_INVALID_PARAMETER
;
1786 StrLength
= AsciiStrLen(EMPTY_SPACE
);
1787 CopyMem (RequestPtr
, EMPTY_SPACE
, StrLength
);
1788 RequestPtr
+= StrLength
;
1790 StrLength
= AsciiStrLen (Url
);
1791 CopyMem (RequestPtr
, Url
, StrLength
);
1792 RequestPtr
+= StrLength
;
1794 StrLength
= sizeof (HTTP_VERSION_CRLF_STR
) - 1;
1795 CopyMem (RequestPtr
, HTTP_VERSION_CRLF_STR
, StrLength
);
1796 RequestPtr
+= StrLength
;
1801 CopyMem (RequestPtr
, HttpHdr
, HttpHdrSize
);
1802 RequestPtr
+= HttpHdrSize
;
1807 if (Message
->Body
!= NULL
) {
1808 CopyMem (RequestPtr
, Message
->Body
, Message
->BodyLength
);
1809 RequestPtr
+= Message
->BodyLength
;
1815 (*RequestMsgSize
) = (UINTN
)(RequestPtr
) - (UINTN
)(*RequestMsg
);
1821 if (*RequestMsg
!= NULL
) {
1822 FreePool (*RequestMsg
);
1828 if (HttpHdr
!= NULL
) {
1836 Translate the status code in HTTP message to EFI_HTTP_STATUS_CODE defined
1837 in UEFI 2.5 specification.
1839 @param[in] StatusCode The status code value in HTTP message.
1841 @return Value defined in EFI_HTTP_STATUS_CODE .
1844 EFI_HTTP_STATUS_CODE
1846 HttpMappingToStatusCode (
1850 switch (StatusCode
) {
1852 return HTTP_STATUS_100_CONTINUE
;
1854 return HTTP_STATUS_101_SWITCHING_PROTOCOLS
;
1856 return HTTP_STATUS_200_OK
;
1858 return HTTP_STATUS_201_CREATED
;
1860 return HTTP_STATUS_202_ACCEPTED
;
1862 return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION
;
1864 return HTTP_STATUS_204_NO_CONTENT
;
1866 return HTTP_STATUS_205_RESET_CONTENT
;
1868 return HTTP_STATUS_206_PARTIAL_CONTENT
;
1870 return HTTP_STATUS_300_MULTIPLE_CHIOCES
;
1872 return HTTP_STATUS_301_MOVED_PERMANENTLY
;
1874 return HTTP_STATUS_302_FOUND
;
1876 return HTTP_STATUS_303_SEE_OTHER
;
1878 return HTTP_STATUS_304_NOT_MODIFIED
;
1880 return HTTP_STATUS_305_USE_PROXY
;
1882 return HTTP_STATUS_307_TEMPORARY_REDIRECT
;
1884 return HTTP_STATUS_400_BAD_REQUEST
;
1886 return HTTP_STATUS_401_UNAUTHORIZED
;
1888 return HTTP_STATUS_402_PAYMENT_REQUIRED
;
1890 return HTTP_STATUS_403_FORBIDDEN
;
1892 return HTTP_STATUS_404_NOT_FOUND
;
1894 return HTTP_STATUS_405_METHOD_NOT_ALLOWED
;
1896 return HTTP_STATUS_406_NOT_ACCEPTABLE
;
1898 return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED
;
1900 return HTTP_STATUS_408_REQUEST_TIME_OUT
;
1902 return HTTP_STATUS_409_CONFLICT
;
1904 return HTTP_STATUS_410_GONE
;
1906 return HTTP_STATUS_411_LENGTH_REQUIRED
;
1908 return HTTP_STATUS_412_PRECONDITION_FAILED
;
1910 return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE
;
1912 return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE
;
1914 return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE
;
1916 return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED
;
1918 return HTTP_STATUS_417_EXPECTATION_FAILED
;
1920 return HTTP_STATUS_500_INTERNAL_SERVER_ERROR
;
1922 return HTTP_STATUS_501_NOT_IMPLEMENTED
;
1924 return HTTP_STATUS_502_BAD_GATEWAY
;
1926 return HTTP_STATUS_503_SERVICE_UNAVAILABLE
;
1928 return HTTP_STATUS_504_GATEWAY_TIME_OUT
;
1930 return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED
;
1933 return HTTP_STATUS_UNSUPPORTED_STATUS
;
1938 Check whether header field called FieldName is in DeleteList.
1940 @param[in] DeleteList Pointer to array of key/value header pairs.
1941 @param[in] DeleteCount The number of header pairs.
1942 @param[in] FieldName Pointer to header field's name.
1944 @return TRUE if FieldName is not in DeleteList, that means this header field is valid.
1945 @return FALSE if FieldName is in DeleteList, that means this header field is invalid.
1950 HttpIsValidHttpHeader (
1951 IN CHAR8
*DeleteList
[],
1952 IN UINTN DeleteCount
,
1958 for (Index
= 0; Index
< DeleteCount
; Index
++) {
1959 if (AsciiStrCmp (FieldName
, DeleteList
[Index
]) == 0) {