]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/GenSec/GenSec.c
projects / mirror_edk2.git / blob
? search:


32b8cfd5a0c5ad40cba785abf648a8828180025b
[mirror_edk2.git] / BaseTools / Source / C / GenSec / GenSec.c
1 /** @file
2
3 Copyright (c) 2004 - 2008, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 GenSection.c
15
16 Abstract:
17
18 Creates output file that is a properly formed section per the PI spec.
19
20 **/
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26
27 #include <Common/UefiBaseTypes.h>
28 #include <Common/PiFirmwareFile.h>
29 #include <Protocol/GuidedSectionExtraction.h>
30
31 #include "CommonLib.h"
32 #include "Compress.h"
33 #include "Crc32.h"
34 #include "EfiUtilityMsgs.h"
35 #include "ParseInf.h"
36
37 //
38 // GenSec Tool Information
39 //
40 #define UTILITY_NAME "GenSec"
41 #define UTILITY_MAJOR_VERSION 0
42 #define UTILITY_MINOR_VERSION 1
43
44 #define MAX_SECTION_SIZE 0x1000000
45
46 STATIC CHAR8 *mSectionTypeName[] = {
47 NULL, // 0x00 - reserved
48 "EFI_SECTION_COMPRESSION", // 0x01
49 "EFI_SECTION_GUID_DEFINED", // 0x02
50 NULL, // 0x03 - reserved
51 NULL, // 0x04 - reserved
52 NULL, // 0x05 - reserved
53 NULL, // 0x06 - reserved
54 NULL, // 0x07 - reserved
55 NULL, // 0x08 - reserved
56 NULL, // 0x09 - reserved
57 NULL, // 0x0A - reserved
58 NULL, // 0x0B - reserved
59 NULL, // 0x0C - reserved
60 NULL, // 0x0D - reserved
61 NULL, // 0x0E - reserved
62 NULL, // 0x0F - reserved
63 "EFI_SECTION_PE32", // 0x10
64 "EFI_SECTION_PIC", // 0x11
65 "EFI_SECTION_TE", // 0x12
66 "EFI_SECTION_DXE_DEPEX", // 0x13
67 "EFI_SECTION_VERSION", // 0x14
68 "EFI_SECTION_USER_INTERFACE", // 0x15
69 "EFI_SECTION_COMPATIBILITY16", // 0x16
70 "EFI_SECTION_FIRMWARE_VOLUME_IMAGE", // 0x17
71 "EFI_SECTION_FREEFORM_SUBTYPE_GUID", // 0x18
72 "EFI_SECTION_RAW", // 0x19
73 NULL, // 0x1A
74 "EFI_SECTION_PEI_DEPEX", // 0x1B
75 "EFI_SECTION_SMM_DEPEX" // 0x1C
76 };
77
78 STATIC CHAR8 *mCompressionTypeName[] = { "PI_NONE", "PI_STD" };
79
80 #define EFI_GUIDED_SECTION_NONE 0x80
81 STATIC CHAR8 *mGUIDedSectionAttribue[] = { "NONE", "PROCESSING_REQUIRED", "AUTH_STATUS_VALID"};
82
83 //
84 // Crc32 GUID section related definitions.
85 //
86 typedef struct {
87 EFI_GUID_DEFINED_SECTION GuidSectionHeader;
88 UINT32 CRC32Checksum;
89 } CRC32_SECTION_HEADER;
90
91 STATIC EFI_GUID mZeroGuid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
92 STATIC EFI_GUID mEfiCrc32SectionGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;
93
94 STATIC
95 VOID
96 Version (
97 VOID
98 )
99 /*++
100
101 Routine Description:
102
103 Print out version information for this utility.
104
105 Arguments:
106
107 None
108
109 Returns:
110
111 None
112
113 --*/
114 {
115 fprintf (stdout, "%s Version %d.%d\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION);
116 }
117
118 STATIC
119 VOID
120 Usage (
121 VOID
122 )
123 /*++
124
125 Routine Description:
126
127 Print Help message.
128
129 Arguments:
130
131 VOID
132
133 Returns:
134
135 None
136
137 --*/
138 {
139 //
140 // Summary usage
141 //
142 fprintf (stdout, "\nUsage: %s [options] [input_file]\n\n", UTILITY_NAME);
143
144 //
145 // Copyright declaration
146 //
147 fprintf (stdout, "Copyright (c) 2007, Intel Corporation. All rights reserved.\n\n");
148
149 //
150 // Details Option
151 //
152 fprintf (stdout, "Options:\n");
153 fprintf (stdout, " -o FileName, --outputfile FileName\n\
154 File is the SectionFile to be created.\n");
155 fprintf (stdout, " -s [SectionType], --sectiontype [SectionType]\n\
156 SectionType defined in PI spec is one type of\n\
157 EFI_SECTION_COMPRESSION, EFI_SECTION_GUID_DEFINED,\n\
158 EFI_SECTION_PE32, EFI_SECTION_PIC, EFI_SECTION_TE,\n\
159 EFI_SECTION_DXE_DEPEX, EFI_SECTION_COMPATIBILITY16,\n\
160 EFI_SECTION_USER_INTERFACE, EFI_SECTION_VERSION,\n\
161 EFI_SECTION_FIRMWARE_VOLUME_IMAGE, EFI_SECTION_RAW,\n\
162 EFI_SECTION_FREEFORM_SUBTYPE_GUID,\n\
163 EFI_SECTION_PEI_DEPEX, EFI_SECTION_SMM_DEPEX.\n\
164 if -s option is not given, \n\
165 EFI_SECTION_ALL is default section type.\n");
166 fprintf (stdout, " -c [Type], --compress [Type]\n\
167 Compress method type can be PI_NONE or PI_STD.\n\
168 if -c option is not given, PI_STD is default type.\n");
169 fprintf (stdout, " -g GuidValue, --vendor GuidValue\n\
170 GuidValue is one specific vendor guid value.\n\
171 Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");
172 fprintf (stdout, " -l GuidHeaderLength, --HeaderLength GuidHeaderLength\n\
173 GuidHeaderLength is the size of header of guided data\n");
174 fprintf (stdout, " -r GuidAttr, --attributes GuidAttr\n\
175 GuidAttr is guid section atttributes, which may be\n\
176 PROCESSING_REQUIRED, AUTH_STATUS_VALID and NONE. \n\
177 if -r option is not given, default PROCESSING_REQUIRED\n");
178 fprintf (stdout, " -n String, --name String\n\
179 String is a NULL terminated string used in Ui section.\n");
180 fprintf (stdout, " -j Number, --buildnumber Number\n\
181 Number is an integer value between 0000 and 9999\n\
182 used in Ver section.\n");
183 fprintf (stdout, " -v, --verbose Turn on verbose output with informational messages.\n");
184 fprintf (stdout, " -q, --quiet Disable all messages except key message and fatal error\n");
185 fprintf (stdout, " -d, --debug level Enable debug messages, at input debug level.\n");
186 fprintf (stdout, " --version Show program's version number and exit.\n");
187 fprintf (stdout, " -h, --help Show this help message and exit.\n");
188 }
189
190 VOID
191 Ascii2UnicodeString (
192 CHAR8 *String,
193 CHAR16 *UniString
194 )
195 /*++
196
197 Routine Description:
198
199 Write ascii string as unicode string format to FILE
200
201 Arguments:
202
203 String - Pointer to string that is written to FILE.
204 UniString - Pointer to unicode string
205
206 Returns:
207
208 NULL
209
210 --*/
211 {
212 while (*String != '\0') {
213 *(UniString++) = (CHAR16) *(String++);
214 }
215 //
216 // End the UniString with a NULL.
217 //
218 *UniString = '\0';
219 }
220
221 STATUS
222 GenSectionCommonLeafSection (
223 CHAR8 **InputFileName,
224 UINT32 InputFileNum,
225 UINT8 SectionType,
226 UINT8 **OutFileBuffer
227 )
228 /*++
229
230 Routine Description:
231
232 Generate a leaf section of type other than EFI_SECTION_VERSION
233 and EFI_SECTION_USER_INTERFACE. Input file must be well formed.
234 The function won't validate the input file's contents. For
235 common leaf sections, the input file may be a binary file.
236 The utility will add section header to the file.
237
238 Arguments:
239
240 InputFileName - Name of the input file.
241
242 InputFileNum - Number of input files. Should be 1 for leaf section.
243
244 SectionType - A valid section type string
245
246 OutFileBuffer - Buffer pointer to Output file contents
247
248 Returns:
249
250 STATUS_ERROR - can't continue
251 STATUS_SUCCESS - successful return
252
253 --*/
254 {
255 UINT32 InputFileLength;
256 FILE *InFile;
257 UINT8 *Buffer;
258 UINT32 TotalLength;
259 EFI_COMMON_SECTION_HEADER *CommonSect;
260 STATUS Status;
261
262 if (InputFileNum > 1) {
263 Error (NULL, 0, 2000, "Invalid paramter", "more than one input file specified");
264 return STATUS_ERROR;
265 } else if (InputFileNum < 1) {
266 Error (NULL, 0, 2000, "Invalid paramter", "no input file specified");
267 return STATUS_ERROR;
268 }
269 //
270 // Open the input file
271 //
272 InFile = fopen (InputFileName[0], "rb");
273 if (InFile == NULL) {
274 Error (NULL, 0, 0001, "Error opening file", InputFileName[0]);
275 return STATUS_ERROR;
276 }
277
278 Status = STATUS_ERROR;
279 Buffer = NULL;
280 //
281 // Seek to the end of the input file so we can determine its size
282 //
283 fseek (InFile, 0, SEEK_END);
284 InputFileLength = ftell (InFile);
285 fseek (InFile, 0, SEEK_SET);
286 DebugMsg (NULL, 0, 9, "Input file", "File name is %s and File size is %u bytes", InputFileName[0], (unsigned) InputFileLength);
287 TotalLength = sizeof (EFI_COMMON_SECTION_HEADER) + InputFileLength;
288 //
289 // Size must fit in 3 bytes
290 //
291 if (TotalLength >= MAX_SECTION_SIZE) {
292 Error (NULL, 0, 2000, "Invalid paramter", "%s file size (0x%X) exceeds section size limit(%uM).", InputFileName[0], (unsigned) TotalLength, MAX_SECTION_SIZE>>20);
293 goto Done;
294 }
295 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
296 //
297 // Fill in the fields in the local section header structure
298 //
299 Buffer = (UINT8 *) malloc ((size_t) TotalLength);
300 if (Buffer == NULL) {
301 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
302 goto Done;
303 }
304 CommonSect = (EFI_COMMON_SECTION_HEADER *) Buffer;
305 CommonSect->Type = SectionType;
306 CommonSect->Size[0] = (UINT8) (TotalLength & 0xff);
307 CommonSect->Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
308 CommonSect->Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
309
310 //
311 // read data from the input file.
312 //
313 if (InputFileLength != 0) {
314 if (fread (Buffer + sizeof (EFI_COMMON_SECTION_HEADER), (size_t) InputFileLength, 1, InFile) != 1) {
315 Error (NULL, 0, 0004, "Error reading file", InputFileName[0]);
316 goto Done;
317 }
318 }
319
320 //
321 // Set OutFileBuffer
322 //
323 *OutFileBuffer = Buffer;
324 Status = STATUS_SUCCESS;
325
326 Done:
327 fclose (InFile);
328
329 return Status;
330 }
331
332 EFI_STATUS
333 GetSectionContents (
334 CHAR8 **InputFileName,
335 UINT32 InputFileNum,
336 UINT8 *FileBuffer,
337 UINT32 *BufferLength
338 )
339 /*++
340
341 Routine Description:
342
343 Get the contents of all section files specified in InputFileName
344 into FileBuffer.
345
346 Arguments:
347
348 InputFileName - Name of the input file.
349
350 InputFileNum - Number of input files. Should be at least 1.
351
352 FileBuffer - Output buffer to contain data
353
354 BufferLength - On input, this is size of the FileBuffer.
355 On output, this is the actual length of the data.
356
357 Returns:
358
359 EFI_SUCCESS on successful return
360 EFI_INVALID_PARAMETER if InputFileNum is less than 1 or BufferLength point is NULL.
361 EFI_ABORTED if unable to open input file.
362 EFI_BUFFER_TOO_SMALL FileBuffer is not enough to contain all file data.
363 --*/
364 {
365 UINT32 Size;
366 UINT32 FileSize;
367 UINT32 Index;
368 FILE *InFile;
369
370 if (InputFileNum < 1) {
371 Error (NULL, 0, 2000, "Invalid paramter", "must specify at least one input file");
372 return EFI_INVALID_PARAMETER;
373 }
374
375 if (BufferLength == NULL) {
376 Error (NULL, 0, 2000, "Invalid paramter", "BufferLength can't be NULL");
377 return EFI_INVALID_PARAMETER;
378 }
379
380 Size = 0;
381 //
382 // Go through our array of file names and copy their contents
383 // to the output buffer.
384 //
385 for (Index = 0; Index < InputFileNum; Index++) {
386 //
387 // make sure section ends on a DWORD boundary
388 //
389 while ((Size & 0x03) != 0) {
390 if (FileBuffer != NULL && Size < *BufferLength) {
391 FileBuffer[Size] = 0;
392 }
393 Size++;
394 }
395
396 //
397 // Open file and read contents
398 //
399 InFile = fopen (InputFileName[Index], "rb");
400 if (InFile == NULL) {
401 Error (NULL, 0, 0001, "Error opening file", InputFileName[Index]);
402 return EFI_ABORTED;
403 }
404
405 fseek (InFile, 0, SEEK_END);
406 FileSize = ftell (InFile);
407 fseek (InFile, 0, SEEK_SET);
408 DebugMsg (NULL, 0, 9, "Input files", "the input file name is %s and the size is %u bytes", InputFileName[Index], (unsigned) FileSize);
409 //
410 // Now read the contents of the file into the buffer
411 // Buffer must be enough to contain the file content.
412 //
413 if (FileSize > 0 && FileBuffer != NULL && (Size + FileSize) <= *BufferLength) {
414 if (fread (FileBuffer + Size, (size_t) FileSize, 1, InFile) != 1) {
415 Error (NULL, 0, 0004, "Error reading file", InputFileName[Index]);
416 fclose (InFile);
417 return EFI_ABORTED;
418 }
419 }
420
421 fclose (InFile);
422 Size += FileSize;
423 }
424
425 //
426 // Set the real required buffer size.
427 //
428 if (Size > *BufferLength) {
429 *BufferLength = Size;
430 return EFI_BUFFER_TOO_SMALL;
431 } else {
432 *BufferLength = Size;
433 return EFI_SUCCESS;
434 }
435 }
436
437 EFI_STATUS
438 GenSectionCompressionSection (
439 CHAR8 **InputFileName,
440 UINT32 InputFileNum,
441 UINT8 SectCompSubType,
442 UINT8 **OutFileBuffer
443 )
444 /*++
445
446 Routine Description:
447
448 Generate an encapsulating section of type EFI_SECTION_COMPRESSION
449 Input file must be already sectioned. The function won't validate
450 the input files' contents. Caller should hand in files already
451 with section header.
452
453 Arguments:
454
455 InputFileName - Name of the input file.
456
457 InputFileNum - Number of input files. Should be at least 1.
458
459 SectCompSubType - Specify the compression algorithm requested.
460
461 OutFileBuffer - Buffer pointer to Output file contents
462
463 Returns:
464
465 EFI_SUCCESS on successful return
466 EFI_INVALID_PARAMETER if InputFileNum is less than 1
467 EFI_ABORTED if unable to open input file.
468 EFI_OUT_OF_RESOURCES No resource to complete the operation.
469 --*/
470 {
471 UINT32 TotalLength;
472 UINT32 InputLength;
473 UINT32 CompressedLength;
474 UINT8 *FileBuffer;
475 UINT8 *OutputBuffer;
476 EFI_STATUS Status;
477 EFI_COMPRESSION_SECTION *CompressionSect;
478 COMPRESS_FUNCTION CompressFunction;
479
480 InputLength = 0;
481 FileBuffer = NULL;
482 OutputBuffer = NULL;
483 CompressedLength = 0;
484 //
485 // read all input file contents into a buffer
486 // first get the size of all file contents
487 //
488 Status = GetSectionContents (
489 InputFileName,
490 InputFileNum,
491 FileBuffer,
492 &InputLength
493 );
494
495 if (Status == EFI_BUFFER_TOO_SMALL) {
496 FileBuffer = (UINT8 *) malloc (InputLength);
497 if (FileBuffer == NULL) {
498 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
499 return EFI_OUT_OF_RESOURCES;
500 }
501 //
502 // read all input file contents into a buffer
503 //
504 Status = GetSectionContents (
505 InputFileName,
506 InputFileNum,
507 FileBuffer,
508 &InputLength
509 );
510 }
511
512 if (EFI_ERROR (Status)) {
513 if (FileBuffer != NULL) {
514 free (FileBuffer);
515 }
516 return Status;
517 }
518
519 CompressFunction = NULL;
520
521 //
522 // Now data is in FileBuffer, compress the data
523 //
524 switch (SectCompSubType) {
525 case EFI_NOT_COMPRESSED:
526 CompressedLength = InputLength;
527 break;
528
529 case EFI_STANDARD_COMPRESSION:
530 CompressFunction = (COMPRESS_FUNCTION) EfiCompress;
531 break;
532
533 default:
534 Error (NULL, 0, 2000, "Invalid paramter", "unknown compression type");
535 free (FileBuffer);
536 return EFI_ABORTED;
537 }
538
539 if (CompressFunction != NULL) {
540
541 Status = CompressFunction (FileBuffer, InputLength, OutputBuffer, &CompressedLength);
542 if (Status == EFI_BUFFER_TOO_SMALL) {
543 OutputBuffer = malloc (CompressedLength + sizeof (EFI_COMPRESSION_SECTION));
544 if (!OutputBuffer) {
545 free (FileBuffer);
546 return EFI_OUT_OF_RESOURCES;
547 }
548
549 Status = CompressFunction (FileBuffer, InputLength, OutputBuffer + sizeof (EFI_COMPRESSION_SECTION), &CompressedLength);
550 }
551
552 free (FileBuffer);
553 FileBuffer = OutputBuffer;
554
555 if (EFI_ERROR (Status)) {
556 if (FileBuffer != NULL) {
557 free (FileBuffer);
558 }
559
560 return Status;
561 }
562 }
563
564 DebugMsg (NULL, 0, 9, "comprss file size",
565 "the original section size is %d bytes and the compressed section size is %u bytes", (unsigned) InputLength, (unsigned) CompressedLength);
566 TotalLength = CompressedLength + sizeof (EFI_COMPRESSION_SECTION);
567 if (TotalLength >= MAX_SECTION_SIZE) {
568 Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
569 if (FileBuffer != NULL) {
570 free (FileBuffer);
571 }
572 if (OutputBuffer != NULL) {
573 free (OutputBuffer);
574 }
575 return STATUS_ERROR;
576 }
577 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
578
579 //
580 // Add the section header for the compressed data
581 //
582 CompressionSect = (EFI_COMPRESSION_SECTION *) FileBuffer;
583
584 CompressionSect->CommonHeader.Type = EFI_SECTION_COMPRESSION;
585 CompressionSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
586 CompressionSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
587 CompressionSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
588 CompressionSect->CompressionType = SectCompSubType;
589 CompressionSect->UncompressedLength = InputLength;
590
591 //
592 // Set OutFileBuffer
593 //
594 *OutFileBuffer = FileBuffer;
595
596 return EFI_SUCCESS;
597 }
598
599 EFI_STATUS
600 GenSectionGuidDefinedSection (
601 CHAR8 **InputFileName,
602 UINT32 InputFileNum,
603 EFI_GUID *VendorGuid,
604 UINT16 DataAttribute,
605 UINT32 DataHeaderSize,
606 UINT8 **OutFileBuffer
607 )
608 /*++
609
610 Routine Description:
611
612 Generate an encapsulating section of type EFI_SECTION_GUID_DEFINED
613 Input file must be already sectioned. The function won't validate
614 the input files' contents. Caller should hand in files already
615 with section header.
616
617 Arguments:
618
619 InputFileName - Name of the input file.
620
621 InputFileNum - Number of input files. Should be at least 1.
622
623 VendorGuid - Specify vendor guid value.
624
625 DataAttribute - Specify attribute for the vendor guid data.
626
627 DataHeaderSize- Guided Data Header Size
628
629 OutFileBuffer - Buffer pointer to Output file contents
630
631 Returns:
632
633 EFI_SUCCESS on successful return
634 EFI_INVALID_PARAMETER if InputFileNum is less than 1
635 EFI_ABORTED if unable to open input file.
636 EFI_OUT_OF_RESOURCES No resource to complete the operation.
637
638 --*/
639 {
640 UINT32 TotalLength;
641 UINT32 InputLength;
642 UINT32 Offset;
643 UINT8 *FileBuffer;
644 UINT32 Crc32Checksum;
645 EFI_STATUS Status;
646 CRC32_SECTION_HEADER *Crc32GuidSect;
647 EFI_GUID_DEFINED_SECTION *VendorGuidSect;
648
649 InputLength = 0;
650 Offset = 0;
651 FileBuffer = NULL;
652
653 if (CompareGuid (VendorGuid, &mEfiCrc32SectionGuid) == 0) {
654 Offset = sizeof (CRC32_SECTION_HEADER);
655 } else {
656 Offset = sizeof (EFI_GUID_DEFINED_SECTION);
657 }
658
659 //
660 // read all input file contents into a buffer
661 // first get the size of all file contents
662 //
663 Status = GetSectionContents (
664 InputFileName,
665 InputFileNum,
666 FileBuffer,
667 &InputLength
668 );
669
670 if (Status == EFI_BUFFER_TOO_SMALL) {
671 FileBuffer = (UINT8 *) malloc (InputLength + Offset);
672 if (FileBuffer == NULL) {
673 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
674 return EFI_OUT_OF_RESOURCES;
675 }
676 //
677 // read all input file contents into a buffer
678 //
679 Status = GetSectionContents (
680 InputFileName,
681 InputFileNum,
682 FileBuffer + Offset,
683 &InputLength
684 );
685 }
686
687 if (EFI_ERROR (Status)) {
688 if (FileBuffer != NULL) {
689 free (FileBuffer);
690 }
691 Error (NULL, 0, 0001, "Error opening file for reading", InputFileName[0]);
692 return Status;
693 }
694
695 if (InputLength == 0) {
696 Error (NULL, 0, 2000, "Invalid parameter", "the size of input file %s can't be zero", InputFileName);
697 return EFI_NOT_FOUND;
698 }
699
700 //
701 // Now data is in FileBuffer + Offset
702 //
703 if (CompareGuid (VendorGuid, &mEfiCrc32SectionGuid) == 0) {
704 //
705 // Default Guid section is CRC32.
706 //
707 Crc32Checksum = 0;
708 CalculateCrc32 (FileBuffer + Offset, InputLength, &Crc32Checksum);
709
710 TotalLength = InputLength + sizeof (CRC32_SECTION_HEADER);
711 if (TotalLength >= MAX_SECTION_SIZE) {
712 Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
713 free (FileBuffer);
714 return STATUS_ERROR;
715 }
716
717 Crc32GuidSect = (CRC32_SECTION_HEADER *) FileBuffer;
718 Crc32GuidSect->GuidSectionHeader.CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
719 Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
720 Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
721 Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
722 memcpy (&(Crc32GuidSect->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));
723 Crc32GuidSect->GuidSectionHeader.Attributes = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;
724 Crc32GuidSect->GuidSectionHeader.DataOffset = sizeof (CRC32_SECTION_HEADER);
725 Crc32GuidSect->CRC32Checksum = Crc32Checksum;
726 DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect->GuidSectionHeader.DataOffset);
727
728 } else {
729 TotalLength = InputLength + sizeof (EFI_GUID_DEFINED_SECTION);
730 if (TotalLength >= MAX_SECTION_SIZE) {
731 Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
732 free (FileBuffer);
733 return STATUS_ERROR;
734 }
735
736 VendorGuidSect = (EFI_GUID_DEFINED_SECTION *) FileBuffer;
737 VendorGuidSect->CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
738 VendorGuidSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
739 VendorGuidSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
740 VendorGuidSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
741 memcpy (&(VendorGuidSect->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));
742 VendorGuidSect->Attributes = DataAttribute;
743 VendorGuidSect->DataOffset = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION) + DataHeaderSize);
744 DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect->DataOffset);
745 }
746 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
747
748 //
749 // Set OutFileBuffer
750 //
751 *OutFileBuffer = FileBuffer;
752
753 return EFI_SUCCESS;
754 }
755
756 int
757 main (
758 int argc,
759 char *argv[]
760 )
761 /*++
762
763 Routine Description:
764
765 Main
766
767 Arguments:
768
769 command line parameters
770
771 Returns:
772
773 EFI_SUCCESS Section header successfully generated and section concatenated.
774 EFI_ABORTED Could not generate the section
775 EFI_OUT_OF_RESOURCES No resource to complete the operation.
776
777 --*/
778 {
779 UINT32 Index;
780 UINT32 InputFileNum;
781 FILE *InFile;
782 FILE *OutFile;
783 CHAR8 **InputFileName;
784 CHAR8 *OutputFileName;
785 CHAR8 *SectionName;
786 CHAR8 *CompressionName;
787 CHAR8 *StringBuffer;
788 EFI_GUID VendorGuid = mZeroGuid;
789 int VersionNumber;
790 UINT8 SectType;
791 UINT8 SectCompSubType;
792 UINT16 SectGuidAttribute;
793 UINT64 SectGuidHeaderLength;
794 EFI_VERSION_SECTION *VersionSect;
795 EFI_USER_INTERFACE_SECTION *UiSect;
796 UINT32 InputLength;
797 UINT8 *OutFileBuffer;
798 EFI_STATUS Status;
799 UINT64 LogLevel;
800
801 InputFileName = NULL;
802 OutputFileName = NULL;
803 SectionName = NULL;
804 CompressionName = NULL;
805 StringBuffer = "";
806 InFile = NULL;
807 OutFile = NULL;
808 VersionNumber = 0;
809 InputFileNum = 0;
810 SectType = EFI_SECTION_ALL;
811 SectCompSubType = 0;
812 SectGuidAttribute = 0;
813 OutFileBuffer = NULL;
814 InputLength = 0;
815 Status = STATUS_SUCCESS;
816 LogLevel = 0;
817 SectGuidHeaderLength = 0;
818 VersionSect = NULL;
819 UiSect = NULL;
820
821 SetUtilityName (UTILITY_NAME);
822
823 if (argc == 1) {
824 Error (NULL, 0, 1001, "Missing options", "No options input");
825 Usage ();
826 return STATUS_ERROR;
827 }
828
829 //
830 // Parse command line
831 //
832 argc --;
833 argv ++;
834
835 if ((stricmp (argv[0], "-h") == 0) || (stricmp (argv[0], "--help") == 0)) {
836 Version ();
837 Usage ();
838 return STATUS_SUCCESS;
839 }
840
841 if (stricmp (argv[0], "--version") == 0) {
842 Version ();
843 return STATUS_SUCCESS;
844 }
845
846 while (argc > 0) {
847 if ((stricmp (argv[0], "-s") == 0) || (stricmp (argv[0], "--SectionType") == 0)) {
848 SectionName = argv[1];
849 if (SectionName == NULL) {
850 Error (NULL, 0, 1003, "Invalid option value", "Section Type can't be NULL");
851 goto Finish;
852 }
853 argc -= 2;
854 argv += 2;
855 continue;
856 }
857
858 if ((stricmp (argv[0], "-o") == 0) || (stricmp (argv[0], "--outputfile") == 0)) {
859 OutputFileName = argv[1];
860 if (OutputFileName == NULL) {
861 Error (NULL, 0, 1003, "Invalid option value", "Output file can't be NULL");
862 goto Finish;
863 }
864 argc -= 2;
865 argv += 2;
866 continue;
867 }
868
869 if ((stricmp (argv[0], "-c") == 0) || (stricmp (argv[0], "--compress") == 0)) {
870 CompressionName = argv[1];
871 if (CompressionName == NULL) {
872 Error (NULL, 0, 1003, "Invalid option value", "Compression Type can't be NULL");
873 goto Finish;
874 }
875 argc -= 2;
876 argv += 2;
877 continue;
878 }
879
880 if ((stricmp (argv[0], "-g") == 0) || (stricmp (argv[0], "--vendor") == 0)) {
881 Status = StringToGuid (argv[1], &VendorGuid);
882 if (EFI_ERROR (Status)) {
883 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
884 goto Finish;
885 }
886 argc -= 2;
887 argv += 2;
888 continue;
889 }
890
891 if ((stricmp (argv[0], "-r") == 0) || (stricmp (argv[0], "--attributes") == 0)) {
892 if (stricmp (argv[1], mGUIDedSectionAttribue[EFI_GUIDED_SECTION_PROCESSING_REQUIRED]) == 0) {
893 SectGuidAttribute |= EFI_GUIDED_SECTION_PROCESSING_REQUIRED;
894 } else if (stricmp (argv[1], mGUIDedSectionAttribue[EFI_GUIDED_SECTION_AUTH_STATUS_VALID]) == 0) {
895 SectGuidAttribute |= EFI_GUIDED_SECTION_AUTH_STATUS_VALID;
896 } else if (stricmp (argv[1], mGUIDedSectionAttribue[0]) == 0) {
897 //
898 // NONE attribute
899 //
900 SectGuidAttribute |= EFI_GUIDED_SECTION_NONE;
901 } else {
902 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
903 goto Finish;
904 }
905 argc -= 2;
906 argv += 2;
907 continue;
908 }
909
910 if ((stricmp (argv[0], "-l") == 0) || (stricmp (argv[0], "--HeaderLength") == 0)) {
911 Status = AsciiStringToUint64 (argv[1], FALSE, &SectGuidHeaderLength);
912 if (EFI_ERROR (Status)) {
913 Error (NULL, 0, 1003, "Invalid option value for GuidHeaderLength", "%s = %s", argv[0], argv[1]);
914 goto Finish;
915 }
916 argc -= 2;
917 argv += 2;
918 continue;
919 }
920
921 if ((stricmp (argv[0], "-n") == 0) || (stricmp (argv[0], "--name") == 0)) {
922 StringBuffer = argv[1];
923 if (StringBuffer == NULL) {
924 Error (NULL, 0, 1003, "Invalid option value", "Name can't be NULL");
925 goto Finish;
926 }
927 argc -= 2;
928 argv += 2;
929 continue;
930 }
931
932 if ((stricmp (argv[0], "-j") == 0) || (stricmp (argv[0], "--buildnumber") == 0)) {
933 if (argv[1] == NULL) {
934 Error (NULL, 0, 1003, "Invalid option value", "build number can't be NULL");
935 goto Finish;
936 }
937 //
938 // Verify string is a integrator number
939 //
940 for (Index = 0; Index < strlen (argv[1]); Index++) {
941 if ((argv[1][Index] != '-') && (isdigit (argv[1][Index]) == 0)) {
942 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
943 goto Finish;
944 }
945 }
946
947 sscanf (argv[1], "%d", &VersionNumber);
948 argc -= 2;
949 argv += 2;
950 continue;
951 }
952
953 if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {
954 SetPrintLevel (VERBOSE_LOG_LEVEL);
955 VerboseMsg ("Verbose output Mode Set!");
956 argc --;
957 argv ++;
958 continue;
959 }
960
961 if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {
962 SetPrintLevel (KEY_LOG_LEVEL);
963 KeyMsg ("Quiet output Mode Set!");
964 argc --;
965 argv ++;
966 continue;
967 }
968
969 if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {
970 Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);
971 if (EFI_ERROR (Status)) {
972 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
973 goto Finish;
974 }
975 if (LogLevel > 9) {
976 Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0~9, currnt input level is %d", (int) LogLevel);
977 goto Finish;
978 }
979 SetPrintLevel (LogLevel);
980 DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);
981 argc -= 2;
982 argv += 2;
983 continue;
984 }
985
986 //
987 // Get Input file name
988 //
989 if ((InputFileNum == 0) && (InputFileName == NULL)) {
990 InputFileName = (CHAR8 **) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *));
991 if (InputFileName == NULL) {
992 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
993 return 1;
994 }
995
996 memset (InputFileName, 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));
997 } else if (InputFileNum % MAXIMUM_INPUT_FILE_NUM == 0) {
998 //
999 // InputFileName buffer too small, need to realloc
1000 //
1001 InputFileName = (CHAR8 **) realloc (
1002 InputFileName,
1003 (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (CHAR8 *)
1004 );
1005
1006 if (InputFileName == NULL) {
1007 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
1008 return 1;
1009 }
1010
1011 memset (&(InputFileName[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));
1012 }
1013
1014 InputFileName[InputFileNum++] = argv[0];
1015 argc --;
1016 argv ++;
1017 }
1018
1019 VerboseMsg ("%s tool start.", UTILITY_NAME);
1020
1021 //
1022 // Parse all command line parameters to get the corresponding section type.
1023 //
1024 VerboseMsg ("Section type is %s", SectionName);
1025 if (SectionName == NULL) {
1026 //
1027 // No specified Section type, default is SECTION_ALL.
1028 //
1029 SectType = EFI_SECTION_ALL;
1030 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_COMPRESSION]) == 0) {
1031 SectType = EFI_SECTION_COMPRESSION;
1032 if (CompressionName == NULL) {
1033 //
1034 // Default is PI_STD compression algorithm.
1035 //
1036 SectCompSubType = EFI_STANDARD_COMPRESSION;
1037 } else if (stricmp (CompressionName, mCompressionTypeName[EFI_NOT_COMPRESSED]) == 0) {
1038 SectCompSubType = EFI_NOT_COMPRESSED;
1039 } else if (stricmp (CompressionName, mCompressionTypeName[EFI_STANDARD_COMPRESSION]) == 0) {
1040 SectCompSubType = EFI_STANDARD_COMPRESSION;
1041 } else {
1042 Error (NULL, 0, 1003, "Invalid option value", "--compress = %s", CompressionName);
1043 goto Finish;
1044 }
1045 VerboseMsg ("Compress method is %s", mCompressionTypeName [SectCompSubType]);
1046 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_GUID_DEFINED]) == 0) {
1047 SectType = EFI_SECTION_GUID_DEFINED;
1048
1049 if (CompareGuid (&VendorGuid, &mZeroGuid) == 0) {
1050 memcpy (&VendorGuid, &mEfiCrc32SectionGuid, sizeof (EFI_GUID));
1051 }
1052
1053 if (SectGuidAttribute == 0) {
1054 SectGuidAttribute = EFI_GUIDED_SECTION_PROCESSING_REQUIRED;
1055 }
1056 if ((SectGuidAttribute & EFI_GUIDED_SECTION_NONE) != 0) {
1057 //
1058 // NONE attribute, clear attribute value.
1059 //
1060 SectGuidAttribute = 0;
1061 }
1062 VerboseMsg ("Vendor Guid is %08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
1063 (unsigned) VendorGuid.Data1,
1064 VendorGuid.Data2,
1065 VendorGuid.Data3,
1066 VendorGuid.Data4[0],
1067 VendorGuid.Data4[1],
1068 VendorGuid.Data4[2],
1069 VendorGuid.Data4[3],
1070 VendorGuid.Data4[4],
1071 VendorGuid.Data4[5],
1072 VendorGuid.Data4[6],
1073 VendorGuid.Data4[7]);
1074 if ((SectGuidAttribute & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) != 0) {
1075 VerboseMsg ("Guid Attribute is %s", mGUIDedSectionAttribue[EFI_GUIDED_SECTION_PROCESSING_REQUIRED]);
1076 }
1077 if ((SectGuidAttribute & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) != 0) {
1078 VerboseMsg ("Guid Attribute is %s", mGUIDedSectionAttribue[EFI_GUIDED_SECTION_AUTH_STATUS_VALID]);
1079 }
1080 if (SectGuidHeaderLength != 0) {
1081 VerboseMsg ("Guid Data Header size is 0x%llx", (unsigned long long) SectGuidHeaderLength);
1082 }
1083 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_PE32]) == 0) {
1084 SectType = EFI_SECTION_PE32;
1085 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_PIC]) == 0) {
1086 SectType = EFI_SECTION_PIC;
1087 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_TE]) == 0) {
1088 SectType = EFI_SECTION_TE;
1089 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_DXE_DEPEX]) == 0) {
1090 SectType = EFI_SECTION_DXE_DEPEX;
1091 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_SMM_DEPEX]) == 0) {
1092 SectType = EFI_SECTION_SMM_DEPEX;
1093 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_VERSION]) == 0) {
1094 SectType = EFI_SECTION_VERSION;
1095 if (VersionNumber < 0 || VersionNumber > 9999) {
1096 Error (NULL, 0, 1003, "Invalid option value", "%d is not in 0~9999", VersionNumber);
1097 goto Finish;
1098 }
1099 VerboseMsg ("Version section number is %d", VersionNumber);
1100 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_USER_INTERFACE]) == 0) {
1101 SectType = EFI_SECTION_USER_INTERFACE;
1102 if (StringBuffer[0] == '\0') {
1103 Error (NULL, 0, 1001, "Missing option", "user interface string");
1104 goto Finish;
1105 }
1106 VerboseMsg ("UI section string name is %s", StringBuffer);
1107 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_COMPATIBILITY16]) == 0) {
1108 SectType = EFI_SECTION_COMPATIBILITY16;
1109 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_FIRMWARE_VOLUME_IMAGE]) == 0) {
1110 SectType = EFI_SECTION_FIRMWARE_VOLUME_IMAGE;
1111 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_FREEFORM_SUBTYPE_GUID]) == 0) {
1112 SectType = EFI_SECTION_FREEFORM_SUBTYPE_GUID;
1113 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_RAW]) == 0) {
1114 SectType = EFI_SECTION_RAW;
1115 } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_PEI_DEPEX]) == 0) {
1116 SectType = EFI_SECTION_PEI_DEPEX;
1117 } else {
1118 Error (NULL, 0, 1003, "Invalid option value", "SectionType = %s", SectionName);
1119 goto Finish;
1120 }
1121
1122 //
1123 // GuidValue is only required by Guided section.
1124 //
1125 if ((SectType != EFI_SECTION_GUID_DEFINED) && (CompareGuid (&VendorGuid, &mZeroGuid) != 0)) {
1126 fprintf (stdout, "Warning: the input guid value is not required for this section type %s\n", SectionName);
1127 }
1128
1129 //
1130 // Check whether there is input file
1131 //
1132 if ((SectType != EFI_SECTION_VERSION) && (SectType != EFI_SECTION_USER_INTERFACE)) {
1133 //
1134 // The input file are required for other section type.
1135 //
1136 if (InputFileNum == 0) {
1137 Error (NULL, 0, 1001, "Missing options", "Input files");
1138 goto Finish;
1139 }
1140 }
1141 //
1142 // Check whether there is output file
1143 //
1144 for (Index = 0; Index < InputFileNum; Index ++) {
1145 VerboseMsg ("the %uth input file name is %s", (unsigned) Index, InputFileName[Index]);
1146 }
1147 if (OutputFileName == NULL) {
1148 Error (NULL, 0, 1001, "Missing options", "Output file");
1149 goto Finish;
1150 // OutFile = stdout;
1151 }
1152 VerboseMsg ("Output file name is %s", OutputFileName);
1153
1154 //
1155 // At this point, we've fully validated the command line, and opened appropriate
1156 // files, so let's go and do what we've been asked to do...
1157 //
1158 //
1159 // Within this switch, build and write out the section header including any
1160 // section type specific pieces. If there's an input file, it's tacked on later
1161 //
1162 switch (SectType) {
1163 case EFI_SECTION_COMPRESSION:
1164 Status = GenSectionCompressionSection (
1165 InputFileName,
1166 InputFileNum,
1167 SectCompSubType,
1168 &OutFileBuffer
1169 );
1170 break;
1171
1172 case EFI_SECTION_GUID_DEFINED:
1173 Status = GenSectionGuidDefinedSection (
1174 InputFileName,
1175 InputFileNum,
1176 &VendorGuid,
1177 SectGuidAttribute,
1178 (UINT32) SectGuidHeaderLength,
1179 &OutFileBuffer
1180 );
1181 break;
1182
1183 case EFI_SECTION_VERSION:
1184 Index = sizeof (EFI_COMMON_SECTION_HEADER);
1185 //
1186 // 2 bytes for the build number UINT16
1187 //
1188 Index += 2;
1189 //
1190 // StringBuffer is ascii.. unicode is 2X + 2 bytes for terminating unicode null.
1191 //
1192 Index += (strlen (StringBuffer) * 2) + 2;
1193 OutFileBuffer = (UINT8 *) malloc (Index);
1194 if (OutFileBuffer == NULL) {
1195 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
1196 goto Finish;
1197 }
1198 VersionSect = (EFI_VERSION_SECTION *) OutFileBuffer;
1199 VersionSect->CommonHeader.Type = SectType;
1200 VersionSect->CommonHeader.Size[0] = (UINT8) (Index & 0xff);
1201 VersionSect->CommonHeader.Size[1] = (UINT8) ((Index & 0xff00) >> 8);
1202 VersionSect->CommonHeader.Size[2] = (UINT8) ((Index & 0xff0000) >> 16);
1203 VersionSect->BuildNumber = (UINT16) VersionNumber;
1204 Ascii2UnicodeString (StringBuffer, VersionSect->VersionString);
1205 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) Index);
1206 break;
1207
1208 case EFI_SECTION_USER_INTERFACE:
1209 Index = sizeof (EFI_COMMON_SECTION_HEADER);
1210 //
1211 // StringBuffer is ascii.. unicode is 2X + 2 bytes for terminating unicode null.
1212 //
1213 Index += (strlen (StringBuffer) * 2) + 2;
1214 OutFileBuffer = (UINT8 *) malloc (Index);
1215 if (OutFileBuffer == NULL) {
1216 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
1217 goto Finish;
1218 }
1219 UiSect = (EFI_USER_INTERFACE_SECTION *) OutFileBuffer;
1220 UiSect->CommonHeader.Type = SectType;
1221 UiSect->CommonHeader.Size[0] = (UINT8) (Index & 0xff);
1222 UiSect->CommonHeader.Size[1] = (UINT8) ((Index & 0xff00) >> 8);
1223 UiSect->CommonHeader.Size[2] = (UINT8) ((Index & 0xff0000) >> 16);
1224 Ascii2UnicodeString (StringBuffer, UiSect->FileNameString);
1225 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) Index);
1226 break;
1227
1228 case EFI_SECTION_ALL:
1229 //
1230 // read all input file contents into a buffer
1231 // first get the size of all file contents
1232 //
1233 Status = GetSectionContents (
1234 InputFileName,
1235 InputFileNum,
1236 OutFileBuffer,
1237 &InputLength
1238 );
1239
1240 if (Status == EFI_BUFFER_TOO_SMALL) {
1241 OutFileBuffer = (UINT8 *) malloc (InputLength);
1242 if (OutFileBuffer == NULL) {
1243 Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
1244 goto Finish;
1245 }
1246 //
1247 // read all input file contents into a buffer
1248 //
1249 Status = GetSectionContents (
1250 InputFileName,
1251 InputFileNum,
1252 OutFileBuffer,
1253 &InputLength
1254 );
1255 }
1256 VerboseMsg ("the size of the created section file is %u bytes", (unsigned) InputLength);
1257 break;
1258 default:
1259 //
1260 // All other section types are caught by default (they're all the same)
1261 //
1262 Status = GenSectionCommonLeafSection (
1263 InputFileName,
1264 InputFileNum,
1265 SectType,
1266 &OutFileBuffer
1267 );
1268 break;
1269 }
1270
1271 if (Status != EFI_SUCCESS || OutFileBuffer == NULL) {
1272 Error (NULL, 0, 2000, "Status is not successful", "Status value is 0x%X", (int) Status);
1273 goto Finish;
1274 }
1275
1276 //
1277 // Get output file length
1278 //
1279 if (SectType != EFI_SECTION_ALL) {
1280 InputLength = SECTION_SIZE (OutFileBuffer);
1281 }
1282
1283 //
1284 // Write the output file
1285 //
1286 OutFile = fopen (OutputFileName, "wb");
1287 if (OutFile == NULL) {
1288 Error (NULL, 0, 0001, "Error opening file for writing", OutputFileName);
1289 goto Finish;
1290 }
1291
1292 fwrite (OutFileBuffer, InputLength, 1, OutFile);
1293
1294 Finish:
1295 if (InputFileName != NULL) {
1296 free (InputFileName);
1297 }
1298
1299 if (OutFileBuffer != NULL) {
1300 free (OutFileBuffer);
1301 }
1302
1303 if (OutFile != NULL) {
1304 fclose (OutFile);
1305 }
1306
1307 VerboseMsg ("%s tool done with return code is 0x%x.", UTILITY_NAME, GetUtilityStatus ());
1308
1309 return GetUtilityStatus ();
1310 }
EFI Development Kit II mirror for PVE