]> pd.if.org Git - zpackage/blob - lzma/common/stream_decoder.c
allow partial package ids in packagehash
[zpackage] / lzma / common / stream_decoder.c
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file       stream_decoder.c
4 /// \brief      Decodes .xz Streams
5 //
6 //  Author:     Lasse Collin
7 //
8 //  This file has been put into the public domain.
9 //  You can do whatever you want with this file.
10 //
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #include "stream_decoder.h"
14 #include "block_decoder.h"
15
16
17 typedef struct {
18         enum {
19                 SEQ_STREAM_HEADER,
20                 SEQ_BLOCK_HEADER,
21                 SEQ_BLOCK,
22                 SEQ_INDEX,
23                 SEQ_STREAM_FOOTER,
24                 SEQ_STREAM_PADDING,
25         } sequence;
26
27         /// Block or Metadata decoder. This takes little memory and the same
28         /// data structure can be used to decode every Block Header, so it's
29         /// a good idea to have a separate lzma_next_coder structure for it.
30         lzma_next_coder block_decoder;
31
32         /// Block options decoded by the Block Header decoder and used by
33         /// the Block decoder.
34         lzma_block block_options;
35
36         /// Stream Flags from Stream Header
37         lzma_stream_flags stream_flags;
38
39         /// Index is hashed so that it can be compared to the sizes of Blocks
40         /// with O(1) memory usage.
41         lzma_index_hash *index_hash;
42
43         /// Memory usage limit
44         uint64_t memlimit;
45
46         /// Amount of memory actually needed (only an estimate)
47         uint64_t memusage;
48
49         /// If true, LZMA_NO_CHECK is returned if the Stream has
50         /// no integrity check.
51         bool tell_no_check;
52
53         /// If true, LZMA_UNSUPPORTED_CHECK is returned if the Stream has
54         /// an integrity check that isn't supported by this liblzma build.
55         bool tell_unsupported_check;
56
57         /// If true, LZMA_GET_CHECK is returned after decoding Stream Header.
58         bool tell_any_check;
59
60         /// If true, we will tell the Block decoder to skip calculating
61         /// and verifying the integrity check.
62         bool ignore_check;
63
64         /// If true, we will decode concatenated Streams that possibly have
65         /// Stream Padding between or after them. LZMA_STREAM_END is returned
66         /// once the application isn't giving us any new input, and we aren't
67         /// in the middle of a Stream, and possible Stream Padding is a
68         /// multiple of four bytes.
69         bool concatenated;
70
71         /// When decoding concatenated Streams, this is true as long as we
72         /// are decoding the first Stream. This is needed to avoid misleading
73         /// LZMA_FORMAT_ERROR in case the later Streams don't have valid magic
74         /// bytes.
75         bool first_stream;
76
77         /// Write position in buffer[] and position in Stream Padding
78         size_t pos;
79
80         /// Buffer to hold Stream Header, Block Header, and Stream Footer.
81         /// Block Header has biggest maximum size.
82         uint8_t buffer[LZMA_BLOCK_HEADER_SIZE_MAX];
83 } lzma_stream_coder;
84
85
86 static lzma_ret
87 stream_decoder_reset(lzma_stream_coder *coder, const lzma_allocator *allocator)
88 {
89         // Initialize the Index hash used to verify the Index.
90         coder->index_hash = lzma_index_hash_init(coder->index_hash, allocator);
91         if (coder->index_hash == NULL)
92                 return LZMA_MEM_ERROR;
93
94         // Reset the rest of the variables.
95         coder->sequence = SEQ_STREAM_HEADER;
96         coder->pos = 0;
97
98         return LZMA_OK;
99 }
100
101
102 static lzma_ret
103 stream_decode(void *coder_ptr, const lzma_allocator *allocator,
104                 const uint8_t *restrict in, size_t *restrict in_pos,
105                 size_t in_size, uint8_t *restrict out,
106                 size_t *restrict out_pos, size_t out_size, lzma_action action)
107 {
108         lzma_stream_coder *coder = coder_ptr;
109
110         // When decoding the actual Block, it may be able to produce more
111         // output even if we don't give it any new input.
112         while (true)
113         switch (coder->sequence) {
114         case SEQ_STREAM_HEADER: {
115                 // Copy the Stream Header to the internal buffer.
116                 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
117                                 LZMA_STREAM_HEADER_SIZE);
118
119                 // Return if we didn't get the whole Stream Header yet.
120                 if (coder->pos < LZMA_STREAM_HEADER_SIZE)
121                         return LZMA_OK;
122
123                 coder->pos = 0;
124
125                 // Decode the Stream Header.
126                 const lzma_ret ret = lzma_stream_header_decode(
127                                 &coder->stream_flags, coder->buffer);
128                 if (ret != LZMA_OK)
129                         return ret == LZMA_FORMAT_ERROR && !coder->first_stream
130                                         ? LZMA_DATA_ERROR : ret;
131
132                 // If we are decoding concatenated Streams, and the later
133                 // Streams have invalid Header Magic Bytes, we give
134                 // LZMA_DATA_ERROR instead of LZMA_FORMAT_ERROR.
135                 coder->first_stream = false;
136
137                 // Copy the type of the Check so that Block Header and Block
138                 // decoders see it.
139                 coder->block_options.check = coder->stream_flags.check;
140
141                 // Even if we return LZMA_*_CHECK below, we want
142                 // to continue from Block Header decoding.
143                 coder->sequence = SEQ_BLOCK_HEADER;
144
145                 // Detect if there's no integrity check or if it is
146                 // unsupported if those were requested by the application.
147                 if (coder->tell_no_check && coder->stream_flags.check
148                                 == LZMA_CHECK_NONE)
149                         return LZMA_NO_CHECK;
150
151                 if (coder->tell_unsupported_check
152                                 && !lzma_check_is_supported(
153                                         coder->stream_flags.check))
154                         return LZMA_UNSUPPORTED_CHECK;
155
156                 if (coder->tell_any_check)
157                         return LZMA_GET_CHECK;
158         }
159
160         // Fall through
161
162         case SEQ_BLOCK_HEADER: {
163                 if (*in_pos >= in_size)
164                         return LZMA_OK;
165
166                 if (coder->pos == 0) {
167                         // Detect if it's Index.
168                         if (in[*in_pos] == 0x00) {
169                                 coder->sequence = SEQ_INDEX;
170                                 break;
171                         }
172
173                         // Calculate the size of the Block Header. Note that
174                         // Block Header decoder wants to see this byte too
175                         // so don't advance *in_pos.
176                         coder->block_options.header_size
177                                         = lzma_block_header_size_decode(
178                                                 in[*in_pos]);
179                 }
180
181                 // Copy the Block Header to the internal buffer.
182                 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
183                                 coder->block_options.header_size);
184
185                 // Return if we didn't get the whole Block Header yet.
186                 if (coder->pos < coder->block_options.header_size)
187                         return LZMA_OK;
188
189                 coder->pos = 0;
190
191                 // Version 1 is needed to support the .ignore_check option.
192                 coder->block_options.version = 1;
193
194                 // Set up a buffer to hold the filter chain. Block Header
195                 // decoder will initialize all members of this array so
196                 // we don't need to do it here.
197                 lzma_filter filters[LZMA_FILTERS_MAX + 1];
198                 coder->block_options.filters = filters;
199
200                 // Decode the Block Header.
201                 return_if_error(lzma_block_header_decode(&coder->block_options,
202                                 allocator, coder->buffer));
203
204                 // If LZMA_IGNORE_CHECK was used, this flag needs to be set.
205                 // It has to be set after lzma_block_header_decode() because
206                 // it always resets this to false.
207                 coder->block_options.ignore_check = coder->ignore_check;
208
209                 // Check the memory usage limit.
210                 const uint64_t memusage = lzma_raw_decoder_memusage(filters);
211                 lzma_ret ret;
212
213                 if (memusage == UINT64_MAX) {
214                         // One or more unknown Filter IDs.
215                         ret = LZMA_OPTIONS_ERROR;
216                 } else {
217                         // Now we can set coder->memusage since we know that
218                         // the filter chain is valid. We don't want
219                         // lzma_memusage() to return UINT64_MAX in case of
220                         // invalid filter chain.
221                         coder->memusage = memusage;
222
223                         if (memusage > coder->memlimit) {
224                                 // The chain would need too much memory.
225                                 ret = LZMA_MEMLIMIT_ERROR;
226                         } else {
227                                 // Memory usage is OK.
228                                 // Initialize the Block decoder.
229                                 ret = lzma_block_decoder_init(
230                                                 &coder->block_decoder,
231                                                 allocator,
232                                                 &coder->block_options);
233                         }
234                 }
235
236                 // Free the allocated filter options since they are needed
237                 // only to initialize the Block decoder.
238                 for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i)
239                         lzma_free(filters[i].options, allocator);
240
241                 coder->block_options.filters = NULL;
242
243                 // Check if memory usage calculation and Block enocoder
244                 // initialization succeeded.
245                 if (ret != LZMA_OK)
246                         return ret;
247
248                 coder->sequence = SEQ_BLOCK;
249         }
250
251         // Fall through
252
253         case SEQ_BLOCK: {
254                 const lzma_ret ret = coder->block_decoder.code(
255                                 coder->block_decoder.coder, allocator,
256                                 in, in_pos, in_size, out, out_pos, out_size,
257                                 action);
258
259                 if (ret != LZMA_STREAM_END)
260                         return ret;
261
262                 // Block decoded successfully. Add the new size pair to
263                 // the Index hash.
264                 return_if_error(lzma_index_hash_append(coder->index_hash,
265                                 lzma_block_unpadded_size(
266                                         &coder->block_options),
267                                 coder->block_options.uncompressed_size));
268
269                 coder->sequence = SEQ_BLOCK_HEADER;
270                 break;
271         }
272
273         case SEQ_INDEX: {
274                 // If we don't have any input, don't call
275                 // lzma_index_hash_decode() since it would return
276                 // LZMA_BUF_ERROR, which we must not do here.
277                 if (*in_pos >= in_size)
278                         return LZMA_OK;
279
280                 // Decode the Index and compare it to the hash calculated
281                 // from the sizes of the Blocks (if any).
282                 const lzma_ret ret = lzma_index_hash_decode(coder->index_hash,
283                                 in, in_pos, in_size);
284                 if (ret != LZMA_STREAM_END)
285                         return ret;
286
287                 coder->sequence = SEQ_STREAM_FOOTER;
288         }
289
290         // Fall through
291
292         case SEQ_STREAM_FOOTER: {
293                 // Copy the Stream Footer to the internal buffer.
294                 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
295                                 LZMA_STREAM_HEADER_SIZE);
296
297                 // Return if we didn't get the whole Stream Footer yet.
298                 if (coder->pos < LZMA_STREAM_HEADER_SIZE)
299                         return LZMA_OK;
300
301                 coder->pos = 0;
302
303                 // Decode the Stream Footer. The decoder gives
304                 // LZMA_FORMAT_ERROR if the magic bytes don't match,
305                 // so convert that return code to LZMA_DATA_ERROR.
306                 lzma_stream_flags footer_flags;
307                 const lzma_ret ret = lzma_stream_footer_decode(
308                                 &footer_flags, coder->buffer);
309                 if (ret != LZMA_OK)
310                         return ret == LZMA_FORMAT_ERROR
311                                         ? LZMA_DATA_ERROR : ret;
312
313                 // Check that Index Size stored in the Stream Footer matches
314                 // the real size of the Index field.
315                 if (lzma_index_hash_size(coder->index_hash)
316                                 != footer_flags.backward_size)
317                         return LZMA_DATA_ERROR;
318
319                 // Compare that the Stream Flags fields are identical in
320                 // both Stream Header and Stream Footer.
321                 return_if_error(lzma_stream_flags_compare(
322                                 &coder->stream_flags, &footer_flags));
323
324                 if (!coder->concatenated)
325                         return LZMA_STREAM_END;
326
327                 coder->sequence = SEQ_STREAM_PADDING;
328         }
329
330         // Fall through
331
332         case SEQ_STREAM_PADDING:
333                 assert(coder->concatenated);
334
335                 // Skip over possible Stream Padding.
336                 while (true) {
337                         if (*in_pos >= in_size) {
338                                 // Unless LZMA_FINISH was used, we cannot
339                                 // know if there's more input coming later.
340                                 if (action != LZMA_FINISH)
341                                         return LZMA_OK;
342
343                                 // Stream Padding must be a multiple of
344                                 // four bytes.
345                                 return coder->pos == 0
346                                                 ? LZMA_STREAM_END
347                                                 : LZMA_DATA_ERROR;
348                         }
349
350                         // If the byte is not zero, it probably indicates
351                         // beginning of a new Stream (or the file is corrupt).
352                         if (in[*in_pos] != 0x00)
353                                 break;
354
355                         ++*in_pos;
356                         coder->pos = (coder->pos + 1) & 3;
357                 }
358
359                 // Stream Padding must be a multiple of four bytes (empty
360                 // Stream Padding is OK).
361                 if (coder->pos != 0) {
362                         ++*in_pos;
363                         return LZMA_DATA_ERROR;
364                 }
365
366                 // Prepare to decode the next Stream.
367                 return_if_error(stream_decoder_reset(coder, allocator));
368                 break;
369
370         default:
371                 assert(0);
372                 return LZMA_PROG_ERROR;
373         }
374
375         // Never reached
376 }
377
378
379 static void
380 stream_decoder_end(void *coder_ptr, const lzma_allocator *allocator)
381 {
382         lzma_stream_coder *coder = coder_ptr;
383         lzma_next_end(&coder->block_decoder, allocator);
384         lzma_index_hash_end(coder->index_hash, allocator);
385         lzma_free(coder, allocator);
386         return;
387 }
388
389
390 static lzma_check
391 stream_decoder_get_check(const void *coder_ptr)
392 {
393         const lzma_stream_coder *coder = coder_ptr;
394         return coder->stream_flags.check;
395 }
396
397
398 static lzma_ret
399 stream_decoder_memconfig(void *coder_ptr, uint64_t *memusage,
400                 uint64_t *old_memlimit, uint64_t new_memlimit)
401 {
402         lzma_stream_coder *coder = coder_ptr;
403
404         *memusage = coder->memusage;
405         *old_memlimit = coder->memlimit;
406
407         if (new_memlimit != 0) {
408                 if (new_memlimit < coder->memusage)
409                         return LZMA_MEMLIMIT_ERROR;
410
411                 coder->memlimit = new_memlimit;
412         }
413
414         return LZMA_OK;
415 }
416
417
418 extern lzma_ret
419 lzma_stream_decoder_init(
420                 lzma_next_coder *next, const lzma_allocator *allocator,
421                 uint64_t memlimit, uint32_t flags)
422 {
423         lzma_next_coder_init(&lzma_stream_decoder_init, next, allocator);
424
425         if (flags & ~LZMA_SUPPORTED_FLAGS)
426                 return LZMA_OPTIONS_ERROR;
427
428         lzma_stream_coder *coder = next->coder;
429         if (coder == NULL) {
430                 coder = lzma_alloc(sizeof(lzma_stream_coder), allocator);
431                 if (coder == NULL)
432                         return LZMA_MEM_ERROR;
433
434                 next->coder = coder;
435                 next->code = &stream_decode;
436                 next->end = &stream_decoder_end;
437                 next->get_check = &stream_decoder_get_check;
438                 next->memconfig = &stream_decoder_memconfig;
439
440                 coder->block_decoder = LZMA_NEXT_CODER_INIT;
441                 coder->index_hash = NULL;
442         }
443
444         coder->memlimit = my_max(1, memlimit);
445         coder->memusage = LZMA_MEMUSAGE_BASE;
446         coder->tell_no_check = (flags & LZMA_TELL_NO_CHECK) != 0;
447         coder->tell_unsupported_check
448                         = (flags & LZMA_TELL_UNSUPPORTED_CHECK) != 0;
449         coder->tell_any_check = (flags & LZMA_TELL_ANY_CHECK) != 0;
450         coder->ignore_check = (flags & LZMA_IGNORE_CHECK) != 0;
451         coder->concatenated = (flags & LZMA_CONCATENATED) != 0;
452         coder->first_stream = true;
453
454         return stream_decoder_reset(coder, allocator);
455 }
456
457
458 extern LZMA_API(lzma_ret)
459 lzma_stream_decoder(lzma_stream *strm, uint64_t memlimit, uint32_t flags)
460 {
461         lzma_next_strm_init(lzma_stream_decoder_init, strm, memlimit, flags);
462
463         strm->internal->supported_actions[LZMA_RUN] = true;
464         strm->internal->supported_actions[LZMA_FINISH] = true;
465
466         return LZMA_OK;
467 }