a4579bf043c2f726826d796355fe8dc4b25bdead
[mirror_edk2.git] / MdeModulePkg / Library / DxeHttpLib / DxeHttpLib.c
1 /** @file
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.
4
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
11
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.
14
15 **/
16
17 #include "DxeHttpLib.h"
18
19
20
21 /**
22 Decode a percent-encoded URI component to the ASCII character.
23
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))
26 in bytes.
27
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.
32
33 @retval EFI_SUCCESS Successfully decoded the URI.
34 @retval EFI_INVALID_PARAMETER Buffer is not a valid percent-encoded string.
35
36 **/
37 EFI_STATUS
38 EFIAPI
39 UriPercentDecode (
40 IN CHAR8 *Buffer,
41 IN UINT32 BufferLength,
42 OUT CHAR8 *ResultBuffer,
43 OUT UINT32 *ResultLength
44 )
45 {
46 UINTN Index;
47 UINTN Offset;
48 CHAR8 HexStr[3];
49
50 if (Buffer == NULL || BufferLength == 0 || ResultBuffer == NULL) {
51 return EFI_INVALID_PARAMETER;
52 }
53
54 Index = 0;
55 Offset = 0;
56 HexStr[2] = '\0';
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;
61 }
62 HexStr[0] = Buffer[Index+1];
63 HexStr[1] = Buffer[Index+2];
64 ResultBuffer[Offset] = (CHAR8) AsciiStrHexToUintn (HexStr);
65 Index += 3;
66 } else {
67 ResultBuffer[Offset] = Buffer[Index];
68 Index++;
69 }
70 Offset++;
71 }
72
73 *ResultLength = (UINT32) Offset;
74
75 return EFI_SUCCESS;
76 }
77
78 /**
79 This function return the updated state according to the input state and next character of
80 the authority.
81
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.
86
87 @return Updated state value.
88 **/
89 HTTP_URL_PARSE_STATE
90 NetHttpParseAuthorityChar (
91 IN CHAR8 Char,
92 IN HTTP_URL_PARSE_STATE State,
93 IN BOOLEAN *IsRightBracket
94 )
95 {
96
97 //
98 // RFC 3986:
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.
102 //
103 if (Char == ' ' || Char == '\r' || Char == '\n') {
104 return UrlParserStateMax;
105 }
106
107 //
108 // authority = [ userinfo "@" ] host [ ":" port ]
109 //
110 switch (State) {
111 case UrlParserUserInfo:
112 if (Char == '@') {
113 return UrlParserHostStart;
114 }
115 break;
116
117 case UrlParserHost:
118 case UrlParserHostStart:
119 if (Char == '[') {
120 return UrlParserHostIpv6;
121 }
122
123 if (Char == ':') {
124 return UrlParserPortStart;
125 }
126
127 return UrlParserHost;
128
129 case UrlParserHostIpv6:
130 if (Char == ']') {
131 *IsRightBracket = TRUE;
132 }
133
134 if (Char == ':' && *IsRightBracket) {
135 return UrlParserPortStart;
136 }
137 return UrlParserHostIpv6;
138
139 case UrlParserPort:
140 case UrlParserPortStart:
141 return UrlParserPort;
142
143 default:
144 break;
145 }
146
147 return State;
148 }
149
150 /**
151 This function parse the authority component of the input URL and update the parser.
152
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.
156
157 @retval EFI_SUCCESS Successfully parse the authority.
158 @retval Other Error happened.
159
160 **/
161 EFI_STATUS
162 NetHttpParseAuthority (
163 IN CHAR8 *Url,
164 IN BOOLEAN FoundAt,
165 IN OUT HTTP_URL_PARSER *UrlParser
166 )
167 {
168 CHAR8 *Char;
169 CHAR8 *Authority;
170 UINT32 Length;
171 HTTP_URL_PARSE_STATE State;
172 UINT32 Field;
173 UINT32 OldField;
174 BOOLEAN IsrightBracket;
175
176 ASSERT ((UrlParser->FieldBitMap & BIT (HTTP_URI_FIELD_AUTHORITY)) != 0);
177
178 //
179 // authority = [ userinfo "@" ] host [ ":" port ]
180 //
181 if (FoundAt) {
182 State = UrlParserUserInfo;
183 } else {
184 State = UrlParserHost;
185 }
186
187 IsrightBracket = FALSE;
188 Field = HTTP_URI_FIELD_MAX;
189 OldField = Field;
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);
194 switch (State) {
195 case UrlParserStateMax:
196 return EFI_INVALID_PARAMETER;
197
198 case UrlParserHostStart:
199 case UrlParserPortStart:
200 continue;
201
202 case UrlParserUserInfo:
203 Field = HTTP_URI_FIELD_USERINFO;
204 break;
205
206 case UrlParserHost:
207 Field = HTTP_URI_FIELD_HOST;
208 break;
209
210 case UrlParserHostIpv6:
211 Field = HTTP_URI_FIELD_HOST;
212 break;
213
214 case UrlParserPort:
215 Field = HTTP_URI_FIELD_PORT;
216 break;
217
218 default:
219 ASSERT (FALSE);
220 }
221
222 //
223 // Field not changed, count the length.
224 //
225 ASSERT (Field < HTTP_URI_FIELD_MAX);
226 if (Field == OldField) {
227 UrlParser->FieldData[Field].Length++;
228 continue;
229 }
230
231 //
232 // New field start
233 //
234 UrlParser->FieldBitMap |= BIT (Field);
235 UrlParser->FieldData[Field].Offset = (UINT32) (Char - Url);
236 UrlParser->FieldData[Field].Length = 1;
237 OldField = Field;
238 }
239
240 return EFI_SUCCESS;
241 }
242
243 /**
244 This function return the updated state according to the input state and next character of a URL.
245
246 @param[in] Char Next character.
247 @param[in] State Current value of the parser state machine.
248
249 @return Updated state value.
250
251 **/
252 HTTP_URL_PARSE_STATE
253 NetHttpParseUrlChar (
254 IN CHAR8 Char,
255 IN HTTP_URL_PARSE_STATE State
256 )
257 {
258 if (Char == ' ' || Char == '\r' || Char == '\n') {
259 return UrlParserStateMax;
260 }
261
262 //
263 // http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
264 //
265 // Request-URI = "*" | absolute-URI | path-absolute | authority
266 //
267 // absolute-URI = scheme ":" hier-part [ "?" query ]
268 // path-absolute = "/" [ segment-nz *( "/" segment ) ]
269 // authority = [ userinfo "@" ] host [ ":" port ]
270 //
271 switch (State) {
272 case UrlParserUrlStart:
273 if (Char == '*' || Char == '/') {
274 return UrlParserPath;
275 }
276 return UrlParserScheme;
277
278 case UrlParserScheme:
279 if (Char == ':') {
280 return UrlParserSchemeColon;
281 }
282 break;
283
284 case UrlParserSchemeColon:
285 if (Char == '/') {
286 return UrlParserSchemeColonSlash;
287 }
288 break;
289
290 case UrlParserSchemeColonSlash:
291 if (Char == '/') {
292 return UrlParserSchemeColonSlashSlash;
293 }
294 break;
295
296 case UrlParserAtInAuthority:
297 if (Char == '@') {
298 return UrlParserStateMax;
299 }
300
301 case UrlParserAuthority:
302 case UrlParserSchemeColonSlashSlash:
303 if (Char == '@') {
304 return UrlParserAtInAuthority;
305 }
306 if (Char == '/') {
307 return UrlParserPath;
308 }
309 if (Char == '?') {
310 return UrlParserQueryStart;
311 }
312 if (Char == '#') {
313 return UrlParserFragmentStart;
314 }
315 return UrlParserAuthority;
316
317 case UrlParserPath:
318 if (Char == '?') {
319 return UrlParserQueryStart;
320 }
321 if (Char == '#') {
322 return UrlParserFragmentStart;
323 }
324 break;
325
326 case UrlParserQuery:
327 case UrlParserQueryStart:
328 if (Char == '#') {
329 return UrlParserFragmentStart;
330 }
331 return UrlParserQuery;
332
333 case UrlParserFragmentStart:
334 return UrlParserFragment;
335
336 default:
337 break;
338 }
339
340 return State;
341 }
342 /**
343 Create a URL parser for the input URL string.
344
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().
348
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.
353
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.
357
358 **/
359 EFI_STATUS
360 EFIAPI
361 HttpParseUrl (
362 IN CHAR8 *Url,
363 IN UINT32 Length,
364 IN BOOLEAN IsConnectMethod,
365 OUT VOID **UrlParser
366 )
367 {
368 HTTP_URL_PARSE_STATE State;
369 CHAR8 *Char;
370 UINT32 Field;
371 UINT32 OldField;
372 BOOLEAN FoundAt;
373 EFI_STATUS Status;
374 HTTP_URL_PARSER *Parser;
375
376 if (Url == NULL || Length == 0 || UrlParser == NULL) {
377 return EFI_INVALID_PARAMETER;
378 }
379
380 Parser = AllocateZeroPool (sizeof (HTTP_URL_PARSER));
381 if (Parser == NULL) {
382 return EFI_OUT_OF_RESOURCES;
383 }
384
385 if (IsConnectMethod) {
386 //
387 // According to RFC 2616, the authority form is only used by the CONNECT method.
388 //
389 State = UrlParserAuthority;
390 } else {
391 State = UrlParserUrlStart;
392 }
393
394 Field = HTTP_URI_FIELD_MAX;
395 OldField = Field;
396 FoundAt = FALSE;
397 for (Char = Url; Char < Url + Length; Char++) {
398 //
399 // Update state machine accoring to next char.
400 //
401 State = NetHttpParseUrlChar (*Char, State);
402
403 switch (State) {
404 case UrlParserStateMax:
405 return EFI_INVALID_PARAMETER;
406
407 case UrlParserSchemeColon:
408 case UrlParserSchemeColonSlash:
409 case UrlParserSchemeColonSlashSlash:
410 case UrlParserQueryStart:
411 case UrlParserFragmentStart:
412 //
413 // Skip all the delimiting char: "://" "?" "@"
414 //
415 continue;
416
417 case UrlParserScheme:
418 Field = HTTP_URI_FIELD_SCHEME;
419 break;
420
421 case UrlParserAtInAuthority:
422 FoundAt = TRUE;
423 case UrlParserAuthority:
424 Field = HTTP_URI_FIELD_AUTHORITY;
425 break;
426
427 case UrlParserPath:
428 Field = HTTP_URI_FIELD_PATH;
429 break;
430
431 case UrlParserQuery:
432 Field = HTTP_URI_FIELD_QUERY;
433 break;
434
435 case UrlParserFragment:
436 Field = HTTP_URI_FIELD_FRAGMENT;
437 break;
438
439 default:
440 ASSERT (FALSE);
441 }
442
443 //
444 // Field not changed, count the length.
445 //
446 ASSERT (Field < HTTP_URI_FIELD_MAX);
447 if (Field == OldField) {
448 Parser->FieldData[Field].Length++;
449 continue;
450 }
451
452 //
453 // New field start
454 //
455 Parser->FieldBitMap |= BIT (Field);
456 Parser->FieldData[Field].Offset = (UINT32) (Char - Url);
457 Parser->FieldData[Field].Length = 1;
458 OldField = Field;
459 }
460
461 //
462 // If has authority component, continue to parse the username, host and port.
463 //
464 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_AUTHORITY)) != 0) {
465 Status = NetHttpParseAuthority (Url, FoundAt, Parser);
466 if (EFI_ERROR (Status)) {
467 return Status;
468 }
469 }
470
471 *UrlParser = Parser;
472 return EFI_SUCCESS;
473 }
474
475 /**
476 Get the Hostname from a HTTP URL.
477
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.
480
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.
484
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.
489
490 **/
491 EFI_STATUS
492 EFIAPI
493 HttpUrlGetHostName (
494 IN CHAR8 *Url,
495 IN VOID *UrlParser,
496 OUT CHAR8 **HostName
497 )
498 {
499 CHAR8 *Name;
500 EFI_STATUS Status;
501 UINT32 ResultLength;
502 HTTP_URL_PARSER *Parser;
503
504 if (Url == NULL || UrlParser == NULL || HostName == NULL) {
505 return EFI_INVALID_PARAMETER;
506 }
507
508 Parser = (HTTP_URL_PARSER*) UrlParser;
509
510 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
511 return EFI_NOT_FOUND;
512 }
513
514 Name = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_HOST].Length + 1);
515 if (Name == NULL) {
516 return EFI_OUT_OF_RESOURCES;
517 }
518
519 Status = UriPercentDecode (
520 Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset,
521 Parser->FieldData[HTTP_URI_FIELD_HOST].Length,
522 Name,
523 &ResultLength
524 );
525 if (EFI_ERROR (Status)) {
526 return Status;
527 }
528
529 Name[ResultLength] = '\0';
530 *HostName = Name;
531 return EFI_SUCCESS;
532 }
533
534
535 /**
536 Get the IPv4 address from a HTTP URL.
537
538 This function will return the IPv4 address according to the Url and previous parse result.
539
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.
543
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.
548
549 **/
550 EFI_STATUS
551 EFIAPI
552 HttpUrlGetIp4 (
553 IN CHAR8 *Url,
554 IN VOID *UrlParser,
555 OUT EFI_IPv4_ADDRESS *Ip4Address
556 )
557 {
558 CHAR8 *Ip4String;
559 EFI_STATUS Status;
560 UINT32 ResultLength;
561 HTTP_URL_PARSER *Parser;
562
563 if (Url == NULL || UrlParser == NULL || Ip4Address == NULL) {
564 return EFI_INVALID_PARAMETER;
565 }
566
567 Parser = (HTTP_URL_PARSER*) UrlParser;
568
569 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
570 return EFI_INVALID_PARAMETER;
571 }
572
573 Ip4String = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_HOST].Length + 1);
574 if (Ip4String == NULL) {
575 return EFI_OUT_OF_RESOURCES;
576 }
577
578 Status = UriPercentDecode (
579 Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset,
580 Parser->FieldData[HTTP_URI_FIELD_HOST].Length,
581 Ip4String,
582 &ResultLength
583 );
584 if (EFI_ERROR (Status)) {
585 return Status;
586 }
587
588 Ip4String[ResultLength] = '\0';
589 Status = NetLibAsciiStrToIp4 (Ip4String, Ip4Address);
590 FreePool (Ip4String);
591
592 return Status;
593 }
594
595 /**
596 Get the IPv6 address from a HTTP URL.
597
598 This function will return the IPv6 address according to the Url and previous parse result.
599
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.
603
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.
608
609 **/
610 EFI_STATUS
611 EFIAPI
612 HttpUrlGetIp6 (
613 IN CHAR8 *Url,
614 IN VOID *UrlParser,
615 OUT EFI_IPv6_ADDRESS *Ip6Address
616 )
617 {
618 CHAR8 *Ip6String;
619 CHAR8 *Ptr;
620 UINT32 Length;
621 EFI_STATUS Status;
622 UINT32 ResultLength;
623 HTTP_URL_PARSER *Parser;
624
625 if (Url == NULL || UrlParser == NULL || Ip6Address == NULL) {
626 return EFI_INVALID_PARAMETER;
627 }
628
629 Parser = (HTTP_URL_PARSER*) UrlParser;
630
631 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_HOST)) == 0) {
632 return EFI_INVALID_PARAMETER;
633 }
634
635 //
636 // IP-literal = "[" ( IPv6address / IPvFuture ) "]"
637 //
638 Length = Parser->FieldData[HTTP_URI_FIELD_HOST].Length;
639 if (Length < 2) {
640 return EFI_INVALID_PARAMETER;
641 }
642
643 Ptr = Url + Parser->FieldData[HTTP_URI_FIELD_HOST].Offset;
644 if ((Ptr[0] != '[') || (Ptr[Length - 1] != ']')) {
645 return EFI_INVALID_PARAMETER;
646 }
647
648 Ip6String = AllocatePool (Length);
649 if (Ip6String == NULL) {
650 return EFI_OUT_OF_RESOURCES;
651 }
652
653 Status = UriPercentDecode (
654 Ptr + 1,
655 Length - 2,
656 Ip6String,
657 &ResultLength
658 );
659 if (EFI_ERROR (Status)) {
660 return Status;
661 }
662
663 Ip6String[ResultLength] = '\0';
664 Status = NetLibAsciiStrToIp6 (Ip6String, Ip6Address);
665 FreePool (Ip6String);
666
667 return Status;
668 }
669
670 /**
671 Get the port number from a HTTP URL.
672
673 This function will return the port number according to the Url and previous parse result.
674
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.
678
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.
683
684 **/
685 EFI_STATUS
686 EFIAPI
687 HttpUrlGetPort (
688 IN CHAR8 *Url,
689 IN VOID *UrlParser,
690 OUT UINT16 *Port
691 )
692 {
693 CHAR8 *PortString;
694 EFI_STATUS Status;
695 UINT32 ResultLength;
696 HTTP_URL_PARSER *Parser;
697
698 if (Url == NULL || UrlParser == NULL || Port == NULL) {
699 return EFI_INVALID_PARAMETER;
700 }
701
702 Parser = (HTTP_URL_PARSER*) UrlParser;
703
704 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PORT)) == 0) {
705 return EFI_INVALID_PARAMETER;
706 }
707
708 PortString = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PORT].Length + 1);
709 if (PortString == NULL) {
710 return EFI_OUT_OF_RESOURCES;
711 }
712
713 Status = UriPercentDecode (
714 Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset,
715 Parser->FieldData[HTTP_URI_FIELD_PORT].Length,
716 PortString,
717 &ResultLength
718 );
719 if (EFI_ERROR (Status)) {
720 return Status;
721 }
722
723 PortString[ResultLength] = '\0';
724 *Port = (UINT16) AsciiStrDecimalToUintn (Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset);
725
726 return EFI_SUCCESS;
727 }
728
729 /**
730 Get the Path from a HTTP URL.
731
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.
734
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.
738
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.
743
744 **/
745 EFI_STATUS
746 EFIAPI
747 HttpUrlGetPath (
748 IN CHAR8 *Url,
749 IN VOID *UrlParser,
750 OUT CHAR8 **Path
751 )
752 {
753 CHAR8 *PathStr;
754 EFI_STATUS Status;
755 UINT32 ResultLength;
756 HTTP_URL_PARSER *Parser;
757
758 if (Url == NULL || UrlParser == NULL || Path == NULL) {
759 return EFI_INVALID_PARAMETER;
760 }
761
762 Parser = (HTTP_URL_PARSER*) UrlParser;
763
764 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PATH)) == 0) {
765 return EFI_NOT_FOUND;
766 }
767
768 PathStr = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PATH].Length + 1);
769 if (PathStr == NULL) {
770 return EFI_OUT_OF_RESOURCES;
771 }
772
773 Status = UriPercentDecode (
774 Url + Parser->FieldData[HTTP_URI_FIELD_PATH].Offset,
775 Parser->FieldData[HTTP_URI_FIELD_PATH].Length,
776 PathStr,
777 &ResultLength
778 );
779 if (EFI_ERROR (Status)) {
780 return Status;
781 }
782
783 PathStr[ResultLength] = '\0';
784 *Path = PathStr;
785 return EFI_SUCCESS;
786 }
787
788 /**
789 Release the resource of the URL parser.
790
791 @param[in] UrlParser Pointer to the parser.
792
793 **/
794 VOID
795 EFIAPI
796 HttpUrlFreeParser (
797 IN VOID *UrlParser
798 )
799 {
800 FreePool (UrlParser);
801 }
802
803 /**
804 Find a specified header field according to the field name.
805
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.
809
810 @return Pointer to the found header or NULL.
811
812 **/
813 EFI_HTTP_HEADER *
814 EFIAPI
815 HttpFindHeader (
816 IN UINTN HeaderCount,
817 IN EFI_HTTP_HEADER *Headers,
818 IN CHAR8 *FieldName
819 )
820 {
821 UINTN Index;
822
823 if (HeaderCount == 0 || Headers == NULL || FieldName == NULL) {
824 return NULL;
825 }
826
827 for (Index = 0; Index < HeaderCount; Index++){
828 //
829 // Field names are case-insensitive (RFC 2616).
830 //
831 if (AsciiStriCmp (Headers[Index].FieldName, FieldName) == 0) {
832 return &Headers[Index];
833 }
834 }
835 return NULL;
836 }
837
838 typedef enum {
839 BodyParserBodyStart,
840 BodyParserBodyIdentity,
841 BodyParserChunkSizeStart,
842 BodyParserChunkSize,
843 BodyParserChunkSizeEndCR,
844 BodyParserChunkExtStart,
845 BodyParserChunkDataStart,
846 BodyParserChunkDataEnd,
847 BodyParserChunkDataEndCR,
848 BodyParserTrailer,
849 BodyParserLastCRLF,
850 BodyParserLastCRLFEnd,
851 BodyParserComplete,
852 BodyParserStateMax
853 } HTTP_BODY_PARSE_STATE;
854
855 typedef struct {
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
860
861 HTTP_BODY_PARSER_CALLBACK Callback;
862 VOID *Context;
863 UINTN ParsedBodyLength;
864 HTTP_BODY_PARSE_STATE State;
865 UINTN CurrentChunkSize;
866 UINTN CurrentChunkParsedSize;
867 } HTTP_BODY_PARSER;
868
869 /**
870
871 Convert an Ascii char to its uppercase.
872
873 @param[in] Char Ascii character.
874
875 @return Uppercase value of the input Char.
876
877 **/
878 CHAR8
879 HttpIoCharToUpper (
880 IN CHAR8 Char
881 )
882 {
883 if (Char >= 'a' && Char <= 'z') {
884 return Char - ('a' - 'A');
885 }
886
887 return Char;
888 }
889
890 /**
891 Convert an hexadecimal char to a value of type UINTN.
892
893 @param[in] Char Ascii character.
894
895 @return Value translated from Char.
896
897 **/
898 UINTN
899 HttpIoHexCharToUintn (
900 IN CHAR8 Char
901 )
902 {
903 if (Char >= '0' && Char <= '9') {
904 return Char - '0';
905 }
906
907 return (10 + HttpIoCharToUpper (Char) - 'A');
908 }
909
910 /**
911 Get the value of the content length if there is a "Content-Length" header.
912
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.
916
917 @retval EFI_SUCCESS Successfully get the content length.
918 @retval EFI_NOT_FOUND No "Content-Length" header in the Headers.
919
920 **/
921 EFI_STATUS
922 HttpIoParseContentLengthHeader (
923 IN UINTN HeaderCount,
924 IN EFI_HTTP_HEADER *Headers,
925 OUT UINTN *ContentLength
926 )
927 {
928 EFI_HTTP_HEADER *Header;
929
930 Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_CONTENT_LENGTH);
931 if (Header == NULL) {
932 return EFI_NOT_FOUND;
933 }
934
935 *ContentLength = AsciiStrDecimalToUintn (Header->FieldValue);
936 return EFI_SUCCESS;
937 }
938
939 /**
940
941 Check whether the HTTP message is using the "chunked" transfer-coding.
942
943 @param[in] HeaderCount Number of HTTP header structures in Headers.
944 @param[in] Headers Array containing list of HTTP headers.
945
946 @return The message is "chunked" transfer-coding (TRUE) or not (FALSE).
947
948 **/
949 BOOLEAN
950 HttpIoIsChunked (
951 IN UINTN HeaderCount,
952 IN EFI_HTTP_HEADER *Headers
953 )
954 {
955 EFI_HTTP_HEADER *Header;
956
957
958 Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
959 if (Header == NULL) {
960 return FALSE;
961 }
962
963 if (AsciiStriCmp (Header->FieldValue, "identity") != 0) {
964 return TRUE;
965 }
966
967 return FALSE;
968 }
969
970 /**
971 Check whether the HTTP message should have a message-body.
972
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.
975
976 @return The message should have a message-body (FALSE) or not (TRUE).
977
978 **/
979 BOOLEAN
980 HttpIoNoMessageBody (
981 IN EFI_HTTP_METHOD Method,
982 IN EFI_HTTP_STATUS_CODE StatusCode
983 )
984 {
985 //
986 // RFC 2616:
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.
993 //
994 if (Method == HttpMethodHead) {
995 return TRUE;
996 }
997
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))
1002 {
1003 return TRUE;
1004 }
1005
1006 return FALSE;
1007 }
1008
1009 /**
1010 Initialize a HTTP message-body parser.
1011
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().
1014
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.
1023
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.
1028
1029 **/
1030 EFI_STATUS
1031 EFIAPI
1032 HttpInitMsgParser (
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,
1038 IN VOID *Context,
1039 OUT VOID **MsgParser
1040 )
1041 {
1042 EFI_STATUS Status;
1043 HTTP_BODY_PARSER *Parser;
1044
1045 if (HeaderCount != 0 && Headers == NULL) {
1046 return EFI_INVALID_PARAMETER;
1047 }
1048
1049 if (MsgParser == NULL) {
1050 return EFI_INVALID_PARAMETER;
1051 }
1052
1053 Parser = AllocateZeroPool (sizeof (HTTP_BODY_PARSER));
1054 if (Parser == NULL) {
1055 return EFI_OUT_OF_RESOURCES;
1056 }
1057
1058 Parser->State = BodyParserBodyStart;
1059
1060 //
1061 // Determine the message length according to RFC 2616.
1062 // 1. Check whether the message "MUST NOT" have a message-body.
1063 //
1064 Parser->IgnoreBody = HttpIoNoMessageBody (Method, StatusCode);
1065 //
1066 // 2. Check whether the message using "chunked" transfer-coding.
1067 //
1068 Parser->IsChunked = HttpIoIsChunked (HeaderCount, Headers);
1069 //
1070 // 3. Check whether the message has a Content-Length header field.
1071 //
1072 Status = HttpIoParseContentLengthHeader (HeaderCount, Headers, &Parser->ContentLength);
1073 if (!EFI_ERROR (Status)) {
1074 Parser->ContentLengthIsValid = TRUE;
1075 }
1076 //
1077 // 4. Range header is not supported now, so we won't meet media type "multipart/byteranges".
1078 // 5. By server closing the connection
1079 //
1080
1081 //
1082 // Set state to skip body parser if the message shouldn't have a message body.
1083 //
1084 if (Parser->IgnoreBody) {
1085 Parser->State = BodyParserComplete;
1086 } else {
1087 Parser->Callback = Callback;
1088 Parser->Context = Context;
1089 }
1090
1091 *MsgParser = Parser;
1092 return EFI_SUCCESS;
1093 }
1094
1095 /**
1096 Parse message body.
1097
1098 Parse BodyLength of message-body. This function can be called repeatedly to parse the message-body partially.
1099
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.
1103
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.
1107
1108 **/
1109 EFI_STATUS
1110 EFIAPI
1111 HttpParseMessageBody (
1112 IN OUT VOID *MsgParser,
1113 IN UINTN BodyLength,
1114 IN CHAR8 *Body
1115 )
1116 {
1117 CHAR8 *Char;
1118 UINTN RemainderLengthInThis;
1119 UINTN LengthForCallback;
1120 EFI_STATUS Status;
1121 HTTP_BODY_PARSER *Parser;
1122
1123 if (BodyLength == 0 || Body == NULL) {
1124 return EFI_INVALID_PARAMETER;
1125 }
1126
1127 if (MsgParser == NULL) {
1128 return EFI_INVALID_PARAMETER;
1129 }
1130
1131 Parser = (HTTP_BODY_PARSER*) MsgParser;
1132
1133 if (Parser->IgnoreBody) {
1134 Parser->State = BodyParserComplete;
1135 if (Parser->Callback != NULL) {
1136 Status = Parser->Callback (
1137 BodyParseEventOnComplete,
1138 Body,
1139 0,
1140 Parser->Context
1141 );
1142 if (EFI_ERROR (Status)) {
1143 return Status;
1144 }
1145 }
1146 return EFI_SUCCESS;
1147 }
1148
1149 if (Parser->State == BodyParserBodyStart) {
1150 Parser->ParsedBodyLength = 0;
1151 if (Parser->IsChunked) {
1152 Parser->State = BodyParserChunkSizeStart;
1153 } else {
1154 Parser->State = BodyParserBodyIdentity;
1155 }
1156 }
1157
1158 //
1159 // The message body might be truncated in anywhere, so we need to parse is byte-by-byte.
1160 //
1161 for (Char = Body; Char < Body + BodyLength; ) {
1162
1163 switch (Parser->State) {
1164 case BodyParserStateMax:
1165 return EFI_ABORTED;
1166
1167 case BodyParserBodyIdentity:
1168 //
1169 // Identity transfer-coding, just notify user to save the body data.
1170 //
1171 if (Parser->Callback != NULL) {
1172 Status = Parser->Callback (
1173 BodyParseEventOnData,
1174 Char,
1175 MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength),
1176 Parser->Context
1177 );
1178 if (EFI_ERROR (Status)) {
1179 return Status;
1180 }
1181 }
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,
1189 Char,
1190 0,
1191 Parser->Context
1192 );
1193 if (EFI_ERROR (Status)) {
1194 return Status;
1195 }
1196 }
1197 }
1198 break;
1199
1200 case BodyParserChunkSizeStart:
1201 //
1202 // First byte of chunk-size, the chunk-size might be truncated.
1203 //
1204 Parser->CurrentChunkSize = 0;
1205 Parser->State = BodyParserChunkSize;
1206 case BodyParserChunkSize:
1207 if (!NET_IS_HEX_CHAR (*Char)) {
1208 if (*Char == ';') {
1209 Parser->State = BodyParserChunkExtStart;
1210 Char++;
1211 } else if (*Char == '\r') {
1212 Parser->State = BodyParserChunkSizeEndCR;
1213 Char++;
1214 } else {
1215 Parser->State = BodyParserStateMax;
1216 }
1217 break;
1218 }
1219
1220 if (Parser->CurrentChunkSize > (((~((UINTN) 0)) - 16) / 16)) {
1221 return EFI_INVALID_PARAMETER;
1222 }
1223 Parser->CurrentChunkSize = Parser->CurrentChunkSize * 16 + HttpIoHexCharToUintn (*Char);
1224 Char++;
1225 break;
1226
1227 case BodyParserChunkExtStart:
1228 //
1229 // Ignore all the chunk extensions.
1230 //
1231 if (*Char == '\r') {
1232 Parser->State = BodyParserChunkSizeEndCR;
1233 }
1234 Char++;
1235 break;
1236
1237 case BodyParserChunkSizeEndCR:
1238 if (*Char != '\n') {
1239 Parser->State = BodyParserStateMax;
1240 break;
1241 }
1242 Char++;
1243 if (Parser->CurrentChunkSize == 0) {
1244 //
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.
1248 //
1249 Parser->ContentLengthIsValid = TRUE;
1250 Parser->State = BodyParserLastCRLF;
1251 break;
1252 }
1253 Parser->State = BodyParserChunkDataStart;
1254 Parser->CurrentChunkParsedSize = 0;
1255 break;
1256
1257 case BodyParserLastCRLF:
1258 //
1259 // Judge the byte is belong to the Last CRLF or trailer, and then
1260 // configure the state of HttpBodyParse to corresponding state.
1261 //
1262 if (*Char == '\r') {
1263 Char++;
1264 Parser->State = BodyParserLastCRLFEnd;
1265 break;
1266 } else {
1267 Parser->State = BodyParserTrailer;
1268 break;
1269 }
1270
1271 case BodyParserLastCRLFEnd:
1272 if (*Char == '\n') {
1273 Parser->State = BodyParserComplete;
1274 Char++;
1275 if (Parser->Callback != NULL) {
1276 Status = Parser->Callback (
1277 BodyParseEventOnComplete,
1278 Char,
1279 0,
1280 Parser->Context
1281 );
1282 if (EFI_ERROR (Status)) {
1283 return Status;
1284 }
1285 }
1286 break;
1287 } else {
1288 Parser->State = BodyParserStateMax;
1289 break;
1290 }
1291
1292 case BodyParserTrailer:
1293 if (*Char == '\r') {
1294 Parser->State = BodyParserChunkSizeEndCR;
1295 }
1296 Char++;
1297 break;
1298
1299 case BodyParserChunkDataStart:
1300 //
1301 // First byte of chunk-data, the chunk data also might be truncated.
1302 //
1303 RemainderLengthInThis = BodyLength - (Char - Body);
1304 LengthForCallback = MIN (Parser->CurrentChunkSize - Parser->CurrentChunkParsedSize, RemainderLengthInThis);
1305 if (Parser->Callback != NULL) {
1306 Status = Parser->Callback (
1307 BodyParseEventOnData,
1308 Char,
1309 LengthForCallback,
1310 Parser->Context
1311 );
1312 if (EFI_ERROR (Status)) {
1313 return Status;
1314 }
1315 }
1316 Char += LengthForCallback;
1317 Parser->ContentLength += LengthForCallback;
1318 Parser->CurrentChunkParsedSize += LengthForCallback;
1319 if (Parser->CurrentChunkParsedSize == Parser->CurrentChunkSize) {
1320 Parser->State = BodyParserChunkDataEnd;
1321 }
1322 break;
1323
1324 case BodyParserChunkDataEnd:
1325 if (*Char == '\r') {
1326 Parser->State = BodyParserChunkDataEndCR;
1327 } else {
1328 Parser->State = BodyParserStateMax;
1329 }
1330 Char++;
1331 break;
1332
1333 case BodyParserChunkDataEndCR:
1334 if (*Char != '\n') {
1335 Parser->State = BodyParserStateMax;
1336 break;
1337 }
1338 Char++;
1339 Parser->State = BodyParserChunkSizeStart;
1340 break;
1341
1342 default:
1343 break;
1344 }
1345
1346 }
1347
1348 if (Parser->State == BodyParserStateMax) {
1349 return EFI_ABORTED;
1350 }
1351
1352 return EFI_SUCCESS;
1353 }
1354
1355 /**
1356 Check whether the message-body is complete or not.
1357
1358 @param[in] MsgParser Pointer to the message parser.
1359
1360 @retval TRUE Message-body is complete.
1361 @retval FALSE Message-body is not complete.
1362
1363 **/
1364 BOOLEAN
1365 EFIAPI
1366 HttpIsMessageComplete (
1367 IN VOID *MsgParser
1368 )
1369 {
1370 HTTP_BODY_PARSER *Parser;
1371
1372 Parser = (HTTP_BODY_PARSER*) MsgParser;
1373
1374 if (Parser->State == BodyParserComplete) {
1375 return TRUE;
1376 }
1377 return FALSE;
1378 }
1379
1380 /**
1381 Get the content length of the entity.
1382
1383 Note that in trunk transfer, the entity length is not valid until the whole message body is received.
1384
1385 @param[in] MsgParser Pointer to the message parser.
1386 @param[out] ContentLength Pointer to store the length of the entity.
1387
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.
1391
1392 **/
1393 EFI_STATUS
1394 EFIAPI
1395 HttpGetEntityLength (
1396 IN VOID *MsgParser,
1397 OUT UINTN *ContentLength
1398 )
1399 {
1400 HTTP_BODY_PARSER *Parser;
1401
1402 if (MsgParser == NULL || ContentLength == NULL) {
1403 return EFI_INVALID_PARAMETER;
1404 }
1405
1406 Parser = (HTTP_BODY_PARSER*) MsgParser;
1407
1408 if (!Parser->ContentLengthIsValid) {
1409 return EFI_NOT_READY;
1410 }
1411
1412 *ContentLength = Parser->ContentLength;
1413 return EFI_SUCCESS;
1414 }
1415
1416 /**
1417 Release the resource of the message parser.
1418
1419 @param[in] MsgParser Pointer to the message parser.
1420
1421 **/
1422 VOID
1423 EFIAPI
1424 HttpFreeMsgParser (
1425 IN VOID *MsgParser
1426 )
1427 {
1428 FreePool (MsgParser);
1429 }
1430
1431
1432 /**
1433 Get the next string, which is distinguished by specified separator.
1434
1435 @param[in] String Pointer to the string.
1436 @param[in] Separator Specified separator used to distinguish where is the beginning
1437 of next string.
1438
1439 @return Pointer to the next string.
1440 @return NULL if not find or String is NULL.
1441
1442 **/
1443 CHAR8 *
1444 EFIAPI
1445 AsciiStrGetNextToken (
1446 IN CONST CHAR8 *String,
1447 IN CHAR8 Separator
1448 )
1449 {
1450 CONST CHAR8 *Token;
1451
1452 Token = String;
1453 while (TRUE) {
1454 if (*Token == 0) {
1455 return NULL;
1456 }
1457 if (*Token == Separator) {
1458 return (CHAR8 *)(Token + 1);
1459 }
1460 Token++;
1461 }
1462 }
1463
1464 /**
1465 Set FieldName and FieldValue into specified HttpHeader.
1466
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.
1470
1471
1472 @retval EFI_SUCCESS The FieldName and FieldValue are set into HttpHeader successfully.
1473 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1474
1475 **/
1476 EFI_STATUS
1477 EFIAPI
1478 HttpSetFieldNameAndValue (
1479 IN OUT EFI_HTTP_HEADER *HttpHeader,
1480 IN CONST CHAR8 *FieldName,
1481 IN CONST CHAR8 *FieldValue
1482 )
1483 {
1484 UINTN FieldNameSize;
1485 UINTN FieldValueSize;
1486
1487 if (HttpHeader->FieldName != NULL) {
1488 FreePool (HttpHeader->FieldName);
1489 }
1490 if (HttpHeader->FieldValue != NULL) {
1491 FreePool (HttpHeader->FieldValue);
1492 }
1493
1494 FieldNameSize = AsciiStrSize (FieldName);
1495 HttpHeader->FieldName = AllocateZeroPool (FieldNameSize);
1496 if (HttpHeader->FieldName == NULL) {
1497 return EFI_OUT_OF_RESOURCES;
1498 }
1499 CopyMem (HttpHeader->FieldName, FieldName, FieldNameSize);
1500 HttpHeader->FieldName[FieldNameSize - 1] = 0;
1501
1502 FieldValueSize = AsciiStrSize (FieldValue);
1503 HttpHeader->FieldValue = AllocateZeroPool (FieldValueSize);
1504 if (HttpHeader->FieldValue == NULL) {
1505 return EFI_OUT_OF_RESOURCES;
1506 }
1507 CopyMem (HttpHeader->FieldValue, FieldValue, FieldValueSize);
1508 HttpHeader->FieldValue[FieldValueSize - 1] = 0;
1509
1510 return EFI_SUCCESS;
1511 }
1512
1513 /**
1514 Get one key/value header pair from the raw string.
1515
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'.
1519
1520 @return Pointer to the next raw string.
1521 @return NULL if no key/value header pair from this raw string.
1522
1523 **/
1524 CHAR8 *
1525 EFIAPI
1526 HttpGetFieldNameAndValue (
1527 IN CHAR8 *String,
1528 OUT CHAR8 **FieldName,
1529 OUT CHAR8 **FieldValue
1530 )
1531 {
1532 CHAR8 *FieldNameStr;
1533 CHAR8 *FieldValueStr;
1534 CHAR8 *StrPtr;
1535
1536 if (String == NULL || FieldName == NULL || FieldValue == NULL) {
1537 return NULL;
1538 }
1539
1540 *FieldName = NULL;
1541 *FieldValue = NULL;
1542 FieldNameStr = NULL;
1543 FieldValueStr = NULL;
1544 StrPtr = NULL;
1545
1546 //
1547 // Each header field consists of a name followed by a colon (":") and the field value.
1548 //
1549 FieldNameStr = String;
1550 FieldValueStr = AsciiStrGetNextToken (FieldNameStr, ':');
1551 if (FieldValueStr == NULL) {
1552 return NULL;
1553 }
1554
1555 //
1556 // Replace ':' with 0
1557 //
1558 *(FieldValueStr - 1) = 0;
1559
1560 //
1561 // The field value MAY be preceded by any amount of LWS, though a single SP is preferred.
1562 //
1563 while (TRUE) {
1564 if (*FieldValueStr == ' ' || *FieldValueStr == '\t') {
1565 FieldValueStr ++;
1566 } else if (*FieldValueStr == '\r' && *(FieldValueStr + 1) == '\n' &&
1567 (*(FieldValueStr + 2) == ' ' || *(FieldValueStr + 2) == '\t')) {
1568 FieldValueStr = FieldValueStr + 3;
1569 } else {
1570 break;
1571 }
1572 }
1573
1574 //
1575 // Header fields can be extended over multiple lines by preceding each extra
1576 // line with at least one SP or HT.
1577 //
1578 StrPtr = FieldValueStr;
1579 do {
1580 StrPtr = AsciiStrGetNextToken (StrPtr, '\r');
1581 if (StrPtr == NULL || *StrPtr != '\n') {
1582 return NULL;
1583 }
1584
1585 StrPtr++;
1586 } while (*StrPtr == ' ' || *StrPtr == '\t');
1587
1588 //
1589 // Replace '\r' with 0
1590 //
1591 *(StrPtr - 2) = 0;
1592
1593 //
1594 // Get FieldName and FieldValue.
1595 //
1596 *FieldName = FieldNameStr;
1597 *FieldValue = FieldValueStr;
1598
1599 return StrPtr;
1600 }
1601
1602 /**
1603 Free existing HeaderFields.
1604
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.
1607
1608 **/
1609 VOID
1610 EFIAPI
1611 HttpFreeHeaderFields (
1612 IN EFI_HTTP_HEADER *HeaderFields,
1613 IN UINTN FieldCount
1614 )
1615 {
1616 UINTN Index;
1617
1618 if (HeaderFields != NULL) {
1619 for (Index = 0; Index < FieldCount; Index++) {
1620 if (HeaderFields[Index].FieldName != NULL) {
1621 FreePool (HeaderFields[Index].FieldName);
1622 }
1623 if (HeaderFields[Index].FieldValue != NULL) {
1624 FreePool (HeaderFields[Index].FieldValue);
1625 }
1626 }
1627
1628 FreePool (HeaderFields);
1629 }
1630 }
1631
1632 /**
1633 Generate HTTP request message.
1634
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.
1639
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).
1647
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
1651
1652 **/
1653 EFI_STATUS
1654 EFIAPI
1655 HttpGenRequestMessage (
1656 IN CONST EFI_HTTP_MESSAGE *Message,
1657 IN CONST CHAR8 *Url,
1658 OUT CHAR8 **RequestMsg,
1659 OUT UINTN *RequestMsgSize
1660 )
1661 {
1662 EFI_STATUS Status;
1663 UINTN StrLength;
1664 CHAR8 *RequestPtr;
1665 UINTN HttpHdrSize;
1666 UINTN MsgSize;
1667 BOOLEAN Success;
1668 VOID *HttpHdr;
1669 EFI_HTTP_HEADER **AppendList;
1670 UINTN Index;
1671 EFI_HTTP_UTILITIES_PROTOCOL *HttpUtilitiesProtocol;
1672
1673
1674 ASSERT (Message != NULL);
1675
1676 *RequestMsg = NULL;
1677 Status = EFI_SUCCESS;
1678 HttpHdrSize = 0;
1679 MsgSize = 0;
1680 Success = FALSE;
1681 HttpHdr = NULL;
1682 AppendList = NULL;
1683 HttpUtilitiesProtocol = NULL;
1684
1685 //
1686 // 1. If we have a Request, we cannot have a NULL Url
1687 // 2. If we have a Request, HeaderCount can not be non-zero
1688 // 3. If we do not have a Request, HeaderCount should be zero
1689 // 4. If we do not have Request and Headers, we need at least a message-body
1690 //
1691 if ((Message->Data.Request != NULL && Url == NULL) ||
1692 (Message->Data.Request != NULL && Message->HeaderCount == 0) ||
1693 (Message->Data.Request == NULL && Message->HeaderCount != 0) ||
1694 (Message->Data.Request == NULL && Message->HeaderCount == 0 && Message->BodyLength == 0)) {
1695 return EFI_INVALID_PARAMETER;
1696 }
1697
1698 if (Message->HeaderCount != 0) {
1699 //
1700 // Locate the HTTP_UTILITIES protocol.
1701 //
1702 Status = gBS->LocateProtocol (
1703 &gEfiHttpUtilitiesProtocolGuid,
1704 NULL,
1705 (VOID **)&HttpUtilitiesProtocol
1706 );
1707
1708 if (EFI_ERROR (Status)) {
1709 DEBUG ((DEBUG_ERROR,"Failed to locate Http Utilities protocol. Status = %r.\n", Status));
1710 return Status;
1711 }
1712
1713 //
1714 // Build AppendList to send into HttpUtilitiesBuild
1715 //
1716 AppendList = AllocateZeroPool (sizeof (EFI_HTTP_HEADER *) * (Message->HeaderCount));
1717 if (AppendList == NULL) {
1718 return EFI_OUT_OF_RESOURCES;
1719 }
1720
1721 for(Index = 0; Index < Message->HeaderCount; Index++){
1722 AppendList[Index] = &Message->Headers[Index];
1723 }
1724
1725 //
1726 // Build raw HTTP Headers
1727 //
1728 Status = HttpUtilitiesProtocol->Build (
1729 HttpUtilitiesProtocol,
1730 0,
1731 NULL,
1732 0,
1733 NULL,
1734 Message->HeaderCount,
1735 AppendList,
1736 &HttpHdrSize,
1737 &HttpHdr
1738 );
1739
1740 if (AppendList != NULL) {
1741 FreePool (AppendList);
1742 }
1743
1744 if (EFI_ERROR (Status) || HttpHdr == NULL){
1745 return Status;
1746 }
1747 }
1748
1749 //
1750 // If we have headers to be sent, account for it.
1751 //
1752 if (Message->HeaderCount != 0) {
1753 MsgSize = HttpHdrSize;
1754 }
1755
1756 //
1757 // If we have a request line, account for the fields.
1758 //
1759 if (Message->Data.Request != NULL) {
1760 MsgSize += HTTP_METHOD_MAXIMUM_LEN + AsciiStrLen (HTTP_VERSION_CRLF_STR) + AsciiStrLen (Url);
1761 }
1762
1763
1764 //
1765 // If we have a message body to be sent, account for it.
1766 //
1767 MsgSize += Message->BodyLength;
1768
1769 //
1770 // memory for the string that needs to be sent to TCP
1771 //
1772 *RequestMsg = AllocateZeroPool (MsgSize);
1773 if (*RequestMsg == NULL) {
1774 Status = EFI_OUT_OF_RESOURCES;
1775 goto Exit;
1776 }
1777
1778 RequestPtr = *RequestMsg;
1779 //
1780 // Construct header request
1781 //
1782 if (Message->Data.Request != NULL) {
1783 switch (Message->Data.Request->Method) {
1784 case HttpMethodGet:
1785 StrLength = sizeof (HTTP_METHOD_GET) - 1;
1786 CopyMem (RequestPtr, HTTP_METHOD_GET, StrLength);
1787 RequestPtr += StrLength;
1788 break;
1789 case HttpMethodPut:
1790 StrLength = sizeof (HTTP_METHOD_PUT) - 1;
1791 CopyMem (RequestPtr, HTTP_METHOD_PUT, StrLength);
1792 RequestPtr += StrLength;
1793 break;
1794 case HttpMethodPatch:
1795 StrLength = sizeof (HTTP_METHOD_PATCH) - 1;
1796 CopyMem (RequestPtr, HTTP_METHOD_PATCH, StrLength);
1797 RequestPtr += StrLength;
1798 break;
1799 case HttpMethodPost:
1800 StrLength = sizeof (HTTP_METHOD_POST) - 1;
1801 CopyMem (RequestPtr, HTTP_METHOD_POST, StrLength);
1802 RequestPtr += StrLength;
1803 break;
1804 case HttpMethodHead:
1805 StrLength = sizeof (HTTP_METHOD_HEAD) - 1;
1806 CopyMem (RequestPtr, HTTP_METHOD_HEAD, StrLength);
1807 RequestPtr += StrLength;
1808 break;
1809 case HttpMethodDelete:
1810 StrLength = sizeof (HTTP_METHOD_DELETE) - 1;
1811 CopyMem (RequestPtr, HTTP_METHOD_DELETE, StrLength);
1812 RequestPtr += StrLength;
1813 break;
1814 default:
1815 ASSERT (FALSE);
1816 Status = EFI_INVALID_PARAMETER;
1817 goto Exit;
1818 }
1819
1820 StrLength = AsciiStrLen(EMPTY_SPACE);
1821 CopyMem (RequestPtr, EMPTY_SPACE, StrLength);
1822 RequestPtr += StrLength;
1823
1824 StrLength = AsciiStrLen (Url);
1825 CopyMem (RequestPtr, Url, StrLength);
1826 RequestPtr += StrLength;
1827
1828 StrLength = sizeof (HTTP_VERSION_CRLF_STR) - 1;
1829 CopyMem (RequestPtr, HTTP_VERSION_CRLF_STR, StrLength);
1830 RequestPtr += StrLength;
1831
1832 if (HttpHdr != NULL) {
1833 //
1834 // Construct header
1835 //
1836 CopyMem (RequestPtr, HttpHdr, HttpHdrSize);
1837 RequestPtr += HttpHdrSize;
1838 }
1839 }
1840
1841 //
1842 // Construct body
1843 //
1844 if (Message->Body != NULL) {
1845 CopyMem (RequestPtr, Message->Body, Message->BodyLength);
1846 RequestPtr += Message->BodyLength;
1847 }
1848
1849 //
1850 // Done
1851 //
1852 (*RequestMsgSize) = (UINTN)(RequestPtr) - (UINTN)(*RequestMsg);
1853 Success = TRUE;
1854
1855 Exit:
1856
1857 if (!Success) {
1858 if (*RequestMsg != NULL) {
1859 FreePool (*RequestMsg);
1860 }
1861 *RequestMsg = NULL;
1862 return Status;
1863 }
1864
1865 if (HttpHdr != NULL) {
1866 FreePool (HttpHdr);
1867 }
1868
1869 return EFI_SUCCESS;
1870 }
1871
1872 /**
1873 Translate the status code in HTTP message to EFI_HTTP_STATUS_CODE defined
1874 in UEFI 2.5 specification.
1875
1876 @param[in] StatusCode The status code value in HTTP message.
1877
1878 @return Value defined in EFI_HTTP_STATUS_CODE .
1879
1880 **/
1881 EFI_HTTP_STATUS_CODE
1882 EFIAPI
1883 HttpMappingToStatusCode (
1884 IN UINTN StatusCode
1885 )
1886 {
1887 switch (StatusCode) {
1888 case 100:
1889 return HTTP_STATUS_100_CONTINUE;
1890 case 101:
1891 return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
1892 case 200:
1893 return HTTP_STATUS_200_OK;
1894 case 201:
1895 return HTTP_STATUS_201_CREATED;
1896 case 202:
1897 return HTTP_STATUS_202_ACCEPTED;
1898 case 203:
1899 return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
1900 case 204:
1901 return HTTP_STATUS_204_NO_CONTENT;
1902 case 205:
1903 return HTTP_STATUS_205_RESET_CONTENT;
1904 case 206:
1905 return HTTP_STATUS_206_PARTIAL_CONTENT;
1906 case 300:
1907 return HTTP_STATUS_300_MULTIPLE_CHIOCES;
1908 case 301:
1909 return HTTP_STATUS_301_MOVED_PERMANENTLY;
1910 case 302:
1911 return HTTP_STATUS_302_FOUND;
1912 case 303:
1913 return HTTP_STATUS_303_SEE_OTHER;
1914 case 304:
1915 return HTTP_STATUS_304_NOT_MODIFIED;
1916 case 305:
1917 return HTTP_STATUS_305_USE_PROXY;
1918 case 307:
1919 return HTTP_STATUS_307_TEMPORARY_REDIRECT;
1920 case 400:
1921 return HTTP_STATUS_400_BAD_REQUEST;
1922 case 401:
1923 return HTTP_STATUS_401_UNAUTHORIZED;
1924 case 402:
1925 return HTTP_STATUS_402_PAYMENT_REQUIRED;
1926 case 403:
1927 return HTTP_STATUS_403_FORBIDDEN;
1928 case 404:
1929 return HTTP_STATUS_404_NOT_FOUND;
1930 case 405:
1931 return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
1932 case 406:
1933 return HTTP_STATUS_406_NOT_ACCEPTABLE;
1934 case 407:
1935 return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
1936 case 408:
1937 return HTTP_STATUS_408_REQUEST_TIME_OUT;
1938 case 409:
1939 return HTTP_STATUS_409_CONFLICT;
1940 case 410:
1941 return HTTP_STATUS_410_GONE;
1942 case 411:
1943 return HTTP_STATUS_411_LENGTH_REQUIRED;
1944 case 412:
1945 return HTTP_STATUS_412_PRECONDITION_FAILED;
1946 case 413:
1947 return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
1948 case 414:
1949 return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
1950 case 415:
1951 return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE;
1952 case 416:
1953 return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
1954 case 417:
1955 return HTTP_STATUS_417_EXPECTATION_FAILED;
1956 case 500:
1957 return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
1958 case 501:
1959 return HTTP_STATUS_501_NOT_IMPLEMENTED;
1960 case 502:
1961 return HTTP_STATUS_502_BAD_GATEWAY;
1962 case 503:
1963 return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
1964 case 504:
1965 return HTTP_STATUS_504_GATEWAY_TIME_OUT;
1966 case 505:
1967 return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
1968
1969 default:
1970 return HTTP_STATUS_UNSUPPORTED_STATUS;
1971 }
1972 }
1973
1974 /**
1975 Check whether header field called FieldName is in DeleteList.
1976
1977 @param[in] DeleteList Pointer to array of key/value header pairs.
1978 @param[in] DeleteCount The number of header pairs.
1979 @param[in] FieldName Pointer to header field's name.
1980
1981 @return TRUE if FieldName is not in DeleteList, that means this header field is valid.
1982 @return FALSE if FieldName is in DeleteList, that means this header field is invalid.
1983
1984 **/
1985 BOOLEAN
1986 EFIAPI
1987 HttpIsValidHttpHeader (
1988 IN CHAR8 *DeleteList[],
1989 IN UINTN DeleteCount,
1990 IN CHAR8 *FieldName
1991 )
1992 {
1993 UINTN Index;
1994
1995 for (Index = 0; Index < DeleteCount; Index++) {
1996 if (AsciiStrCmp (FieldName, DeleteList[Index]) == 0) {
1997 return FALSE;
1998 }
1999 }
2000
2001 return TRUE;
2002 }
2003