SignedCapsulePkg: Fix various typos
[mirror_edk2.git] / SignedCapsulePkg / Library / IniParsingLib / IniParsingLib.c
1 /** @file
2 This library parses the INI configuration file.
3
4 The INI file format is:
5 ================
6 [SectionName]
7 EntryName=EntryValue
8 ================
9
10 Where:
11 1) SectionName is an ASCII string. The valid format is [A-Za-z0-9_]+
12 2) EntryName is an ASCII string. The valid format is [A-Za-z0-9_]+
13 3) EntryValue can be:
14 3.1) an ASCII String. The valid format is [A-Za-z0-9_]+
15 3.2) a GUID. The valid format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, where x is [A-Fa-f0-9]
16 3.3) a decimal value. The valid format is [0-9]+
17 3.4) a hexadecimal value. The valid format is 0x[A-Fa-f0-9]+
18 4) '#' or ';' can be used as comment at anywhere.
19 5) TAB(0x20) or SPACE(0x9) can be used as separator.
20 6) LF(\n, 0xA) or CR(\r, 0xD) can be used as line break.
21
22 Caution: This module requires additional review when modified.
23 This driver will have external input - INI data file.
24
25 OpenIniFile(), PreProcessDataFile(), ProfileGetSection(), ProfileGetEntry()
26 will receive untrusted input and do basic validation.
27
28 Copyright (c) 2016 - 2017, Intel Corporation. All rights reserved.<BR>
29
30 SPDX-License-Identifier: BSD-2-Clause-Patent
31
32 **/
33
34 #include <Uefi.h>
35 #include <Library/BaseLib.h>
36 #include <Library/BaseMemoryLib.h>
37 #include <Library/DebugLib.h>
38 #include <Library/MemoryAllocationLib.h>
39
40 #define IS_HYPHEN(a) ((a) == '-')
41 #define IS_NULL(a) ((a) == '\0')
42
43 // This is default allocation. Reallocation will happen if it is not enough.
44 #define MAX_LINE_LENGTH 512
45
46 typedef struct _INI_SECTION_ITEM SECTION_ITEM;
47 struct _INI_SECTION_ITEM {
48 CHAR8 *PtrSection;
49 UINTN SecNameLen;
50 CHAR8 *PtrEntry;
51 CHAR8 *PtrValue;
52 SECTION_ITEM *PtrNext;
53 };
54
55 typedef struct _INI_COMMENT_LINE COMMENT_LINE;
56 struct _INI_COMMENT_LINE {
57 CHAR8 *PtrComment;
58 COMMENT_LINE *PtrNext;
59 };
60
61 typedef struct {
62 SECTION_ITEM *SectionHead;
63 COMMENT_LINE *CommentHead;
64 } INI_PARSING_LIB_CONTEXT;
65
66 /**
67 Return if the digital char is valid.
68
69 @param[in] DigitalChar The digital char to be checked.
70 @param[in] IncludeHex If it include HEX char.
71
72 @retval TRUE The digital char is valid.
73 @retval FALSE The digital char is invalid.
74 **/
75 BOOLEAN
76 IsValidDigitalChar (
77 IN CHAR8 DigitalChar,
78 IN BOOLEAN IncludeHex
79 )
80 {
81 if (DigitalChar >= '0' && DigitalChar <= '9') {
82 return TRUE;
83 }
84 if (IncludeHex) {
85 if (DigitalChar >= 'a' && DigitalChar <= 'f') {
86 return TRUE;
87 }
88 if (DigitalChar >= 'A' && DigitalChar <= 'F') {
89 return TRUE;
90 }
91 }
92 return FALSE;
93 }
94
95 /**
96 Return if the name char is valid.
97
98 @param[in] NameChar The name char to be checked.
99
100 @retval TRUE The name char is valid.
101 @retval FALSE The name char is invalid.
102 **/
103 BOOLEAN
104 IsValidNameChar (
105 IN CHAR8 NameChar
106 )
107 {
108 if (NameChar >= 'a' && NameChar <= 'z') {
109 return TRUE;
110 }
111 if (NameChar >= 'A' && NameChar <= 'Z') {
112 return TRUE;
113 }
114 if (NameChar >= '0' && NameChar <= '9') {
115 return TRUE;
116 }
117 if (NameChar == '_') {
118 return TRUE;
119 }
120 return FALSE;
121 }
122
123 /**
124 Return if the digital string is valid.
125
126 @param[in] Digital The digital to be checked.
127 @param[in] Length The length of digital string in bytes.
128 @param[in] IncludeHex If it include HEX char.
129
130 @retval TRUE The digital string is valid.
131 @retval FALSE The digital string is invalid.
132 **/
133 BOOLEAN
134 IsValidDigital (
135 IN CHAR8 *Digital,
136 IN UINTN Length,
137 IN BOOLEAN IncludeHex
138 )
139 {
140 UINTN Index;
141 for (Index = 0; Index < Length; Index++) {
142 if (!IsValidDigitalChar(Digital[Index], IncludeHex)) {
143 return FALSE;
144 }
145 }
146 return TRUE;
147 }
148
149 /**
150 Return if the decimal string is valid.
151
152 @param[in] Decimal The decimal string to be checked.
153 @param[in] Length The length of decimal string in bytes.
154
155 @retval TRUE The decimal string is valid.
156 @retval FALSE The decimal string is invalid.
157 **/
158 BOOLEAN
159 IsValidDecimalString (
160 IN CHAR8 *Decimal,
161 IN UINTN Length
162 )
163 {
164 return IsValidDigital(Decimal, Length, FALSE);
165 }
166
167 /**
168 Return if the hexadecimal string is valid.
169
170 @param[in] Hex The hexadecimal string to be checked.
171 @param[in] Length The length of hexadecimal string in bytes.
172
173 @retval TRUE The hexadecimal string is valid.
174 @retval FALSE The hexadecimal string is invalid.
175 **/
176 BOOLEAN
177 IsValidHexString (
178 IN CHAR8 *Hex,
179 IN UINTN Length
180 )
181 {
182 if (Length <= 2) {
183 return FALSE;
184 }
185 if (Hex[0] != '0') {
186 return FALSE;
187 }
188 if (Hex[1] != 'x' && Hex[1] != 'X') {
189 return FALSE;
190 }
191 return IsValidDigital(&Hex[2], Length - 2, TRUE);
192 }
193
194 /**
195 Return if the name string is valid.
196
197 @param[in] Name The name to be checked.
198 @param[in] Length The length of name string in bytes.
199
200 @retval TRUE The name string is valid.
201 @retval FALSE The name string is invalid.
202 **/
203 BOOLEAN
204 IsValidName (
205 IN CHAR8 *Name,
206 IN UINTN Length
207 )
208 {
209 UINTN Index;
210 for (Index = 0; Index < Length; Index++) {
211 if (!IsValidNameChar(Name[Index])) {
212 return FALSE;
213 }
214 }
215 return TRUE;
216 }
217
218 /**
219 Return if the value string is valid GUID.
220
221 @param[in] Value The value to be checked.
222 @param[in] Length The length of value string in bytes.
223
224 @retval TRUE The value string is valid GUID.
225 @retval FALSE The value string is invalid GUID.
226 **/
227 BOOLEAN
228 IsValidGuid (
229 IN CHAR8 *Value,
230 IN UINTN Length
231 )
232 {
233 if (Length != sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") - 1) {
234 return FALSE;
235 }
236 if (!IS_HYPHEN(Value[8])) {
237 return FALSE;
238 }
239 if (!IS_HYPHEN(Value[13])) {
240 return FALSE;
241 }
242 if (!IS_HYPHEN(Value[18])) {
243 return FALSE;
244 }
245 if (!IS_HYPHEN(Value[23])) {
246 return FALSE;
247 }
248 if (!IsValidDigital(&Value[0], 8, TRUE)) {
249 return FALSE;
250 }
251 if (!IsValidDigital(&Value[9], 4, TRUE)) {
252 return FALSE;
253 }
254 if (!IsValidDigital(&Value[14], 4, TRUE)) {
255 return FALSE;
256 }
257 if (!IsValidDigital(&Value[19], 4, TRUE)) {
258 return FALSE;
259 }
260 if (!IsValidDigital(&Value[24], 12, TRUE)) {
261 return FALSE;
262 }
263 return TRUE;
264 }
265
266 /**
267 Return if the value string is valid.
268
269 @param[in] Value The value to be checked.
270 @param[in] Length The length of value string in bytes.
271
272 @retval TRUE The name string is valid.
273 @retval FALSE The name string is invalid.
274 **/
275 BOOLEAN
276 IsValidValue (
277 IN CHAR8 *Value,
278 IN UINTN Length
279 )
280 {
281 if (IsValidName(Value, Length) || IsValidGuid(Value, Length)) {
282 return TRUE;
283 }
284 return FALSE;
285 }
286
287 /**
288 Dump an INI config file context.
289
290 @param[in] Context INI Config file context.
291 **/
292 VOID
293 DumpIniSection (
294 IN VOID *Context
295 )
296 {
297 INI_PARSING_LIB_CONTEXT *IniContext;
298 SECTION_ITEM *PtrSection;
299 SECTION_ITEM *Section;
300
301 if (Context == NULL) {
302 return;
303 }
304
305 IniContext = Context;
306 Section = IniContext->SectionHead;
307
308 while (Section != NULL) {
309 PtrSection = Section;
310 Section = Section->PtrNext;
311 if (PtrSection->PtrSection != NULL) {
312 DEBUG((DEBUG_VERBOSE, "Section - %a\n", PtrSection->PtrSection));
313 }
314 if (PtrSection->PtrEntry != NULL) {
315 DEBUG ((DEBUG_VERBOSE, " Entry - %a\n", PtrSection->PtrEntry));
316 }
317 if (PtrSection->PtrValue != NULL) {
318 DEBUG((DEBUG_VERBOSE, " Value - %a\n", PtrSection->PtrValue));
319 }
320 }
321 }
322
323 /**
324 Copy one line data from buffer data to the line buffer.
325
326 @param[in] Buffer Buffer data.
327 @param[in] BufferSize Buffer Size.
328 @param[in, out] LineBuffer Line buffer to store the found line data.
329 @param[in, out] LineSize On input, size of the input line buffer.
330 On output, size of the actual line buffer.
331
332 @retval EFI_BUFFER_TOO_SMALL The size of input line buffer is not enough.
333 @retval EFI_SUCCESS Copy line data into the line buffer.
334
335 **/
336 EFI_STATUS
337 ProfileGetLine (
338 IN UINT8 *Buffer,
339 IN UINTN BufferSize,
340 IN OUT UINT8 *LineBuffer,
341 IN OUT UINTN *LineSize
342 )
343 {
344 UINTN Length;
345 UINT8 *PtrBuf;
346 UINTN PtrEnd;
347
348 PtrBuf = Buffer;
349 PtrEnd = (UINTN)Buffer + BufferSize;
350
351 //
352 // 0x0D indicates a line break. Otherwise there is no line break
353 //
354 while ((UINTN)PtrBuf < PtrEnd) {
355 if (*PtrBuf == 0x0D || *PtrBuf == 0x0A) {
356 break;
357 }
358 PtrBuf++;
359 }
360
361 if ((UINTN)PtrBuf >= (PtrEnd - 1)) {
362 //
363 // The buffer ends without any line break
364 // or it is the last character of the buffer
365 //
366 Length = BufferSize;
367 } else if (*(PtrBuf + 1) == 0x0A) {
368 //
369 // Further check if a 0x0A follows. If yes, count 0xA
370 //
371 Length = (UINTN) PtrBuf - (UINTN) Buffer + 2;
372 } else {
373 Length = (UINTN) PtrBuf - (UINTN) Buffer + 1;
374 }
375
376 if (Length > (*LineSize)) {
377 *LineSize = Length;
378 return EFI_BUFFER_TOO_SMALL;
379 }
380
381 SetMem (LineBuffer, *LineSize, 0x0);
382 *LineSize = Length;
383 CopyMem (LineBuffer, Buffer, Length);
384
385 return EFI_SUCCESS;
386 }
387
388 /**
389 Trim Buffer by removing all CR, LF, TAB, and SPACE chars in its head and tail.
390
391 @param[in, out] Buffer On input, buffer data to be trimmed.
392 On output, the trimmed buffer.
393 @param[in, out] BufferSize On input, size of original buffer data.
394 On output, size of the trimmed buffer.
395
396 **/
397 VOID
398 ProfileTrim (
399 IN OUT UINT8 *Buffer,
400 IN OUT UINTN *BufferSize
401 )
402 {
403 UINTN Length;
404 UINT8 *PtrBuf;
405 UINT8 *PtrEnd;
406
407 if (*BufferSize == 0) {
408 return;
409 }
410
411 //
412 // Trim the tail first, include CR, LF, TAB, and SPACE.
413 //
414 Length = *BufferSize;
415 PtrBuf = (UINT8 *) ((UINTN) Buffer + Length - 1);
416 while (PtrBuf >= Buffer) {
417 if ((*PtrBuf != 0x0D) && (*PtrBuf != 0x0A )
418 && (*PtrBuf != 0x20) && (*PtrBuf != 0x09)) {
419 break;
420 }
421 PtrBuf --;
422 }
423
424 //
425 // all spaces, a blank line, return directly;
426 //
427 if (PtrBuf < Buffer) {
428 *BufferSize = 0;
429 return;
430 }
431
432 Length = (UINTN)PtrBuf - (UINTN)Buffer + 1;
433 PtrEnd = PtrBuf;
434 PtrBuf = Buffer;
435
436 //
437 // Now skip the heading CR, LF, TAB and SPACE
438 //
439 while (PtrBuf <= PtrEnd) {
440 if ((*PtrBuf != 0x0D) && (*PtrBuf != 0x0A )
441 && (*PtrBuf != 0x20) && (*PtrBuf != 0x09)) {
442 break;
443 }
444 PtrBuf++;
445 }
446
447 //
448 // If no heading CR, LF, TAB or SPACE, directly return
449 //
450 if (PtrBuf == Buffer) {
451 *BufferSize = Length;
452 return;
453 }
454
455 *BufferSize = (UINTN)PtrEnd - (UINTN)PtrBuf + 1;
456
457 //
458 // The first Buffer..PtrBuf characters are CR, LF, TAB or SPACE.
459 // Now move out all these characters.
460 //
461 while (PtrBuf <= PtrEnd) {
462 *Buffer = *PtrBuf;
463 Buffer++;
464 PtrBuf++;
465 }
466
467 return;
468 }
469
470 /**
471 Insert new comment item into comment head.
472
473 @param[in] Buffer Comment buffer to be added.
474 @param[in] BufferSize Size of comment buffer.
475 @param[in, out] CommentHead Comment Item head entry.
476
477 @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
478 @retval EFI_SUCCESS New comment item is inserted.
479
480 **/
481 EFI_STATUS
482 ProfileGetComments (
483 IN UINT8 *Buffer,
484 IN UINTN BufferSize,
485 IN OUT COMMENT_LINE **CommentHead
486 )
487 {
488 COMMENT_LINE *CommentItem;
489
490 CommentItem = NULL;
491 CommentItem = AllocatePool (sizeof (COMMENT_LINE));
492 if (CommentItem == NULL) {
493 return EFI_OUT_OF_RESOURCES;
494 }
495
496 CommentItem->PtrNext = *CommentHead;
497 *CommentHead = CommentItem;
498
499 //
500 // Add a trailing '\0'
501 //
502 CommentItem->PtrComment = AllocatePool (BufferSize + 1);
503 if (CommentItem->PtrComment == NULL) {
504 FreePool (CommentItem);
505 return EFI_OUT_OF_RESOURCES;
506 }
507 CopyMem (CommentItem->PtrComment, Buffer, BufferSize);
508 *(CommentItem->PtrComment + BufferSize) = '\0';
509
510 return EFI_SUCCESS;
511 }
512
513 /**
514 Add new section item into Section head.
515
516 @param[in] Buffer Section item data buffer.
517 @param[in] BufferSize Size of section item.
518 @param[in, out] SectionHead Section item head entry.
519
520 @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
521 @retval EFI_SUCCESS Section item is NULL or Section item is added.
522
523 **/
524 EFI_STATUS
525 ProfileGetSection (
526 IN UINT8 *Buffer,
527 IN UINTN BufferSize,
528 IN OUT SECTION_ITEM **SectionHead
529 )
530 {
531 SECTION_ITEM *SectionItem;
532 UINTN Length;
533 UINT8 *PtrBuf;
534 UINT8 *PtrEnd;
535
536 ASSERT(BufferSize >= 1);
537 //
538 // The first character of Buffer is '[', now we want for ']'
539 //
540 PtrEnd = (UINT8 *)((UINTN)Buffer + BufferSize - 1);
541 PtrBuf = (UINT8 *)((UINTN)Buffer + 1);
542 while (PtrBuf <= PtrEnd) {
543 if (*PtrBuf == ']') {
544 break;
545 }
546 PtrBuf ++;
547 }
548 if (PtrBuf > PtrEnd) {
549 //
550 // Not found. Invalid line
551 //
552 return EFI_NOT_FOUND;
553 }
554 if (PtrBuf <= Buffer + 1) {
555 // Empty name
556 return EFI_NOT_FOUND;
557 }
558
559 //
560 // excluding the heading '[' and tailing ']'
561 //
562 Length = PtrBuf - Buffer - 1;
563 ProfileTrim (
564 Buffer + 1,
565 &Length
566 );
567
568 //
569 // Invalid line if the section name is null
570 //
571 if (Length == 0) {
572 return EFI_NOT_FOUND;
573 }
574
575 if (!IsValidName((CHAR8 *)Buffer + 1, Length)) {
576 return EFI_INVALID_PARAMETER;
577 }
578
579 SectionItem = AllocatePool (sizeof (SECTION_ITEM));
580 if (SectionItem == NULL) {
581 return EFI_OUT_OF_RESOURCES;
582 }
583
584 SectionItem->PtrSection = NULL;
585 SectionItem->SecNameLen = Length;
586 SectionItem->PtrEntry = NULL;
587 SectionItem->PtrValue = NULL;
588 SectionItem->PtrNext = *SectionHead;
589 *SectionHead = SectionItem;
590
591 //
592 // Add a trailing '\0'
593 //
594 SectionItem->PtrSection = AllocatePool (Length + 1);
595 if (SectionItem->PtrSection == NULL) {
596 return EFI_OUT_OF_RESOURCES;
597 }
598
599 //
600 // excluding the heading '['
601 //
602 CopyMem (SectionItem->PtrSection, Buffer + 1, Length);
603 *(SectionItem->PtrSection + Length) = '\0';
604
605 return EFI_SUCCESS;
606 }
607
608 /**
609 Add new section entry and entry value into Section head.
610
611 @param[in] Buffer Section entry data buffer.
612 @param[in] BufferSize Size of section entry.
613 @param[in, out] SectionHead Section item head entry.
614
615 @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
616 @retval EFI_SUCCESS Section entry is added.
617 @retval EFI_NOT_FOUND Section entry is not found.
618 @retval EFI_INVALID_PARAMETER Section entry is invalid.
619
620 **/
621 EFI_STATUS
622 ProfileGetEntry (
623 IN UINT8 *Buffer,
624 IN UINTN BufferSize,
625 IN OUT SECTION_ITEM **SectionHead
626 )
627 {
628 EFI_STATUS Status;
629 SECTION_ITEM *SectionItem;
630 SECTION_ITEM *PtrSection;
631 UINTN Length;
632 UINT8 *PtrBuf;
633 UINT8 *PtrEnd;
634
635 Status = EFI_SUCCESS;
636 PtrBuf = Buffer;
637 PtrEnd = (UINT8 *) ((UINTN)Buffer + BufferSize - 1);
638
639 //
640 // First search for '='
641 //
642 while (PtrBuf <= PtrEnd) {
643 if (*PtrBuf == '=') {
644 break;
645 }
646 PtrBuf++;
647 }
648 if (PtrBuf > PtrEnd) {
649 //
650 // Not found. Invalid line
651 //
652 return EFI_NOT_FOUND;
653 }
654 if (PtrBuf <= Buffer) {
655 // Empty name
656 return EFI_NOT_FOUND;
657 }
658
659 //
660 // excluding the tailing '='
661 //
662 Length = PtrBuf - Buffer;
663 ProfileTrim (
664 Buffer,
665 &Length
666 );
667
668 //
669 // Invalid line if the entry name is null
670 //
671 if (Length == 0) {
672 return EFI_NOT_FOUND;
673 }
674
675 if (!IsValidName((CHAR8 *)Buffer, Length)) {
676 return EFI_INVALID_PARAMETER;
677 }
678
679 //
680 // Omit this line if no section header has been found before
681 //
682 if (*SectionHead == NULL) {
683 return Status;
684 }
685 PtrSection = *SectionHead;
686
687 SectionItem = AllocatePool (sizeof (SECTION_ITEM));
688 if (SectionItem == NULL) {
689 return EFI_OUT_OF_RESOURCES;
690 }
691
692 SectionItem->PtrSection = NULL;
693 SectionItem->PtrEntry = NULL;
694 SectionItem->PtrValue = NULL;
695 SectionItem->SecNameLen = PtrSection->SecNameLen;
696 SectionItem->PtrNext = *SectionHead;
697 *SectionHead = SectionItem;
698
699 //
700 // SectionName, add a trailing '\0'
701 //
702 SectionItem->PtrSection = AllocatePool (PtrSection->SecNameLen + 1);
703 if (SectionItem->PtrSection == NULL) {
704 return EFI_OUT_OF_RESOURCES;
705 }
706 CopyMem (SectionItem->PtrSection, PtrSection->PtrSection, PtrSection->SecNameLen + 1);
707
708 //
709 // EntryName, add a trailing '\0'
710 //
711 SectionItem->PtrEntry = AllocatePool (Length + 1);
712 if (SectionItem->PtrEntry == NULL) {
713 FreePool(SectionItem->PtrSection);
714 return EFI_OUT_OF_RESOURCES;
715 }
716 CopyMem (SectionItem->PtrEntry, Buffer, Length);
717 *(SectionItem->PtrEntry + Length) = '\0';
718
719 //
720 // Next search for '#' or ';'
721 //
722 PtrBuf = PtrBuf + 1;
723 Buffer = PtrBuf;
724 while (PtrBuf <= PtrEnd) {
725 if (*PtrBuf == '#' || *PtrBuf == ';') {
726 break;
727 }
728 PtrBuf++;
729 }
730 if (PtrBuf <= Buffer) {
731 // Empty name
732 FreePool(SectionItem->PtrEntry);
733 FreePool(SectionItem->PtrSection);
734 return EFI_NOT_FOUND;
735 }
736 Length = PtrBuf - Buffer;
737 ProfileTrim (
738 Buffer,
739 &Length
740 );
741
742 //
743 // Invalid line if the entry value is null
744 //
745 if (Length == 0) {
746 FreePool(SectionItem->PtrEntry);
747 FreePool(SectionItem->PtrSection);
748 return EFI_NOT_FOUND;
749 }
750
751 if (!IsValidValue((CHAR8 *)Buffer, Length)) {
752 FreePool(SectionItem->PtrEntry);
753 FreePool(SectionItem->PtrSection);
754 return EFI_INVALID_PARAMETER;
755 }
756
757 //
758 // EntryValue, add a trailing '\0'
759 //
760 SectionItem->PtrValue = AllocatePool (Length + 1);
761 if (SectionItem->PtrValue == NULL) {
762 FreePool(SectionItem->PtrEntry);
763 FreePool(SectionItem->PtrSection);
764 return EFI_OUT_OF_RESOURCES;
765 }
766 CopyMem (SectionItem->PtrValue, Buffer, Length);
767 *(SectionItem->PtrValue + Length) = '\0';
768
769 return EFI_SUCCESS;
770 }
771
772 /**
773 Free all comment entry and section entry.
774
775 @param[in] Section Section entry list.
776 @param[in] Comment Comment entry list.
777
778 **/
779 VOID
780 FreeAllList (
781 IN SECTION_ITEM *Section,
782 IN COMMENT_LINE *Comment
783 )
784 {
785 SECTION_ITEM *PtrSection;
786 COMMENT_LINE *PtrComment;
787
788 while (Section != NULL) {
789 PtrSection = Section;
790 Section = Section->PtrNext;
791 if (PtrSection->PtrEntry != NULL) {
792 FreePool (PtrSection->PtrEntry);
793 }
794 if (PtrSection->PtrSection != NULL) {
795 FreePool (PtrSection->PtrSection);
796 }
797 if (PtrSection->PtrValue != NULL) {
798 FreePool (PtrSection->PtrValue);
799 }
800 FreePool (PtrSection);
801 }
802
803 while (Comment != NULL) {
804 PtrComment = Comment;
805 Comment = Comment->PtrNext;
806 if (PtrComment->PtrComment != NULL) {
807 FreePool (PtrComment->PtrComment);
808 }
809 FreePool (PtrComment);
810 }
811
812 return;
813 }
814
815 /**
816 Get section entry value.
817
818 @param[in] Section Section entry list.
819 @param[in] SectionName Section name.
820 @param[in] EntryName Section entry name.
821 @param[out] EntryValue Point to the got entry value.
822
823 @retval EFI_NOT_FOUND Section is not found.
824 @retval EFI_SUCCESS Section entry value is got.
825
826 **/
827 EFI_STATUS
828 UpdateGetProfileString (
829 IN SECTION_ITEM *Section,
830 IN CHAR8 *SectionName,
831 IN CHAR8 *EntryName,
832 OUT CHAR8 **EntryValue
833 )
834 {
835 *EntryValue = NULL;
836
837 while (Section != NULL) {
838 if (AsciiStrCmp ((CONST CHAR8 *) Section->PtrSection, (CONST CHAR8 *) SectionName) == 0) {
839 if (Section->PtrEntry != NULL) {
840 if (AsciiStrCmp ((CONST CHAR8 *) Section->PtrEntry, (CONST CHAR8 *) EntryName) == 0) {
841 break;
842 }
843 }
844 }
845 Section = Section->PtrNext;
846 }
847
848 if (Section == NULL) {
849 return EFI_NOT_FOUND;
850 }
851
852 *EntryValue = Section->PtrValue;
853
854 return EFI_SUCCESS;
855 }
856
857 /**
858 Pre process config data buffer into Section entry list and Comment entry list.
859
860 @param[in] DataBuffer Config raw file buffer.
861 @param[in] BufferSize Size of raw buffer.
862 @param[in, out] SectionHead Pointer to the section entry list.
863 @param[in, out] CommentHead Pointer to the comment entry list.
864
865 @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
866 @retval EFI_SUCCESS Config data buffer is preprocessed.
867 @retval EFI_NOT_FOUND Config data buffer is invalid, because Section or Entry is not found.
868 @retval EFI_INVALID_PARAMETER Config data buffer is invalid, because Section or Entry is invalid.
869
870 **/
871 EFI_STATUS
872 PreProcessDataFile (
873 IN UINT8 *DataBuffer,
874 IN UINTN BufferSize,
875 IN OUT SECTION_ITEM **SectionHead,
876 IN OUT COMMENT_LINE **CommentHead
877 )
878 {
879 EFI_STATUS Status;
880 CHAR8 *Source;
881 CHAR8 *CurrentPtr;
882 CHAR8 *BufferEnd;
883 CHAR8 *PtrLine;
884 UINTN LineLength;
885 UINTN SourceLength;
886 UINTN MaxLineLength;
887
888 *SectionHead = NULL;
889 *CommentHead = NULL;
890 BufferEnd = (CHAR8 *) ( (UINTN) DataBuffer + BufferSize);
891 CurrentPtr = (CHAR8 *) DataBuffer;
892 MaxLineLength = MAX_LINE_LENGTH;
893 Status = EFI_SUCCESS;
894
895 PtrLine = AllocatePool (MaxLineLength);
896 if (PtrLine == NULL) {
897 return EFI_OUT_OF_RESOURCES;
898 }
899
900 while (CurrentPtr < BufferEnd) {
901 Source = CurrentPtr;
902 SourceLength = (UINTN)BufferEnd - (UINTN)CurrentPtr;
903 LineLength = MaxLineLength;
904 //
905 // With the assumption that line length is less than 512
906 // characters. Otherwise BUFFER_TOO_SMALL will be returned.
907 //
908 Status = ProfileGetLine (
909 (UINT8 *) Source,
910 SourceLength,
911 (UINT8 *) PtrLine,
912 &LineLength
913 );
914 if (EFI_ERROR (Status)) {
915 if (Status == EFI_BUFFER_TOO_SMALL) {
916 //
917 // If buffer too small, re-allocate the buffer according
918 // to the returned LineLength and try again.
919 //
920 FreePool (PtrLine);
921 PtrLine = NULL;
922 PtrLine = AllocatePool (LineLength);
923 if (PtrLine == NULL) {
924 Status = EFI_OUT_OF_RESOURCES;
925 break;
926 }
927 SourceLength = LineLength;
928 Status = ProfileGetLine (
929 (UINT8 *) Source,
930 SourceLength,
931 (UINT8 *) PtrLine,
932 &LineLength
933 );
934 if (EFI_ERROR (Status)) {
935 break;
936 }
937 MaxLineLength = LineLength;
938 } else {
939 break;
940 }
941 }
942 CurrentPtr = (CHAR8 *) ( (UINTN) CurrentPtr + LineLength);
943
944 //
945 // Line got. Trim the line before processing it.
946 //
947 ProfileTrim (
948 (UINT8 *) PtrLine,
949 &LineLength
950 );
951
952 //
953 // Blank line
954 //
955 if (LineLength == 0) {
956 continue;
957 }
958
959 if (PtrLine[0] == '#' || PtrLine[0] == ';') {
960 Status = ProfileGetComments (
961 (UINT8 *) PtrLine,
962 LineLength,
963 CommentHead
964 );
965 } else if (PtrLine[0] == '[') {
966 Status = ProfileGetSection (
967 (UINT8 *) PtrLine,
968 LineLength,
969 SectionHead
970 );
971 } else {
972 Status = ProfileGetEntry (
973 (UINT8 *) PtrLine,
974 LineLength,
975 SectionHead
976 );
977 }
978
979 if (EFI_ERROR (Status)) {
980 break;
981 }
982 }
983
984 //
985 // Free buffer
986 //
987 FreePool (PtrLine);
988
989 return Status;
990 }
991
992 /**
993 Open an INI config file and return a context.
994
995 @param[in] DataBuffer Config raw file buffer.
996 @param[in] BufferSize Size of raw buffer.
997
998 @return Config data buffer is opened and context is returned.
999 @retval NULL No enough memory is allocated.
1000 @retval NULL Config data buffer is invalid.
1001 **/
1002 VOID *
1003 EFIAPI
1004 OpenIniFile (
1005 IN UINT8 *DataBuffer,
1006 IN UINTN BufferSize
1007 )
1008 {
1009 EFI_STATUS Status;
1010 INI_PARSING_LIB_CONTEXT *IniContext;
1011
1012 if (DataBuffer == NULL || BufferSize == 0) {
1013 return NULL;
1014 }
1015
1016 IniContext = AllocateZeroPool(sizeof(INI_PARSING_LIB_CONTEXT));
1017 if (IniContext == NULL) {
1018 return NULL;
1019 }
1020
1021 //
1022 // First process the data buffer and get all sections and entries
1023 //
1024 Status = PreProcessDataFile (
1025 DataBuffer,
1026 BufferSize,
1027 &IniContext->SectionHead,
1028 &IniContext->CommentHead
1029 );
1030 if (EFI_ERROR(Status)) {
1031 FreePool(IniContext);
1032 return NULL;
1033 }
1034 DEBUG_CODE_BEGIN ();
1035 DumpIniSection(IniContext);
1036 DEBUG_CODE_END ();
1037 return IniContext;
1038 }
1039
1040 /**
1041 Get section entry string value.
1042
1043 @param[in] Context INI Config file context.
1044 @param[in] SectionName Section name.
1045 @param[in] EntryName Section entry name.
1046 @param[out] EntryValue Point to the got entry string value.
1047
1048 @retval EFI_SUCCESS Section entry string value is got.
1049 @retval EFI_NOT_FOUND Section is not found.
1050 **/
1051 EFI_STATUS
1052 EFIAPI
1053 GetStringFromDataFile(
1054 IN VOID *Context,
1055 IN CHAR8 *SectionName,
1056 IN CHAR8 *EntryName,
1057 OUT CHAR8 **EntryValue
1058 )
1059 {
1060 INI_PARSING_LIB_CONTEXT *IniContext;
1061 EFI_STATUS Status;
1062
1063 if (Context == NULL || SectionName == NULL || EntryName == NULL || EntryValue == NULL) {
1064 return EFI_INVALID_PARAMETER;
1065 }
1066
1067 IniContext = Context;
1068
1069 *EntryValue = NULL;
1070 Status = UpdateGetProfileString (
1071 IniContext->SectionHead,
1072 SectionName,
1073 EntryName,
1074 EntryValue
1075 );
1076 return Status;
1077 }
1078
1079 /**
1080 Get section entry GUID value.
1081
1082 @param[in] Context INI Config file context.
1083 @param[in] SectionName Section name.
1084 @param[in] EntryName Section entry name.
1085 @param[out] Guid Point to the got GUID value.
1086
1087 @retval EFI_SUCCESS Section entry GUID value is got.
1088 @retval EFI_NOT_FOUND Section is not found.
1089 **/
1090 EFI_STATUS
1091 EFIAPI
1092 GetGuidFromDataFile (
1093 IN VOID *Context,
1094 IN CHAR8 *SectionName,
1095 IN CHAR8 *EntryName,
1096 OUT EFI_GUID *Guid
1097 )
1098 {
1099 CHAR8 *Value;
1100 EFI_STATUS Status;
1101 RETURN_STATUS RStatus;
1102
1103 if (Context == NULL || SectionName == NULL || EntryName == NULL || Guid == NULL) {
1104 return EFI_INVALID_PARAMETER;
1105 }
1106
1107 Status = GetStringFromDataFile(
1108 Context,
1109 SectionName,
1110 EntryName,
1111 &Value
1112 );
1113 if (EFI_ERROR(Status)) {
1114 return EFI_NOT_FOUND;
1115 }
1116 ASSERT (Value != NULL);
1117 RStatus = AsciiStrToGuid (Value, Guid);
1118 if (RETURN_ERROR (RStatus) || (Value[GUID_STRING_LENGTH] != '\0')) {
1119 return EFI_NOT_FOUND;
1120 }
1121 return EFI_SUCCESS;
1122 }
1123
1124 /**
1125 Get section entry decimal UINTN value.
1126
1127 @param[in] Context INI Config file context.
1128 @param[in] SectionName Section name.
1129 @param[in] EntryName Section entry name.
1130 @param[out] Data Point to the got decimal UINTN value.
1131
1132 @retval EFI_SUCCESS Section entry decimal UINTN value is got.
1133 @retval EFI_NOT_FOUND Section is not found.
1134 **/
1135 EFI_STATUS
1136 EFIAPI
1137 GetDecimalUintnFromDataFile (
1138 IN VOID *Context,
1139 IN CHAR8 *SectionName,
1140 IN CHAR8 *EntryName,
1141 OUT UINTN *Data
1142 )
1143 {
1144 CHAR8 *Value;
1145 EFI_STATUS Status;
1146
1147 if (Context == NULL || SectionName == NULL || EntryName == NULL || Data == NULL) {
1148 return EFI_INVALID_PARAMETER;
1149 }
1150
1151 Status = GetStringFromDataFile(
1152 Context,
1153 SectionName,
1154 EntryName,
1155 &Value
1156 );
1157 if (EFI_ERROR(Status)) {
1158 return EFI_NOT_FOUND;
1159 }
1160 ASSERT (Value != NULL);
1161 if (!IsValidDecimalString(Value, AsciiStrLen(Value))) {
1162 return EFI_NOT_FOUND;
1163 }
1164 *Data = AsciiStrDecimalToUintn(Value);
1165 return EFI_SUCCESS;
1166 }
1167
1168 /**
1169 Get section entry hexadecimal UINTN value.
1170
1171 @param[in] Context INI Config file context.
1172 @param[in] SectionName Section name.
1173 @param[in] EntryName Section entry name.
1174 @param[out] Data Point to the got hexadecimal UINTN value.
1175
1176 @retval EFI_SUCCESS Section entry hexadecimal UINTN value is got.
1177 @retval EFI_NOT_FOUND Section is not found.
1178 **/
1179 EFI_STATUS
1180 EFIAPI
1181 GetHexUintnFromDataFile (
1182 IN VOID *Context,
1183 IN CHAR8 *SectionName,
1184 IN CHAR8 *EntryName,
1185 OUT UINTN *Data
1186 )
1187 {
1188 CHAR8 *Value;
1189 EFI_STATUS Status;
1190
1191 if (Context == NULL || SectionName == NULL || EntryName == NULL || Data == NULL) {
1192 return EFI_INVALID_PARAMETER;
1193 }
1194
1195 Status = GetStringFromDataFile(
1196 Context,
1197 SectionName,
1198 EntryName,
1199 &Value
1200 );
1201 if (EFI_ERROR(Status)) {
1202 return EFI_NOT_FOUND;
1203 }
1204 ASSERT (Value != NULL);
1205 if (!IsValidHexString(Value, AsciiStrLen(Value))) {
1206 return EFI_NOT_FOUND;
1207 }
1208 *Data = AsciiStrHexToUintn(Value);
1209 return EFI_SUCCESS;
1210 }
1211
1212 /**
1213 Get section entry hexadecimal UINT64 value.
1214
1215 @param[in] Context INI Config file context.
1216 @param[in] SectionName Section name.
1217 @param[in] EntryName Section entry name.
1218 @param[out] Data Point to the got hexadecimal UINT64 value.
1219
1220 @retval EFI_SUCCESS Section entry hexadecimal UINT64 value is got.
1221 @retval EFI_NOT_FOUND Section is not found.
1222 **/
1223 EFI_STATUS
1224 EFIAPI
1225 GetHexUint64FromDataFile (
1226 IN VOID *Context,
1227 IN CHAR8 *SectionName,
1228 IN CHAR8 *EntryName,
1229 OUT UINT64 *Data
1230 )
1231 {
1232 CHAR8 *Value;
1233 EFI_STATUS Status;
1234
1235 if (Context == NULL || SectionName == NULL || EntryName == NULL || Data == NULL) {
1236 return EFI_INVALID_PARAMETER;
1237 }
1238
1239 Status = GetStringFromDataFile(
1240 Context,
1241 SectionName,
1242 EntryName,
1243 &Value
1244 );
1245 if (EFI_ERROR(Status)) {
1246 return EFI_NOT_FOUND;
1247 }
1248 ASSERT (Value != NULL);
1249 if (!IsValidHexString(Value, AsciiStrLen(Value))) {
1250 return EFI_NOT_FOUND;
1251 }
1252 *Data = AsciiStrHexToUint64(Value);
1253 return EFI_SUCCESS;
1254 }
1255
1256 /**
1257 Close an INI config file and free the context.
1258
1259 @param[in] Context INI Config file context.
1260 **/
1261 VOID
1262 EFIAPI
1263 CloseIniFile (
1264 IN VOID *Context
1265 )
1266 {
1267 INI_PARSING_LIB_CONTEXT *IniContext;
1268
1269 if (Context == NULL) {
1270 return ;
1271 }
1272
1273 IniContext = Context;
1274 FreeAllList(IniContext->SectionHead, IniContext->CommentHead);
1275
1276 return;
1277 }