]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Library/DxeHttpLib/DxeHttpLib.c
projects / mirror_edk2.git / blob
? search:


2ff04ffad3ac1b4976c20e1f18a9c12a041f14bd
[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 - 2017, 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 according 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 UINTN Data;
696 UINT32 ResultLength;
697 HTTP_URL_PARSER *Parser;
698
699 if (Url == NULL || UrlParser == NULL || Port == NULL) {
700 return EFI_INVALID_PARAMETER;
701 }
702
703 Parser = (HTTP_URL_PARSER*) UrlParser;
704
705 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PORT)) == 0) {
706 return EFI_INVALID_PARAMETER;
707 }
708
709 PortString = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PORT].Length + 1);
710 if (PortString == NULL) {
711 return EFI_OUT_OF_RESOURCES;
712 }
713
714 Status = UriPercentDecode (
715 Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset,
716 Parser->FieldData[HTTP_URI_FIELD_PORT].Length,
717 PortString,
718 &ResultLength
719 );
720 if (EFI_ERROR (Status)) {
721 return Status;
722 }
723
724 PortString[ResultLength] = '\0';
725
726 Status = AsciiStrDecimalToUintnS (Url + Parser->FieldData[HTTP_URI_FIELD_PORT].Offset, (CHAR8 **) NULL, &Data);
727
728 *Port = (UINT16) Data;
729 return Status;
730 }
731
732 /**
733 Get the Path from a HTTP URL.
734
735 This function will return the Path according to the Url and previous parse result,and
736 it is the caller's responsibility to free the buffer returned in *Path.
737
738 @param[in] Url The pointer to a HTTP URL string.
739 @param[in] UrlParser URL Parse result returned by NetHttpParseUrl().
740 @param[out] Path Pointer to a buffer to store the Path.
741
742 @retval EFI_SUCCESS Successfully get the required component.
743 @retval EFI_INVALID_PARAMETER Uri is NULL or HostName is NULL or UrlParser is invalid.
744 @retval EFI_NOT_FOUND No hostName component in the URL.
745 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
746
747 **/
748 EFI_STATUS
749 EFIAPI
750 HttpUrlGetPath (
751 IN CHAR8 *Url,
752 IN VOID *UrlParser,
753 OUT CHAR8 **Path
754 )
755 {
756 CHAR8 *PathStr;
757 EFI_STATUS Status;
758 UINT32 ResultLength;
759 HTTP_URL_PARSER *Parser;
760
761 if (Url == NULL || UrlParser == NULL || Path == NULL) {
762 return EFI_INVALID_PARAMETER;
763 }
764
765 Parser = (HTTP_URL_PARSER*) UrlParser;
766
767 if ((Parser->FieldBitMap & BIT (HTTP_URI_FIELD_PATH)) == 0) {
768 return EFI_NOT_FOUND;
769 }
770
771 PathStr = AllocatePool (Parser->FieldData[HTTP_URI_FIELD_PATH].Length + 1);
772 if (PathStr == NULL) {
773 return EFI_OUT_OF_RESOURCES;
774 }
775
776 Status = UriPercentDecode (
777 Url + Parser->FieldData[HTTP_URI_FIELD_PATH].Offset,
778 Parser->FieldData[HTTP_URI_FIELD_PATH].Length,
779 PathStr,
780 &ResultLength
781 );
782 if (EFI_ERROR (Status)) {
783 return Status;
784 }
785
786 PathStr[ResultLength] = '\0';
787 *Path = PathStr;
788 return EFI_SUCCESS;
789 }
790
791 /**
792 Release the resource of the URL parser.
793
794 @param[in] UrlParser Pointer to the parser.
795
796 **/
797 VOID
798 EFIAPI
799 HttpUrlFreeParser (
800 IN VOID *UrlParser
801 )
802 {
803 FreePool (UrlParser);
804 }
805
806 /**
807 Find a specified header field according to the field name.
808
809 @param[in] HeaderCount Number of HTTP header structures in Headers list.
810 @param[in] Headers Array containing list of HTTP headers.
811 @param[in] FieldName Null terminated string which describes a field name.
812
813 @return Pointer to the found header or NULL.
814
815 **/
816 EFI_HTTP_HEADER *
817 EFIAPI
818 HttpFindHeader (
819 IN UINTN HeaderCount,
820 IN EFI_HTTP_HEADER *Headers,
821 IN CHAR8 *FieldName
822 )
823 {
824 UINTN Index;
825
826 if (HeaderCount == 0 || Headers == NULL || FieldName == NULL) {
827 return NULL;
828 }
829
830 for (Index = 0; Index < HeaderCount; Index++){
831 //
832 // Field names are case-insensitive (RFC 2616).
833 //
834 if (AsciiStriCmp (Headers[Index].FieldName, FieldName) == 0) {
835 return &Headers[Index];
836 }
837 }
838 return NULL;
839 }
840
841 typedef enum {
842 BodyParserBodyStart,
843 BodyParserBodyIdentity,
844 BodyParserChunkSizeStart,
845 BodyParserChunkSize,
846 BodyParserChunkSizeEndCR,
847 BodyParserChunkExtStart,
848 BodyParserChunkDataStart,
849 BodyParserChunkDataEnd,
850 BodyParserChunkDataEndCR,
851 BodyParserTrailer,
852 BodyParserLastCRLF,
853 BodyParserLastCRLFEnd,
854 BodyParserComplete,
855 BodyParserStateMax
856 } HTTP_BODY_PARSE_STATE;
857
858 typedef struct {
859 BOOLEAN IgnoreBody; // "MUST NOT" include a message-body
860 BOOLEAN IsChunked; // "chunked" transfer-coding.
861 BOOLEAN ContentLengthIsValid;
862 UINTN ContentLength; // Entity length (not the message-body length), invalid until ContentLengthIsValid is TRUE
863
864 HTTP_BODY_PARSER_CALLBACK Callback;
865 VOID *Context;
866 UINTN ParsedBodyLength;
867 HTTP_BODY_PARSE_STATE State;
868 UINTN CurrentChunkSize;
869 UINTN CurrentChunkParsedSize;
870 } HTTP_BODY_PARSER;
871
872 /**
873
874 Convert an Ascii char to its uppercase.
875
876 @param[in] Char Ascii character.
877
878 @return Uppercase value of the input Char.
879
880 **/
881 CHAR8
882 HttpIoCharToUpper (
883 IN CHAR8 Char
884 )
885 {
886 if (Char >= 'a' && Char <= 'z') {
887 return Char - ('a' - 'A');
888 }
889
890 return Char;
891 }
892
893 /**
894 Convert an hexadecimal char to a value of type UINTN.
895
896 @param[in] Char Ascii character.
897
898 @return Value translated from Char.
899
900 **/
901 UINTN
902 HttpIoHexCharToUintn (
903 IN CHAR8 Char
904 )
905 {
906 if (Char >= '0' && Char <= '9') {
907 return Char - '0';
908 }
909
910 return (10 + HttpIoCharToUpper (Char) - 'A');
911 }
912
913 /**
914 Get the value of the content length if there is a "Content-Length" header.
915
916 @param[in] HeaderCount Number of HTTP header structures in Headers.
917 @param[in] Headers Array containing list of HTTP headers.
918 @param[out] ContentLength Pointer to save the value of the content length.
919
920 @retval EFI_SUCCESS Successfully get the content length.
921 @retval EFI_NOT_FOUND No "Content-Length" header in the Headers.
922
923 **/
924 EFI_STATUS
925 HttpIoParseContentLengthHeader (
926 IN UINTN HeaderCount,
927 IN EFI_HTTP_HEADER *Headers,
928 OUT UINTN *ContentLength
929 )
930 {
931 EFI_HTTP_HEADER *Header;
932
933 Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_CONTENT_LENGTH);
934 if (Header == NULL) {
935 return EFI_NOT_FOUND;
936 }
937
938 return AsciiStrDecimalToUintnS (Header->FieldValue, (CHAR8 **) NULL, ContentLength);
939 }
940
941 /**
942
943 Check whether the HTTP message is using the "chunked" transfer-coding.
944
945 @param[in] HeaderCount Number of HTTP header structures in Headers.
946 @param[in] Headers Array containing list of HTTP headers.
947
948 @return The message is "chunked" transfer-coding (TRUE) or not (FALSE).
949
950 **/
951 BOOLEAN
952 HttpIoIsChunked (
953 IN UINTN HeaderCount,
954 IN EFI_HTTP_HEADER *Headers
955 )
956 {
957 EFI_HTTP_HEADER *Header;
958
959
960 Header = HttpFindHeader (HeaderCount, Headers, HTTP_HEADER_TRANSFER_ENCODING);
961 if (Header == NULL) {
962 return FALSE;
963 }
964
965 if (AsciiStriCmp (Header->FieldValue, "identity") != 0) {
966 return TRUE;
967 }
968
969 return FALSE;
970 }
971
972 /**
973 Check whether the HTTP message should have a message-body.
974
975 @param[in] Method The HTTP method (e.g. GET, POST) for this HTTP message.
976 @param[in] StatusCode Response status code returned by the remote host.
977
978 @return The message should have a message-body (FALSE) or not (TRUE).
979
980 **/
981 BOOLEAN
982 HttpIoNoMessageBody (
983 IN EFI_HTTP_METHOD Method,
984 IN EFI_HTTP_STATUS_CODE StatusCode
985 )
986 {
987 //
988 // RFC 2616:
989 // All responses to the HEAD request method
990 // MUST NOT include a message-body, even though the presence of entity-
991 // header fields might lead one to believe they do. All 1xx
992 // (informational), 204 (no content), and 304 (not modified) responses
993 // MUST NOT include a message-body. All other responses do include a
994 // message-body, although it MAY be of zero length.
995 //
996 if (Method == HttpMethodHead) {
997 return TRUE;
998 }
999
1000 if ((StatusCode == HTTP_STATUS_100_CONTINUE) ||
1001 (StatusCode == HTTP_STATUS_101_SWITCHING_PROTOCOLS) ||
1002 (StatusCode == HTTP_STATUS_204_NO_CONTENT) ||
1003 (StatusCode == HTTP_STATUS_304_NOT_MODIFIED))
1004 {
1005 return TRUE;
1006 }
1007
1008 return FALSE;
1009 }
1010
1011 /**
1012 Initialize a HTTP message-body parser.
1013
1014 This function will create and initialize a HTTP message parser according to caller provided HTTP message
1015 header information. It is the caller's responsibility to free the buffer returned in *UrlParser by HttpFreeMsgParser().
1016
1017 @param[in] Method The HTTP method (e.g. GET, POST) for this HTTP message.
1018 @param[in] StatusCode Response status code returned by the remote host.
1019 @param[in] HeaderCount Number of HTTP header structures in Headers.
1020 @param[in] Headers Array containing list of HTTP headers.
1021 @param[in] Callback Callback function that is invoked when parsing the HTTP message-body,
1022 set to NULL to ignore all events.
1023 @param[in] Context Pointer to the context that will be passed to Callback.
1024 @param[out] MsgParser Pointer to the returned buffer to store the message parser.
1025
1026 @retval EFI_SUCCESS Successfully initialized the parser.
1027 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
1028 @retval EFI_INVALID_PARAMETER MsgParser is NULL or HeaderCount is not NULL but Headers is NULL.
1029 @retval Others Failed to initialize the parser.
1030
1031 **/
1032 EFI_STATUS
1033 EFIAPI
1034 HttpInitMsgParser (
1035 IN EFI_HTTP_METHOD Method,
1036 IN EFI_HTTP_STATUS_CODE StatusCode,
1037 IN UINTN HeaderCount,
1038 IN EFI_HTTP_HEADER *Headers,
1039 IN HTTP_BODY_PARSER_CALLBACK Callback,
1040 IN VOID *Context,
1041 OUT VOID **MsgParser
1042 )
1043 {
1044 EFI_STATUS Status;
1045 HTTP_BODY_PARSER *Parser;
1046
1047 if (HeaderCount != 0 && Headers == NULL) {
1048 return EFI_INVALID_PARAMETER;
1049 }
1050
1051 if (MsgParser == NULL) {
1052 return EFI_INVALID_PARAMETER;
1053 }
1054
1055 Parser = AllocateZeroPool (sizeof (HTTP_BODY_PARSER));
1056 if (Parser == NULL) {
1057 return EFI_OUT_OF_RESOURCES;
1058 }
1059
1060 Parser->State = BodyParserBodyStart;
1061
1062 //
1063 // Determine the message length according to RFC 2616.
1064 // 1. Check whether the message "MUST NOT" have a message-body.
1065 //
1066 Parser->IgnoreBody = HttpIoNoMessageBody (Method, StatusCode);
1067 //
1068 // 2. Check whether the message using "chunked" transfer-coding.
1069 //
1070 Parser->IsChunked = HttpIoIsChunked (HeaderCount, Headers);
1071 //
1072 // 3. Check whether the message has a Content-Length header field.
1073 //
1074 Status = HttpIoParseContentLengthHeader (HeaderCount, Headers, &Parser->ContentLength);
1075 if (!EFI_ERROR (Status)) {
1076 Parser->ContentLengthIsValid = TRUE;
1077 }
1078 //
1079 // 4. Range header is not supported now, so we won't meet media type "multipart/byteranges".
1080 // 5. By server closing the connection
1081 //
1082
1083 //
1084 // Set state to skip body parser if the message shouldn't have a message body.
1085 //
1086 if (Parser->IgnoreBody) {
1087 Parser->State = BodyParserComplete;
1088 } else {
1089 Parser->Callback = Callback;
1090 Parser->Context = Context;
1091 }
1092
1093 *MsgParser = Parser;
1094 return EFI_SUCCESS;
1095 }
1096
1097 /**
1098 Parse message body.
1099
1100 Parse BodyLength of message-body. This function can be called repeatedly to parse the message-body partially.
1101
1102 @param[in, out] MsgParser Pointer to the message parser.
1103 @param[in] BodyLength Length in bytes of the Body.
1104 @param[in] Body Pointer to the buffer of the message-body to be parsed.
1105
1106 @retval EFI_SUCCESS Successfully parse the message-body.
1107 @retval EFI_INVALID_PARAMETER MsgParser is NULL or Body is NULL or BodyLength is 0.
1108 @retval Others Operation aborted.
1109
1110 **/
1111 EFI_STATUS
1112 EFIAPI
1113 HttpParseMessageBody (
1114 IN OUT VOID *MsgParser,
1115 IN UINTN BodyLength,
1116 IN CHAR8 *Body
1117 )
1118 {
1119 CHAR8 *Char;
1120 UINTN RemainderLengthInThis;
1121 UINTN LengthForCallback;
1122 EFI_STATUS Status;
1123 HTTP_BODY_PARSER *Parser;
1124
1125 if (BodyLength == 0 || Body == NULL) {
1126 return EFI_INVALID_PARAMETER;
1127 }
1128
1129 if (MsgParser == NULL) {
1130 return EFI_INVALID_PARAMETER;
1131 }
1132
1133 Parser = (HTTP_BODY_PARSER*) MsgParser;
1134
1135 if (Parser->IgnoreBody) {
1136 Parser->State = BodyParserComplete;
1137 if (Parser->Callback != NULL) {
1138 Status = Parser->Callback (
1139 BodyParseEventOnComplete,
1140 Body,
1141 0,
1142 Parser->Context
1143 );
1144 if (EFI_ERROR (Status)) {
1145 return Status;
1146 }
1147 }
1148 return EFI_SUCCESS;
1149 }
1150
1151 if (Parser->State == BodyParserBodyStart) {
1152 Parser->ParsedBodyLength = 0;
1153 if (Parser->IsChunked) {
1154 Parser->State = BodyParserChunkSizeStart;
1155 } else {
1156 Parser->State = BodyParserBodyIdentity;
1157 }
1158 }
1159
1160 //
1161 // The message body might be truncated in anywhere, so we need to parse is byte-by-byte.
1162 //
1163 for (Char = Body; Char < Body + BodyLength; ) {
1164
1165 switch (Parser->State) {
1166 case BodyParserStateMax:
1167 return EFI_ABORTED;
1168
1169 case BodyParserBodyIdentity:
1170 //
1171 // Identity transfer-coding, just notify user to save the body data.
1172 //
1173 if (Parser->Callback != NULL) {
1174 Status = Parser->Callback (
1175 BodyParseEventOnData,
1176 Char,
1177 MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength),
1178 Parser->Context
1179 );
1180 if (EFI_ERROR (Status)) {
1181 return Status;
1182 }
1183 }
1184 Char += MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength);
1185 Parser->ParsedBodyLength += MIN (BodyLength, Parser->ContentLength - Parser->ParsedBodyLength);
1186 if (Parser->ParsedBodyLength == Parser->ContentLength) {
1187 Parser->State = BodyParserComplete;
1188 if (Parser->Callback != NULL) {
1189 Status = Parser->Callback (
1190 BodyParseEventOnComplete,
1191 Char,
1192 0,
1193 Parser->Context
1194 );
1195 if (EFI_ERROR (Status)) {
1196 return Status;
1197 }
1198 }
1199 }
1200 break;
1201
1202 case BodyParserChunkSizeStart:
1203 //
1204 // First byte of chunk-size, the chunk-size might be truncated.
1205 //
1206 Parser->CurrentChunkSize = 0;
1207 Parser->State = BodyParserChunkSize;
1208 case BodyParserChunkSize:
1209 if (!NET_IS_HEX_CHAR (*Char)) {
1210 if (*Char == ';') {
1211 Parser->State = BodyParserChunkExtStart;
1212 Char++;
1213 } else if (*Char == '\r') {
1214 Parser->State = BodyParserChunkSizeEndCR;
1215 Char++;
1216 } else {
1217 Parser->State = BodyParserStateMax;
1218 }
1219 break;
1220 }
1221
1222 if (Parser->CurrentChunkSize > (((~((UINTN) 0)) - 16) / 16)) {
1223 return EFI_INVALID_PARAMETER;
1224 }
1225 Parser->CurrentChunkSize = Parser->CurrentChunkSize * 16 + HttpIoHexCharToUintn (*Char);
1226 Char++;
1227 break;
1228
1229 case BodyParserChunkExtStart:
1230 //
1231 // Ignore all the chunk extensions.
1232 //
1233 if (*Char == '\r') {
1234 Parser->State = BodyParserChunkSizeEndCR;
1235 }
1236 Char++;
1237 break;
1238
1239 case BodyParserChunkSizeEndCR:
1240 if (*Char != '\n') {
1241 Parser->State = BodyParserStateMax;
1242 break;
1243 }
1244 Char++;
1245 if (Parser->CurrentChunkSize == 0) {
1246 //
1247 // The last chunk has been parsed and now assumed the state
1248 // of HttpBodyParse is ParserLastCRLF. So it need to decide
1249 // whether the rest message is trailer or last CRLF in the next round.
1250 //
1251 Parser->ContentLengthIsValid = TRUE;
1252 Parser->State = BodyParserLastCRLF;
1253 break;
1254 }
1255 Parser->State = BodyParserChunkDataStart;
1256 Parser->CurrentChunkParsedSize = 0;
1257 break;
1258
1259 case BodyParserLastCRLF:
1260 //
1261 // Judge the byte is belong to the Last CRLF or trailer, and then
1262 // configure the state of HttpBodyParse to corresponding state.
1263 //
1264 if (*Char == '\r') {
1265 Char++;
1266 Parser->State = BodyParserLastCRLFEnd;
1267 break;
1268 } else {
1269 Parser->State = BodyParserTrailer;
1270 break;
1271 }
1272
1273 case BodyParserLastCRLFEnd:
1274 if (*Char == '\n') {
1275 Parser->State = BodyParserComplete;
1276 Char++;
1277 if (Parser->Callback != NULL) {
1278 Status = Parser->Callback (
1279 BodyParseEventOnComplete,
1280 Char,
1281 0,
1282 Parser->Context
1283 );
1284 if (EFI_ERROR (Status)) {
1285 return Status;
1286 }
1287 }
1288 break;
1289 } else {
1290 Parser->State = BodyParserStateMax;
1291 break;
1292 }
1293
1294 case BodyParserTrailer:
1295 if (*Char == '\r') {
1296 Parser->State = BodyParserChunkSizeEndCR;
1297 }
1298 Char++;
1299 break;
1300
1301 case BodyParserChunkDataStart:
1302 //
1303 // First byte of chunk-data, the chunk data also might be truncated.
1304 //
1305 RemainderLengthInThis = BodyLength - (Char - Body);
1306 LengthForCallback = MIN (Parser->CurrentChunkSize - Parser->CurrentChunkParsedSize, RemainderLengthInThis);
1307 if (Parser->Callback != NULL) {
1308 Status = Parser->Callback (
1309 BodyParseEventOnData,
1310 Char,
1311 LengthForCallback,
1312 Parser->Context
1313 );
1314 if (EFI_ERROR (Status)) {
1315 return Status;
1316 }
1317 }
1318 Char += LengthForCallback;
1319 Parser->ContentLength += LengthForCallback;
1320 Parser->CurrentChunkParsedSize += LengthForCallback;
1321 if (Parser->CurrentChunkParsedSize == Parser->CurrentChunkSize) {
1322 Parser->State = BodyParserChunkDataEnd;
1323 }
1324 break;
1325
1326 case BodyParserChunkDataEnd:
1327 if (*Char == '\r') {
1328 Parser->State = BodyParserChunkDataEndCR;
1329 } else {
1330 Parser->State = BodyParserStateMax;
1331 }
1332 Char++;
1333 break;
1334
1335 case BodyParserChunkDataEndCR:
1336 if (*Char != '\n') {
1337 Parser->State = BodyParserStateMax;
1338 break;
1339 }
1340 Char++;
1341 Parser->State = BodyParserChunkSizeStart;
1342 break;
1343
1344 default:
1345 break;
1346 }
1347
1348 }
1349
1350 if (Parser->State == BodyParserStateMax) {
1351 return EFI_ABORTED;
1352 }
1353
1354 return EFI_SUCCESS;
1355 }
1356
1357 /**
1358 Check whether the message-body is complete or not.
1359
1360 @param[in] MsgParser Pointer to the message parser.
1361
1362 @retval TRUE Message-body is complete.
1363 @retval FALSE Message-body is not complete.
1364
1365 **/
1366 BOOLEAN
1367 EFIAPI
1368 HttpIsMessageComplete (
1369 IN VOID *MsgParser
1370 )
1371 {
1372 HTTP_BODY_PARSER *Parser;
1373
1374 Parser = (HTTP_BODY_PARSER*) MsgParser;
1375
1376 if (Parser->State == BodyParserComplete) {
1377 return TRUE;
1378 }
1379 return FALSE;
1380 }
1381
1382 /**
1383 Get the content length of the entity.
1384
1385 Note that in trunk transfer, the entity length is not valid until the whole message body is received.
1386
1387 @param[in] MsgParser Pointer to the message parser.
1388 @param[out] ContentLength Pointer to store the length of the entity.
1389
1390 @retval EFI_SUCCESS Successfully to get the entity length.
1391 @retval EFI_NOT_READY Entity length is not valid yet.
1392 @retval EFI_INVALID_PARAMETER MsgParser is NULL or ContentLength is NULL.
1393
1394 **/
1395 EFI_STATUS
1396 EFIAPI
1397 HttpGetEntityLength (
1398 IN VOID *MsgParser,
1399 OUT UINTN *ContentLength
1400 )
1401 {
1402 HTTP_BODY_PARSER *Parser;
1403
1404 if (MsgParser == NULL || ContentLength == NULL) {
1405 return EFI_INVALID_PARAMETER;
1406 }
1407
1408 Parser = (HTTP_BODY_PARSER*) MsgParser;
1409
1410 if (!Parser->ContentLengthIsValid) {
1411 return EFI_NOT_READY;
1412 }
1413
1414 *ContentLength = Parser->ContentLength;
1415 return EFI_SUCCESS;
1416 }
1417
1418 /**
1419 Release the resource of the message parser.
1420
1421 @param[in] MsgParser Pointer to the message parser.
1422
1423 **/
1424 VOID
1425 EFIAPI
1426 HttpFreeMsgParser (
1427 IN VOID *MsgParser
1428 )
1429 {
1430 FreePool (MsgParser);
1431 }
1432
1433
1434 /**
1435 Get the next string, which is distinguished by specified separator.
1436
1437 @param[in] String Pointer to the string.
1438 @param[in] Separator Specified separator used to distinguish where is the beginning
1439 of next string.
1440
1441 @return Pointer to the next string.
1442 @return NULL if not find or String is NULL.
1443
1444 **/
1445 CHAR8 *
1446 EFIAPI
1447 AsciiStrGetNextToken (
1448 IN CONST CHAR8 *String,
1449 IN CHAR8 Separator
1450 )
1451 {
1452 CONST CHAR8 *Token;
1453
1454 Token = String;
1455 while (TRUE) {
1456 if (*Token == 0) {
1457 return NULL;
1458 }
1459 if (*Token == Separator) {
1460 return (CHAR8 *)(Token + 1);
1461 }
1462 Token++;
1463 }
1464 }
1465
1466 /**
1467 Set FieldName and FieldValue into specified HttpHeader.
1468
1469 @param[in,out] HttpHeader Specified HttpHeader.
1470 @param[in] FieldName FieldName of this HttpHeader, a NULL terminated ASCII string.
1471 @param[in] FieldValue FieldValue of this HttpHeader, a NULL terminated ASCII string.
1472
1473
1474 @retval EFI_SUCCESS The FieldName and FieldValue are set into HttpHeader successfully.
1475 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1476
1477 **/
1478 EFI_STATUS
1479 EFIAPI
1480 HttpSetFieldNameAndValue (
1481 IN OUT EFI_HTTP_HEADER *HttpHeader,
1482 IN CONST CHAR8 *FieldName,
1483 IN CONST CHAR8 *FieldValue
1484 )
1485 {
1486 UINTN FieldNameSize;
1487 UINTN FieldValueSize;
1488
1489 if (HttpHeader->FieldName != NULL) {
1490 FreePool (HttpHeader->FieldName);
1491 }
1492 if (HttpHeader->FieldValue != NULL) {
1493 FreePool (HttpHeader->FieldValue);
1494 }
1495
1496 FieldNameSize = AsciiStrSize (FieldName);
1497 HttpHeader->FieldName = AllocateZeroPool (FieldNameSize);
1498 if (HttpHeader->FieldName == NULL) {
1499 return EFI_OUT_OF_RESOURCES;
1500 }
1501 CopyMem (HttpHeader->FieldName, FieldName, FieldNameSize);
1502 HttpHeader->FieldName[FieldNameSize - 1] = 0;
1503
1504 FieldValueSize = AsciiStrSize (FieldValue);
1505 HttpHeader->FieldValue = AllocateZeroPool (FieldValueSize);
1506 if (HttpHeader->FieldValue == NULL) {
1507 return EFI_OUT_OF_RESOURCES;
1508 }
1509 CopyMem (HttpHeader->FieldValue, FieldValue, FieldValueSize);
1510 HttpHeader->FieldValue[FieldValueSize - 1] = 0;
1511
1512 return EFI_SUCCESS;
1513 }
1514
1515 /**
1516 Get one key/value header pair from the raw string.
1517
1518 @param[in] String Pointer to the raw string.
1519 @param[out] FieldName Points directly to field name within 'HttpHeader'.
1520 @param[out] FieldValue Points directly to field value within 'HttpHeader'.
1521
1522 @return Pointer to the next raw string.
1523 @return NULL if no key/value header pair from this raw string.
1524
1525 **/
1526 CHAR8 *
1527 EFIAPI
1528 HttpGetFieldNameAndValue (
1529 IN CHAR8 *String,
1530 OUT CHAR8 **FieldName,
1531 OUT CHAR8 **FieldValue
1532 )
1533 {
1534 CHAR8 *FieldNameStr;
1535 CHAR8 *FieldValueStr;
1536 CHAR8 *StrPtr;
1537
1538 if (String == NULL || FieldName == NULL || FieldValue == NULL) {
1539 return NULL;
1540 }
1541
1542 *FieldName = NULL;
1543 *FieldValue = NULL;
1544 FieldNameStr = NULL;
1545 FieldValueStr = NULL;
1546 StrPtr = NULL;
1547
1548 //
1549 // Each header field consists of a name followed by a colon (":") and the field value.
1550 //
1551 FieldNameStr = String;
1552 FieldValueStr = AsciiStrGetNextToken (FieldNameStr, ':');
1553 if (FieldValueStr == NULL) {
1554 return NULL;
1555 }
1556
1557 //
1558 // Replace ':' with 0
1559 //
1560 *(FieldValueStr - 1) = 0;
1561
1562 //
1563 // The field value MAY be preceded by any amount of LWS, though a single SP is preferred.
1564 //
1565 while (TRUE) {
1566 if (*FieldValueStr == ' ' || *FieldValueStr == '\t') {
1567 FieldValueStr ++;
1568 } else if (*FieldValueStr == '\r' && *(FieldValueStr + 1) == '\n' &&
1569 (*(FieldValueStr + 2) == ' ' || *(FieldValueStr + 2) == '\t')) {
1570 FieldValueStr = FieldValueStr + 3;
1571 } else {
1572 break;
1573 }
1574 }
1575
1576 //
1577 // Header fields can be extended over multiple lines by preceding each extra
1578 // line with at least one SP or HT.
1579 //
1580 StrPtr = FieldValueStr;
1581 do {
1582 StrPtr = AsciiStrGetNextToken (StrPtr, '\r');
1583 if (StrPtr == NULL || *StrPtr != '\n') {
1584 return NULL;
1585 }
1586
1587 StrPtr++;
1588 } while (*StrPtr == ' ' || *StrPtr == '\t');
1589
1590 //
1591 // Replace '\r' with 0
1592 //
1593 *(StrPtr - 2) = 0;
1594
1595 //
1596 // Get FieldName and FieldValue.
1597 //
1598 *FieldName = FieldNameStr;
1599 *FieldValue = FieldValueStr;
1600
1601 return StrPtr;
1602 }
1603
1604 /**
1605 Free existing HeaderFields.
1606
1607 @param[in] HeaderFields Pointer to array of key/value header pairs waitting for free.
1608 @param[in] FieldCount The number of header pairs in HeaderFields.
1609
1610 **/
1611 VOID
1612 EFIAPI
1613 HttpFreeHeaderFields (
1614 IN EFI_HTTP_HEADER *HeaderFields,
1615 IN UINTN FieldCount
1616 )
1617 {
1618 UINTN Index;
1619
1620 if (HeaderFields != NULL) {
1621 for (Index = 0; Index < FieldCount; Index++) {
1622 if (HeaderFields[Index].FieldName != NULL) {
1623 FreePool (HeaderFields[Index].FieldName);
1624 }
1625 if (HeaderFields[Index].FieldValue != NULL) {
1626 FreePool (HeaderFields[Index].FieldValue);
1627 }
1628 }
1629
1630 FreePool (HeaderFields);
1631 }
1632 }
1633
1634 /**
1635 Generate HTTP request message.
1636
1637 This function will allocate memory for the whole HTTP message and generate a
1638 well formatted HTTP Request message in it, include the Request-Line, header
1639 fields and also the message body. It is the caller's responsibility to free
1640 the buffer returned in *RequestMsg.
1641
1642 @param[in] Message Pointer to the EFI_HTTP_MESSAGE structure which
1643 contains the required information to generate
1644 the HTTP request message.
1645 @param[in] Url The URL of a remote host.
1646 @param[out] RequestMsg Pointer to the created HTTP request message.
1647 NULL if any error occured.
1648 @param[out] RequestMsgSize Size of the RequestMsg (in bytes).
1649
1650 @return EFI_SUCCESS If HTTP request string was created successfully
1651 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
1652 @retval EFI_INVALID_PARAMETER The input arguments are invalid
1653
1654 **/
1655 EFI_STATUS
1656 EFIAPI
1657 HttpGenRequestMessage (
1658 IN CONST EFI_HTTP_MESSAGE *Message,
1659 IN CONST CHAR8 *Url,
1660 OUT CHAR8 **RequestMsg,
1661 OUT UINTN *RequestMsgSize
1662 )
1663 {
1664 EFI_STATUS Status;
1665 UINTN StrLength;
1666 CHAR8 *RequestPtr;
1667 UINTN HttpHdrSize;
1668 UINTN MsgSize;
1669 BOOLEAN Success;
1670 VOID *HttpHdr;
1671 EFI_HTTP_HEADER **AppendList;
1672 UINTN Index;
1673 EFI_HTTP_UTILITIES_PROTOCOL *HttpUtilitiesProtocol;
1674
1675
1676 ASSERT (Message != NULL);
1677
1678 *RequestMsg = NULL;
1679 Status = EFI_SUCCESS;
1680 HttpHdrSize = 0;
1681 MsgSize = 0;
1682 Success = FALSE;
1683 HttpHdr = NULL;
1684 AppendList = NULL;
1685 HttpUtilitiesProtocol = NULL;
1686
1687 //
1688 // 1. If we have a Request, we cannot have a NULL Url
1689 // 2. If we have a Request, HeaderCount can not be non-zero
1690 // 3. If we do not have a Request, HeaderCount should be zero
1691 // 4. If we do not have Request and Headers, we need at least a message-body
1692 //
1693 if ((Message->Data.Request != NULL && Url == NULL) ||
1694 (Message->Data.Request != NULL && Message->HeaderCount == 0) ||
1695 (Message->Data.Request == NULL && Message->HeaderCount != 0) ||
1696 (Message->Data.Request == NULL && Message->HeaderCount == 0 && Message->BodyLength == 0)) {
1697 return EFI_INVALID_PARAMETER;
1698 }
1699
1700 if (Message->HeaderCount != 0) {
1701 //
1702 // Locate the HTTP_UTILITIES protocol.
1703 //
1704 Status = gBS->LocateProtocol (
1705 &gEfiHttpUtilitiesProtocolGuid,
1706 NULL,
1707 (VOID **)&HttpUtilitiesProtocol
1708 );
1709
1710 if (EFI_ERROR (Status)) {
1711 DEBUG ((DEBUG_ERROR,"Failed to locate Http Utilities protocol. Status = %r.\n", Status));
1712 return Status;
1713 }
1714
1715 //
1716 // Build AppendList to send into HttpUtilitiesBuild
1717 //
1718 AppendList = AllocateZeroPool (sizeof (EFI_HTTP_HEADER *) * (Message->HeaderCount));
1719 if (AppendList == NULL) {
1720 return EFI_OUT_OF_RESOURCES;
1721 }
1722
1723 for(Index = 0; Index < Message->HeaderCount; Index++){
1724 AppendList[Index] = &Message->Headers[Index];
1725 }
1726
1727 //
1728 // Build raw HTTP Headers
1729 //
1730 Status = HttpUtilitiesProtocol->Build (
1731 HttpUtilitiesProtocol,
1732 0,
1733 NULL,
1734 0,
1735 NULL,
1736 Message->HeaderCount,
1737 AppendList,
1738 &HttpHdrSize,
1739 &HttpHdr
1740 );
1741
1742 if (AppendList != NULL) {
1743 FreePool (AppendList);
1744 }
1745
1746 if (EFI_ERROR (Status) || HttpHdr == NULL){
1747 return Status;
1748 }
1749 }
1750
1751 //
1752 // If we have headers to be sent, account for it.
1753 //
1754 if (Message->HeaderCount != 0) {
1755 MsgSize = HttpHdrSize;
1756 }
1757
1758 //
1759 // If we have a request line, account for the fields.
1760 //
1761 if (Message->Data.Request != NULL) {
1762 MsgSize += HTTP_METHOD_MAXIMUM_LEN + AsciiStrLen (HTTP_VERSION_CRLF_STR) + AsciiStrLen (Url);
1763 }
1764
1765
1766 //
1767 // If we have a message body to be sent, account for it.
1768 //
1769 MsgSize += Message->BodyLength;
1770
1771 //
1772 // memory for the string that needs to be sent to TCP
1773 //
1774 *RequestMsg = AllocateZeroPool (MsgSize);
1775 if (*RequestMsg == NULL) {
1776 Status = EFI_OUT_OF_RESOURCES;
1777 goto Exit;
1778 }
1779
1780 RequestPtr = *RequestMsg;
1781 //
1782 // Construct header request
1783 //
1784 if (Message->Data.Request != NULL) {
1785 switch (Message->Data.Request->Method) {
1786 case HttpMethodGet:
1787 StrLength = sizeof (HTTP_METHOD_GET) - 1;
1788 CopyMem (RequestPtr, HTTP_METHOD_GET, StrLength);
1789 RequestPtr += StrLength;
1790 break;
1791 case HttpMethodPut:
1792 StrLength = sizeof (HTTP_METHOD_PUT) - 1;
1793 CopyMem (RequestPtr, HTTP_METHOD_PUT, StrLength);
1794 RequestPtr += StrLength;
1795 break;
1796 case HttpMethodPatch:
1797 StrLength = sizeof (HTTP_METHOD_PATCH) - 1;
1798 CopyMem (RequestPtr, HTTP_METHOD_PATCH, StrLength);
1799 RequestPtr += StrLength;
1800 break;
1801 case HttpMethodPost:
1802 StrLength = sizeof (HTTP_METHOD_POST) - 1;
1803 CopyMem (RequestPtr, HTTP_METHOD_POST, StrLength);
1804 RequestPtr += StrLength;
1805 break;
1806 case HttpMethodHead:
1807 StrLength = sizeof (HTTP_METHOD_HEAD) - 1;
1808 CopyMem (RequestPtr, HTTP_METHOD_HEAD, StrLength);
1809 RequestPtr += StrLength;
1810 break;
1811 case HttpMethodDelete:
1812 StrLength = sizeof (HTTP_METHOD_DELETE) - 1;
1813 CopyMem (RequestPtr, HTTP_METHOD_DELETE, StrLength);
1814 RequestPtr += StrLength;
1815 break;
1816 default:
1817 ASSERT (FALSE);
1818 Status = EFI_INVALID_PARAMETER;
1819 goto Exit;
1820 }
1821
1822 StrLength = AsciiStrLen(EMPTY_SPACE);
1823 CopyMem (RequestPtr, EMPTY_SPACE, StrLength);
1824 RequestPtr += StrLength;
1825
1826 StrLength = AsciiStrLen (Url);
1827 CopyMem (RequestPtr, Url, StrLength);
1828 RequestPtr += StrLength;
1829
1830 StrLength = sizeof (HTTP_VERSION_CRLF_STR) - 1;
1831 CopyMem (RequestPtr, HTTP_VERSION_CRLF_STR, StrLength);
1832 RequestPtr += StrLength;
1833
1834 if (HttpHdr != NULL) {
1835 //
1836 // Construct header
1837 //
1838 CopyMem (RequestPtr, HttpHdr, HttpHdrSize);
1839 RequestPtr += HttpHdrSize;
1840 }
1841 }
1842
1843 //
1844 // Construct body
1845 //
1846 if (Message->Body != NULL) {
1847 CopyMem (RequestPtr, Message->Body, Message->BodyLength);
1848 RequestPtr += Message->BodyLength;
1849 }
1850
1851 //
1852 // Done
1853 //
1854 (*RequestMsgSize) = (UINTN)(RequestPtr) - (UINTN)(*RequestMsg);
1855 Success = TRUE;
1856
1857 Exit:
1858
1859 if (!Success) {
1860 if (*RequestMsg != NULL) {
1861 FreePool (*RequestMsg);
1862 }
1863 *RequestMsg = NULL;
1864 return Status;
1865 }
1866
1867 if (HttpHdr != NULL) {
1868 FreePool (HttpHdr);
1869 }
1870
1871 return EFI_SUCCESS;
1872 }
1873
1874 /**
1875 Translate the status code in HTTP message to EFI_HTTP_STATUS_CODE defined
1876 in UEFI 2.5 specification.
1877
1878 @param[in] StatusCode The status code value in HTTP message.
1879
1880 @return Value defined in EFI_HTTP_STATUS_CODE .
1881
1882 **/
1883 EFI_HTTP_STATUS_CODE
1884 EFIAPI
1885 HttpMappingToStatusCode (
1886 IN UINTN StatusCode
1887 )
1888 {
1889 switch (StatusCode) {
1890 case 100:
1891 return HTTP_STATUS_100_CONTINUE;
1892 case 101:
1893 return HTTP_STATUS_101_SWITCHING_PROTOCOLS;
1894 case 200:
1895 return HTTP_STATUS_200_OK;
1896 case 201:
1897 return HTTP_STATUS_201_CREATED;
1898 case 202:
1899 return HTTP_STATUS_202_ACCEPTED;
1900 case 203:
1901 return HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION;
1902 case 204:
1903 return HTTP_STATUS_204_NO_CONTENT;
1904 case 205:
1905 return HTTP_STATUS_205_RESET_CONTENT;
1906 case 206:
1907 return HTTP_STATUS_206_PARTIAL_CONTENT;
1908 case 300:
1909 return HTTP_STATUS_300_MULTIPLE_CHIOCES;
1910 case 301:
1911 return HTTP_STATUS_301_MOVED_PERMANENTLY;
1912 case 302:
1913 return HTTP_STATUS_302_FOUND;
1914 case 303:
1915 return HTTP_STATUS_303_SEE_OTHER;
1916 case 304:
1917 return HTTP_STATUS_304_NOT_MODIFIED;
1918 case 305:
1919 return HTTP_STATUS_305_USE_PROXY;
1920 case 307:
1921 return HTTP_STATUS_307_TEMPORARY_REDIRECT;
1922 case 400:
1923 return HTTP_STATUS_400_BAD_REQUEST;
1924 case 401:
1925 return HTTP_STATUS_401_UNAUTHORIZED;
1926 case 402:
1927 return HTTP_STATUS_402_PAYMENT_REQUIRED;
1928 case 403:
1929 return HTTP_STATUS_403_FORBIDDEN;
1930 case 404:
1931 return HTTP_STATUS_404_NOT_FOUND;
1932 case 405:
1933 return HTTP_STATUS_405_METHOD_NOT_ALLOWED;
1934 case 406:
1935 return HTTP_STATUS_406_NOT_ACCEPTABLE;
1936 case 407:
1937 return HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED;
1938 case 408:
1939 return HTTP_STATUS_408_REQUEST_TIME_OUT;
1940 case 409:
1941 return HTTP_STATUS_409_CONFLICT;
1942 case 410:
1943 return HTTP_STATUS_410_GONE;
1944 case 411:
1945 return HTTP_STATUS_411_LENGTH_REQUIRED;
1946 case 412:
1947 return HTTP_STATUS_412_PRECONDITION_FAILED;
1948 case 413:
1949 return HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE;
1950 case 414:
1951 return HTTP_STATUS_414_REQUEST_URI_TOO_LARGE;
1952 case 415:
1953 return HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE;
1954 case 416:
1955 return HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED;
1956 case 417:
1957 return HTTP_STATUS_417_EXPECTATION_FAILED;
1958 case 500:
1959 return HTTP_STATUS_500_INTERNAL_SERVER_ERROR;
1960 case 501:
1961 return HTTP_STATUS_501_NOT_IMPLEMENTED;
1962 case 502:
1963 return HTTP_STATUS_502_BAD_GATEWAY;
1964 case 503:
1965 return HTTP_STATUS_503_SERVICE_UNAVAILABLE;
1966 case 504:
1967 return HTTP_STATUS_504_GATEWAY_TIME_OUT;
1968 case 505:
1969 return HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED;
1970
1971 default:
1972 return HTTP_STATUS_UNSUPPORTED_STATUS;
1973 }
1974 }
1975
1976 /**
1977 Check whether header field called FieldName is in DeleteList.
1978
1979 @param[in] DeleteList Pointer to array of key/value header pairs.
1980 @param[in] DeleteCount The number of header pairs.
1981 @param[in] FieldName Pointer to header field's name.
1982
1983 @return TRUE if FieldName is not in DeleteList, that means this header field is valid.
1984 @return FALSE if FieldName is in DeleteList, that means this header field is invalid.
1985
1986 **/
1987 BOOLEAN
1988 EFIAPI
1989 HttpIsValidHttpHeader (
1990 IN CHAR8 *DeleteList[],
1991 IN UINTN DeleteCount,
1992 IN CHAR8 *FieldName
1993 )
1994 {
1995 UINTN Index;
1996
1997 for (Index = 0; Index < DeleteCount; Index++) {
1998 if (AsciiStrCmp (FieldName, DeleteList[Index]) == 0) {
1999 return FALSE;
2000 }
2001 }
2002
2003 return TRUE;
2004 }
2005
EFI Development Kit II mirror for PVE