]> git.proxmox.com Git - mirror_edk2.git/blob - MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdePkg: Add more checker in UefiDecompressLib to access the valid buffer only (CVE...
[mirror_edk2.git] / MdePkg / Library / BaseUefiDecompressLib / BaseUefiDecompressLib.c
1 /** @file
2 UEFI Decompress Library implementation refer to UEFI specification.
3
4 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5 Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16
17 #include <Base.h>
18 #include <Library/BaseLib.h>
19 #include <Library/DebugLib.h>
20 #include <Library/BaseMemoryLib.h>
21 #include <Library/UefiDecompressLib.h>
22
23 #include "BaseUefiDecompressLibInternals.h"
24
25 /**
26 Read NumOfBit of bits from source into mBitBuf.
27
28 Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.
29
30 @param Sd The global scratch data.
31 @param NumOfBits The number of bits to shift and read.
32
33 **/
34 VOID
35 FillBuf (
36 IN SCRATCH_DATA *Sd,
37 IN UINT16 NumOfBits
38 )
39 {
40 //
41 // Left shift NumOfBits of bits in advance
42 //
43 Sd->mBitBuf = (UINT32) LShiftU64 (((UINT64)Sd->mBitBuf), NumOfBits);
44
45 //
46 // Copy data needed in bytes into mSbuBitBuf
47 //
48 while (NumOfBits > Sd->mBitCount) {
49 NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount);
50 Sd->mBitBuf |= (UINT32) LShiftU64 (((UINT64)Sd->mSubBitBuf), NumOfBits);
51
52 if (Sd->mCompSize > 0) {
53 //
54 // Get 1 byte into SubBitBuf
55 //
56 Sd->mCompSize--;
57 Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++];
58 Sd->mBitCount = 8;
59
60 } else {
61 //
62 // No more bits from the source, just pad zero bit.
63 //
64 Sd->mSubBitBuf = 0;
65 Sd->mBitCount = 8;
66
67 }
68 }
69
70 //
71 // Calculate additional bit count read to update mBitCount
72 //
73 Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits);
74
75 //
76 // Copy NumOfBits of bits from mSubBitBuf into mBitBuf
77 //
78 Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount;
79 }
80
81 /**
82 Get NumOfBits of bits out from mBitBuf.
83
84 Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent
85 NumOfBits of bits from source. Returns NumOfBits of bits that are
86 popped out.
87
88 @param Sd The global scratch data.
89 @param NumOfBits The number of bits to pop and read.
90
91 @return The bits that are popped out.
92
93 **/
94 UINT32
95 GetBits (
96 IN SCRATCH_DATA *Sd,
97 IN UINT16 NumOfBits
98 )
99 {
100 UINT32 OutBits;
101
102 //
103 // Pop NumOfBits of Bits from Left
104 //
105 OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits));
106
107 //
108 // Fill up mBitBuf from source
109 //
110 FillBuf (Sd, NumOfBits);
111
112 return OutBits;
113 }
114
115 /**
116 Creates Huffman Code mapping table according to code length array.
117
118 Creates Huffman Code mapping table for Extra Set, Char&Len Set
119 and Position Set according to code length array.
120 If TableBits > 16, then ASSERT ().
121
122 @param Sd The global scratch data.
123 @param NumOfChar The number of symbols in the symbol set.
124 @param BitLen Code length array.
125 @param TableBits The width of the mapping table.
126 @param Table The table to be created.
127
128 @retval 0 OK.
129 @retval BAD_TABLE The table is corrupted.
130
131 **/
132 UINT16
133 MakeTable (
134 IN SCRATCH_DATA *Sd,
135 IN UINT16 NumOfChar,
136 IN UINT8 *BitLen,
137 IN UINT16 TableBits,
138 OUT UINT16 *Table
139 )
140 {
141 UINT16 Count[17];
142 UINT16 Weight[17];
143 UINT16 Start[18];
144 UINT16 *Pointer;
145 UINT16 Index3;
146 UINT16 Index;
147 UINT16 Len;
148 UINT16 Char;
149 UINT16 JuBits;
150 UINT16 Avail;
151 UINT16 NextCode;
152 UINT16 Mask;
153 UINT16 WordOfStart;
154 UINT16 WordOfCount;
155 UINT16 MaxTableLength;
156
157 //
158 // The maximum mapping table width supported by this internal
159 // working function is 16.
160 //
161 ASSERT (TableBits <= 16);
162
163 for (Index = 0; Index <= 16; Index++) {
164 Count[Index] = 0;
165 }
166
167 for (Index = 0; Index < NumOfChar; Index++) {
168 if (BitLen[Index] > 16) {
169 return (UINT16) BAD_TABLE;
170 }
171 Count[BitLen[Index]]++;
172 }
173
174 Start[0] = 0;
175 Start[1] = 0;
176
177 for (Index = 1; Index <= 16; Index++) {
178 WordOfStart = Start[Index];
179 WordOfCount = Count[Index];
180 Start[Index + 1] = (UINT16) (WordOfStart + (WordOfCount << (16 - Index)));
181 }
182
183 if (Start[17] != 0) {
184 /*(1U << 16)*/
185 return (UINT16) BAD_TABLE;
186 }
187
188 JuBits = (UINT16) (16 - TableBits);
189
190 Weight[0] = 0;
191 for (Index = 1; Index <= TableBits; Index++) {
192 Start[Index] >>= JuBits;
193 Weight[Index] = (UINT16) (1U << (TableBits - Index));
194 }
195
196 while (Index <= 16) {
197 Weight[Index] = (UINT16) (1U << (16 - Index));
198 Index++;
199 }
200
201 Index = (UINT16) (Start[TableBits + 1] >> JuBits);
202
203 if (Index != 0) {
204 Index3 = (UINT16) (1U << TableBits);
205 if (Index < Index3) {
206 SetMem16 (Table + Index, (Index3 - Index) * sizeof (*Table), 0);
207 }
208 }
209
210 Avail = NumOfChar;
211 Mask = (UINT16) (1U << (15 - TableBits));
212 MaxTableLength = (UINT16) (1U << TableBits);
213
214 for (Char = 0; Char < NumOfChar; Char++) {
215
216 Len = BitLen[Char];
217 if (Len == 0 || Len >= 17) {
218 continue;
219 }
220
221 NextCode = (UINT16) (Start[Len] + Weight[Len]);
222
223 if (Len <= TableBits) {
224
225 for (Index = Start[Len]; Index < NextCode; Index++) {
226 if (Index >= MaxTableLength) {
227 return (UINT16) BAD_TABLE;
228 }
229 Table[Index] = Char;
230 }
231
232 } else {
233
234 Index3 = Start[Len];
235 Pointer = &Table[Index3 >> JuBits];
236 Index = (UINT16) (Len - TableBits);
237
238 while (Index != 0) {
239 if (*Pointer == 0 && Avail < (2 * NC - 1)) {
240 Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;
241 *Pointer = Avail++;
242 }
243
244 if (*Pointer < (2 * NC - 1)) {
245 if ((Index3 & Mask) != 0) {
246 Pointer = &Sd->mRight[*Pointer];
247 } else {
248 Pointer = &Sd->mLeft[*Pointer];
249 }
250 }
251
252 Index3 <<= 1;
253 Index--;
254 }
255
256 *Pointer = Char;
257
258 }
259
260 Start[Len] = NextCode;
261 }
262 //
263 // Succeeds
264 //
265 return 0;
266 }
267
268 /**
269 Decodes a position value.
270
271 Get a position value according to Position Huffman Table.
272
273 @param Sd The global scratch data.
274
275 @return The position value decoded.
276
277 **/
278 UINT32
279 DecodeP (
280 IN SCRATCH_DATA *Sd
281 )
282 {
283 UINT16 Val;
284 UINT32 Mask;
285 UINT32 Pos;
286
287 Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
288
289 if (Val >= MAXNP) {
290 Mask = 1U << (BITBUFSIZ - 1 - 8);
291
292 do {
293
294 if ((Sd->mBitBuf & Mask) != 0) {
295 Val = Sd->mRight[Val];
296 } else {
297 Val = Sd->mLeft[Val];
298 }
299
300 Mask >>= 1;
301 } while (Val >= MAXNP);
302 }
303 //
304 // Advance what we have read
305 //
306 FillBuf (Sd, Sd->mPTLen[Val]);
307
308 Pos = Val;
309 if (Val > 1) {
310 Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));
311 }
312
313 return Pos;
314 }
315
316 /**
317 Reads code lengths for the Extra Set or the Position Set.
318
319 Read in the Extra Set or Position Set Length Array, then
320 generate the Huffman code mapping for them.
321
322 @param Sd The global scratch data.
323 @param nn The number of symbols.
324 @param nbit The number of bits needed to represent nn.
325 @param Special The special symbol that needs to be taken care of.
326
327 @retval 0 OK.
328 @retval BAD_TABLE Table is corrupted.
329
330 **/
331 UINT16
332 ReadPTLen (
333 IN SCRATCH_DATA *Sd,
334 IN UINT16 nn,
335 IN UINT16 nbit,
336 IN UINT16 Special
337 )
338 {
339 UINT16 Number;
340 UINT16 CharC;
341 UINT16 Index;
342 UINT32 Mask;
343
344 ASSERT (nn <= NPT);
345 //
346 // Read Extra Set Code Length Array size
347 //
348 Number = (UINT16) GetBits (Sd, nbit);
349
350 if (Number == 0) {
351 //
352 // This represents only Huffman code used
353 //
354 CharC = (UINT16) GetBits (Sd, nbit);
355
356 SetMem16 (&Sd->mPTTable[0] , sizeof (Sd->mPTTable), CharC);
357
358 SetMem (Sd->mPTLen, nn, 0);
359
360 return 0;
361 }
362
363 Index = 0;
364
365 while (Index < Number && Index < NPT) {
366
367 CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));
368
369 //
370 // If a code length is less than 7, then it is encoded as a 3-bit
371 // value. Or it is encoded as a series of "1"s followed by a
372 // terminating "0". The number of "1"s = Code length - 4.
373 //
374 if (CharC == 7) {
375 Mask = 1U << (BITBUFSIZ - 1 - 3);
376 while (Mask & Sd->mBitBuf) {
377 Mask >>= 1;
378 CharC += 1;
379 }
380 }
381
382 FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));
383
384 Sd->mPTLen[Index++] = (UINT8) CharC;
385
386 //
387 // For Code&Len Set,
388 // After the third length of the code length concatenation,
389 // a 2-bit value is used to indicated the number of consecutive
390 // zero lengths after the third length.
391 //
392 if (Index == Special) {
393 CharC = (UINT16) GetBits (Sd, 2);
394 while ((INT16) (--CharC) >= 0 && Index < NPT) {
395 Sd->mPTLen[Index++] = 0;
396 }
397 }
398 }
399
400 while (Index < nn && Index < NPT) {
401 Sd->mPTLen[Index++] = 0;
402 }
403
404 return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);
405 }
406
407 /**
408 Reads code lengths for Char&Len Set.
409
410 Read in and decode the Char&Len Set Code Length Array, then
411 generate the Huffman Code mapping table for the Char&Len Set.
412
413 @param Sd The global scratch data.
414
415 **/
416 VOID
417 ReadCLen (
418 SCRATCH_DATA *Sd
419 )
420 {
421 UINT16 Number;
422 UINT16 CharC;
423 UINT16 Index;
424 UINT32 Mask;
425
426 Number = (UINT16) GetBits (Sd, CBIT);
427
428 if (Number == 0) {
429 //
430 // This represents only Huffman code used
431 //
432 CharC = (UINT16) GetBits (Sd, CBIT);
433
434 SetMem (Sd->mCLen, NC, 0);
435 SetMem16 (&Sd->mCTable[0], sizeof (Sd->mCTable), CharC);
436
437 return ;
438 }
439
440 Index = 0;
441 while (Index < Number && Index < NC) {
442 CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
443 if (CharC >= NT) {
444 Mask = 1U << (BITBUFSIZ - 1 - 8);
445
446 do {
447
448 if (Mask & Sd->mBitBuf) {
449 CharC = Sd->mRight[CharC];
450 } else {
451 CharC = Sd->mLeft[CharC];
452 }
453
454 Mask >>= 1;
455
456 } while (CharC >= NT);
457 }
458 //
459 // Advance what we have read
460 //
461 FillBuf (Sd, Sd->mPTLen[CharC]);
462
463 if (CharC <= 2) {
464
465 if (CharC == 0) {
466 CharC = 1;
467 } else if (CharC == 1) {
468 CharC = (UINT16) (GetBits (Sd, 4) + 3);
469 } else if (CharC == 2) {
470 CharC = (UINT16) (GetBits (Sd, CBIT) + 20);
471 }
472
473 while ((INT16) (--CharC) >= 0 && Index < NC) {
474 Sd->mCLen[Index++] = 0;
475 }
476
477 } else {
478
479 Sd->mCLen[Index++] = (UINT8) (CharC - 2);
480
481 }
482 }
483
484 SetMem (Sd->mCLen + Index, NC - Index, 0);
485
486 MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);
487
488 return ;
489 }
490
491 /**
492 Decode a character/length value.
493
494 Read one value from mBitBuf, Get one code from mBitBuf. If it is at block boundary, generates
495 Huffman code mapping table for Extra Set, Code&Len Set and
496 Position Set.
497
498 @param Sd The global scratch data.
499
500 @return The value decoded.
501
502 **/
503 UINT16
504 DecodeC (
505 SCRATCH_DATA *Sd
506 )
507 {
508 UINT16 Index2;
509 UINT32 Mask;
510
511 if (Sd->mBlockSize == 0) {
512 //
513 // Starting a new block
514 // Read BlockSize from block header
515 //
516 Sd->mBlockSize = (UINT16) GetBits (Sd, 16);
517
518 //
519 // Read in the Extra Set Code Length Array,
520 // Generate the Huffman code mapping table for Extra Set.
521 //
522 Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);
523 if (Sd->mBadTableFlag != 0) {
524 return 0;
525 }
526
527 //
528 // Read in and decode the Char&Len Set Code Length Array,
529 // Generate the Huffman code mapping table for Char&Len Set.
530 //
531 ReadCLen (Sd);
532
533 //
534 // Read in the Position Set Code Length Array,
535 // Generate the Huffman code mapping table for the Position Set.
536 //
537 Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, Sd->mPBit, (UINT16) (-1));
538 if (Sd->mBadTableFlag != 0) {
539 return 0;
540 }
541 }
542
543 //
544 // Get one code according to Code&Set Huffman Table
545 //
546 Sd->mBlockSize--;
547 Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];
548
549 if (Index2 >= NC) {
550 Mask = 1U << (BITBUFSIZ - 1 - 12);
551
552 do {
553 if ((Sd->mBitBuf & Mask) != 0) {
554 Index2 = Sd->mRight[Index2];
555 } else {
556 Index2 = Sd->mLeft[Index2];
557 }
558
559 Mask >>= 1;
560 } while (Index2 >= NC);
561 }
562 //
563 // Advance what we have read
564 //
565 FillBuf (Sd, Sd->mCLen[Index2]);
566
567 return Index2;
568 }
569
570 /**
571 Decode the source data and put the resulting data into the destination buffer.
572
573 @param Sd The global scratch data.
574
575 **/
576 VOID
577 Decode (
578 SCRATCH_DATA *Sd
579 )
580 {
581 UINT16 BytesRemain;
582 UINT32 DataIdx;
583 UINT16 CharC;
584
585 BytesRemain = (UINT16) (-1);
586
587 DataIdx = 0;
588
589 for (;;) {
590 //
591 // Get one code from mBitBuf
592 //
593 CharC = DecodeC (Sd);
594 if (Sd->mBadTableFlag != 0) {
595 goto Done;
596 }
597
598 if (CharC < 256) {
599 //
600 // Process an Original character
601 //
602 if (Sd->mOutBuf >= Sd->mOrigSize) {
603 goto Done;
604 } else {
605 //
606 // Write orignal character into mDstBase
607 //
608 Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;
609 }
610
611 } else {
612 //
613 // Process a Pointer
614 //
615 CharC = (UINT16) (CharC - (BIT8 - THRESHOLD));
616
617 //
618 // Get string length
619 //
620 BytesRemain = CharC;
621
622 //
623 // Locate string position
624 //
625 DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1;
626
627 //
628 // Write BytesRemain of bytes into mDstBase
629 //
630 BytesRemain--;
631
632 while ((INT16) (BytesRemain) >= 0) {
633 if (Sd->mOutBuf >= Sd->mOrigSize) {
634 goto Done;
635 }
636 if (DataIdx >= Sd->mOrigSize) {
637 Sd->mBadTableFlag = (UINT16) BAD_TABLE;
638 goto Done;
639 }
640 Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];
641
642 BytesRemain--;
643 }
644 }
645 }
646
647 Done:
648 return ;
649 }
650
651 /**
652 Given a compressed source buffer, this function retrieves the size of
653 the uncompressed buffer and the size of the scratch buffer required
654 to decompress the compressed source buffer.
655
656 Retrieves the size of the uncompressed buffer and the temporary scratch buffer
657 required to decompress the buffer specified by Source and SourceSize.
658 If the size of the uncompressed buffer or the size of the scratch buffer cannot
659 be determined from the compressed data specified by Source and SourceData,
660 then RETURN_INVALID_PARAMETER is returned. Otherwise, the size of the uncompressed
661 buffer is returned in DestinationSize, the size of the scratch buffer is returned
662 in ScratchSize, and RETURN_SUCCESS is returned.
663 This function does not have scratch buffer available to perform a thorough
664 checking of the validity of the source data. It just retrieves the "Original Size"
665 field from the beginning bytes of the source data and output it as DestinationSize.
666 And ScratchSize is specific to the decompression implementation.
667
668 If Source is NULL, then ASSERT().
669 If DestinationSize is NULL, then ASSERT().
670 If ScratchSize is NULL, then ASSERT().
671
672 @param Source The source buffer containing the compressed data.
673 @param SourceSize The size, in bytes, of the source buffer.
674 @param DestinationSize A pointer to the size, in bytes, of the uncompressed buffer
675 that will be generated when the compressed buffer specified
676 by Source and SourceSize is decompressed.
677 @param ScratchSize A pointer to the size, in bytes, of the scratch buffer that
678 is required to decompress the compressed buffer specified
679 by Source and SourceSize.
680
681 @retval RETURN_SUCCESS The size of the uncompressed data was returned
682 in DestinationSize, and the size of the scratch
683 buffer was returned in ScratchSize.
684 @retval RETURN_INVALID_PARAMETER
685 The size of the uncompressed data or the size of
686 the scratch buffer cannot be determined from
687 the compressed data specified by Source
688 and SourceSize.
689 **/
690 RETURN_STATUS
691 EFIAPI
692 UefiDecompressGetInfo (
693 IN CONST VOID *Source,
694 IN UINT32 SourceSize,
695 OUT UINT32 *DestinationSize,
696 OUT UINT32 *ScratchSize
697 )
698 {
699 UINT32 CompressedSize;
700
701 ASSERT (Source != NULL);
702 ASSERT (DestinationSize != NULL);
703 ASSERT (ScratchSize != NULL);
704
705 if (SourceSize < 8) {
706 return RETURN_INVALID_PARAMETER;
707 }
708
709 CompressedSize = ReadUnaligned32 ((UINT32 *)Source);
710 if (SourceSize < (CompressedSize + 8) || (CompressedSize + 8) < 8) {
711 return RETURN_INVALID_PARAMETER;
712 }
713
714 *ScratchSize = sizeof (SCRATCH_DATA);
715 *DestinationSize = ReadUnaligned32 ((UINT32 *)Source + 1);
716
717 return RETURN_SUCCESS;
718 }
719
720 /**
721 Decompresses a compressed source buffer.
722
723 Extracts decompressed data to its original form.
724 This function is designed so that the decompression algorithm can be implemented
725 without using any memory services. As a result, this function is not allowed to
726 call any memory allocation services in its implementation. It is the caller's
727 responsibility to allocate and free the Destination and Scratch buffers.
728 If the compressed source data specified by Source is successfully decompressed
729 into Destination, then RETURN_SUCCESS is returned. If the compressed source data
730 specified by Source is not in a valid compressed data format,
731 then RETURN_INVALID_PARAMETER is returned.
732
733 If Source is NULL, then ASSERT().
734 If Destination is NULL, then ASSERT().
735 If the required scratch buffer size > 0 and Scratch is NULL, then ASSERT().
736
737 @param Source The source buffer containing the compressed data.
738 @param Destination The destination buffer to store the decompressed data.
739 @param Scratch A temporary scratch buffer that is used to perform the decompression.
740 This is an optional parameter that may be NULL if the
741 required scratch buffer size is 0.
742
743 @retval RETURN_SUCCESS Decompression completed successfully, and
744 the uncompressed buffer is returned in Destination.
745 @retval RETURN_INVALID_PARAMETER
746 The source buffer specified by Source is corrupted
747 (not in a valid compressed format).
748 **/
749 RETURN_STATUS
750 EFIAPI
751 UefiDecompress (
752 IN CONST VOID *Source,
753 IN OUT VOID *Destination,
754 IN OUT VOID *Scratch OPTIONAL
755 )
756 {
757 UINT32 CompSize;
758 UINT32 OrigSize;
759 SCRATCH_DATA *Sd;
760 CONST UINT8 *Src;
761 UINT8 *Dst;
762
763 ASSERT (Source != NULL);
764 ASSERT (Destination != NULL);
765 ASSERT (Scratch != NULL);
766
767 Src = Source;
768 Dst = Destination;
769
770 Sd = (SCRATCH_DATA *) Scratch;
771
772 CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24);
773 OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);
774
775 //
776 // If compressed file size is 0, return
777 //
778 if (OrigSize == 0) {
779 return RETURN_SUCCESS;
780 }
781
782 Src = Src + 8;
783 SetMem (Sd, sizeof (SCRATCH_DATA), 0);
784
785 //
786 // The length of the field 'Position Set Code Length Array Size' in Block Header.
787 // For UEFI 2.0 de/compression algorithm(Version 1), mPBit = 4
788 //
789 Sd->mPBit = 4;
790 Sd->mSrcBase = (UINT8 *)Src;
791 Sd->mDstBase = Dst;
792 //
793 // CompSize and OrigSize are calculated in bytes
794 //
795 Sd->mCompSize = CompSize;
796 Sd->mOrigSize = OrigSize;
797
798 //
799 // Fill the first BITBUFSIZ bits
800 //
801 FillBuf (Sd, BITBUFSIZ);
802
803 //
804 // Decompress it
805 //
806 Decode (Sd);
807
808 if (Sd->mBadTableFlag != 0) {
809 //
810 // Something wrong with the source
811 //
812 return RETURN_INVALID_PARAMETER;
813 }
814
815 return RETURN_SUCCESS;
816 }
EFI Development Kit II mirror for PVE