1/**
2 * \file lzma/block.h
3 * \brief .xz Block handling
4 */
5
6/*
7 * Author: Lasse Collin
8 *
9 * This file has been put into the public domain.
10 * You can do whatever you want with this file.
11 *
12 * See ../lzma.h for information about liblzma as a whole.
13 */
14
15#ifndef LZMA_H_INTERNAL
16# error Never include this file directly. Use <lzma.h> instead.
17#endif
18
19
20/**
21 * \brief Options for the Block and Block Header encoders and decoders
22 *
23 * Different Block handling functions use different parts of this structure.
24 * Some read some members, other functions write, and some do both. Only the
25 * members listed for reading need to be initialized when the specified
26 * functions are called. The members marked for writing will be assigned
27 * new values at some point either by calling the given function or by
28 * later calls to lzma_code().
29 */
30typedef struct {
31 /**
32 * \brief Block format version
33 *
34 * To prevent API and ABI breakages when new features are needed,
35 * a version number is used to indicate which fields in this
36 * structure are in use:
37 * - liblzma >= 5.0.0: version = 0 is supported.
38 * - liblzma >= 5.1.4beta: Support for version = 1 was added,
39 * which adds the ignore_check field.
40 *
41 * If version is greater than one, most Block related functions
42 * will return LZMA_OPTIONS_ERROR (lzma_block_header_decode() works
43 * with any version value).
44 *
45 * Read by:
46 * - All functions that take pointer to lzma_block as argument,
47 * including lzma_block_header_decode().
48 *
49 * Written by:
50 * - lzma_block_header_decode()
51 */
52 uint32_t version;
53
54 /**
55 * \brief Size of the Block Header field
56 *
57 * This is always a multiple of four.
58 *
59 * Read by:
60 * - lzma_block_header_encode()
61 * - lzma_block_header_decode()
62 * - lzma_block_compressed_size()
63 * - lzma_block_unpadded_size()
64 * - lzma_block_total_size()
65 * - lzma_block_decoder()
66 * - lzma_block_buffer_decode()
67 *
68 * Written by:
69 * - lzma_block_header_size()
70 * - lzma_block_buffer_encode()
71 */
72 uint32_t header_size;
73# define LZMA_BLOCK_HEADER_SIZE_MIN 8
74# define LZMA_BLOCK_HEADER_SIZE_MAX 1024
75
76 /**
77 * \brief Type of integrity Check
78 *
79 * The Check ID is not stored into the Block Header, thus its value
80 * must be provided also when decoding.
81 *
82 * Read by:
83 * - lzma_block_header_encode()
84 * - lzma_block_header_decode()
85 * - lzma_block_compressed_size()
86 * - lzma_block_unpadded_size()
87 * - lzma_block_total_size()
88 * - lzma_block_encoder()
89 * - lzma_block_decoder()
90 * - lzma_block_buffer_encode()
91 * - lzma_block_buffer_decode()
92 */
93 lzma_check check;
94
95 /**
96 * \brief Size of the Compressed Data in bytes
97 *
98 * Encoding: If this is not LZMA_VLI_UNKNOWN, Block Header encoder
99 * will store this value to the Block Header. Block encoder doesn't
100 * care about this value, but will set it once the encoding has been
101 * finished.
102 *
103 * Decoding: If this is not LZMA_VLI_UNKNOWN, Block decoder will
104 * verify that the size of the Compressed Data field matches
105 * compressed_size.
106 *
107 * Usually you don't know this value when encoding in streamed mode,
108 * and thus cannot write this field into the Block Header.
109 *
110 * In non-streamed mode you can reserve space for this field before
111 * encoding the actual Block. After encoding the data, finish the
112 * Block by encoding the Block Header. Steps in detail:
113 *
114 * - Set compressed_size to some big enough value. If you don't know
115 * better, use LZMA_VLI_MAX, but remember that bigger values take
116 * more space in Block Header.
117 *
118 * - Call lzma_block_header_size() to see how much space you need to
119 * reserve for the Block Header.
120 *
121 * - Encode the Block using lzma_block_encoder() and lzma_code().
122 * It sets compressed_size to the correct value.
123 *
124 * - Use lzma_block_header_encode() to encode the Block Header.
125 * Because space was reserved in the first step, you don't need
126 * to call lzma_block_header_size() anymore, because due to
127 * reserving, header_size has to be big enough. If it is "too big",
128 * lzma_block_header_encode() will add enough Header Padding to
129 * make Block Header to match the size specified by header_size.
130 *
131 * Read by:
132 * - lzma_block_header_size()
133 * - lzma_block_header_encode()
134 * - lzma_block_compressed_size()
135 * - lzma_block_unpadded_size()
136 * - lzma_block_total_size()
137 * - lzma_block_decoder()
138 * - lzma_block_buffer_decode()
139 *
140 * Written by:
141 * - lzma_block_header_decode()
142 * - lzma_block_compressed_size()
143 * - lzma_block_encoder()
144 * - lzma_block_decoder()
145 * - lzma_block_buffer_encode()
146 * - lzma_block_buffer_decode()
147 */
148 lzma_vli compressed_size;
149
150 /**
151 * \brief Uncompressed Size in bytes
152 *
153 * This is handled very similarly to compressed_size above.
154 *
155 * uncompressed_size is needed by fewer functions than
156 * compressed_size. This is because uncompressed_size isn't
157 * needed to validate that Block stays within proper limits.
158 *
159 * Read by:
160 * - lzma_block_header_size()
161 * - lzma_block_header_encode()
162 * - lzma_block_decoder()
163 * - lzma_block_buffer_decode()
164 *
165 * Written by:
166 * - lzma_block_header_decode()
167 * - lzma_block_encoder()
168 * - lzma_block_decoder()
169 * - lzma_block_buffer_encode()
170 * - lzma_block_buffer_decode()
171 */
172 lzma_vli uncompressed_size;
173
174 /**
175 * \brief Array of filters
176 *
177 * There can be 1-4 filters. The end of the array is marked with
178 * .id = LZMA_VLI_UNKNOWN.
179 *
180 * Read by:
181 * - lzma_block_header_size()
182 * - lzma_block_header_encode()
183 * - lzma_block_encoder()
184 * - lzma_block_decoder()
185 * - lzma_block_buffer_encode()
186 * - lzma_block_buffer_decode()
187 *
188 * Written by:
189 * - lzma_block_header_decode(): Note that this does NOT free()
190 * the old filter options structures. All unused filters[] will
191 * have .id == LZMA_VLI_UNKNOWN and .options == NULL. If
192 * decoding fails, all filters[] are guaranteed to be
193 * LZMA_VLI_UNKNOWN and NULL.
194 *
195 * \note Because of the array is terminated with
196 * .id = LZMA_VLI_UNKNOWN, the actual array must
197 * have LZMA_FILTERS_MAX + 1 members or the Block
198 * Header decoder will overflow the buffer.
199 */
200 lzma_filter *filters;
201
202 /**
203 * \brief Raw value stored in the Check field
204 *
205 * After successful coding, the first lzma_check_size(check) bytes
206 * of this array contain the raw value stored in the Check field.
207 *
208 * Note that CRC32 and CRC64 are stored in little endian byte order.
209 * Take it into account if you display the Check values to the user.
210 *
211 * Written by:
212 * - lzma_block_encoder()
213 * - lzma_block_decoder()
214 * - lzma_block_buffer_encode()
215 * - lzma_block_buffer_decode()
216 */
217 uint8_t raw_check[LZMA_CHECK_SIZE_MAX];
218
219 /*
220 * Reserved space to allow possible future extensions without
221 * breaking the ABI. You should not touch these, because the names
222 * of these variables may change. These are and will never be used
223 * with the currently supported options, so it is safe to leave these
224 * uninitialized.
225 */
226 void *reserved_ptr1;
227 void *reserved_ptr2;
228 void *reserved_ptr3;
229 uint32_t reserved_int1;
230 uint32_t reserved_int2;
231 lzma_vli reserved_int3;
232 lzma_vli reserved_int4;
233 lzma_vli reserved_int5;
234 lzma_vli reserved_int6;
235 lzma_vli reserved_int7;
236 lzma_vli reserved_int8;
237 lzma_reserved_enum reserved_enum1;
238 lzma_reserved_enum reserved_enum2;
239 lzma_reserved_enum reserved_enum3;
240 lzma_reserved_enum reserved_enum4;
241
242 /**
243 * \brief A flag to Block decoder to not verify the Check field
244 *
245 * This field is supported by liblzma >= 5.1.4beta if .version >= 1.
246 *
247 * If this is set to true, the integrity check won't be calculated
248 * and verified. Unless you know what you are doing, you should
249 * leave this to false. (A reason to set this to true is when the
250 * file integrity is verified externally anyway and you want to
251 * speed up the decompression, which matters mostly when using
252 * SHA-256 as the integrity check.)
253 *
254 * If .version >= 1, read by:
255 * - lzma_block_decoder()
256 * - lzma_block_buffer_decode()
257 *
258 * Written by (.version is ignored):
259 * - lzma_block_header_decode() always sets this to false
260 */
261 lzma_bool ignore_check;
262
263 lzma_bool reserved_bool2;
264 lzma_bool reserved_bool3;
265 lzma_bool reserved_bool4;
266 lzma_bool reserved_bool5;
267 lzma_bool reserved_bool6;
268 lzma_bool reserved_bool7;
269 lzma_bool reserved_bool8;
270
271} lzma_block;
272
273
274/**
275 * \brief Decode the Block Header Size field
276 *
277 * To decode Block Header using lzma_block_header_decode(), the size of the
278 * Block Header has to be known and stored into lzma_block.header_size.
279 * The size can be calculated from the first byte of a Block using this macro.
280 * Note that if the first byte is 0x00, it indicates beginning of Index; use
281 * this macro only when the byte is not 0x00.
282 *
283 * There is no encoding macro, because Block Header encoder is enough for that.
284 */
285#define lzma_block_header_size_decode(b) (((uint32_t)(b) + 1) * 4)
286
287
288/**
289 * \brief Calculate Block Header Size
290 *
291 * Calculate the minimum size needed for the Block Header field using the
292 * settings specified in the lzma_block structure. Note that it is OK to
293 * increase the calculated header_size value as long as it is a multiple of
294 * four and doesn't exceed LZMA_BLOCK_HEADER_SIZE_MAX. Increasing header_size
295 * just means that lzma_block_header_encode() will add Header Padding.
296 *
297 * \return - LZMA_OK: Size calculated successfully and stored to
298 * block->header_size.
299 * - LZMA_OPTIONS_ERROR: Unsupported version, filters or
300 * filter options.
301 * - LZMA_PROG_ERROR: Invalid values like compressed_size == 0.
302 *
303 * \note This doesn't check that all the options are valid i.e. this
304 * may return LZMA_OK even if lzma_block_header_encode() or
305 * lzma_block_encoder() would fail. If you want to validate the
306 * filter chain, consider using lzma_memlimit_encoder() which as
307 * a side-effect validates the filter chain.
308 */
309extern LZMA_API(lzma_ret) lzma_block_header_size(lzma_block *block)
310 lzma_nothrow lzma_attr_warn_unused_result;
311
312
313/**
314 * \brief Encode Block Header
315 *
316 * The caller must have calculated the size of the Block Header already with
317 * lzma_block_header_size(). If a value larger than the one calculated by
318 * lzma_block_header_size() is used, the Block Header will be padded to the
319 * specified size.
320 *
321 * \param out Beginning of the output buffer. This must be
322 * at least block->header_size bytes.
323 * \param block Block options to be encoded.
324 *
325 * \return - LZMA_OK: Encoding was successful. block->header_size
326 * bytes were written to output buffer.
327 * - LZMA_OPTIONS_ERROR: Invalid or unsupported options.
328 * - LZMA_PROG_ERROR: Invalid arguments, for example
329 * block->header_size is invalid or block->filters is NULL.
330 */
331extern LZMA_API(lzma_ret) lzma_block_header_encode(
332 const lzma_block *block, uint8_t *out)
333 lzma_nothrow lzma_attr_warn_unused_result;
334
335
336/**
337 * \brief Decode Block Header
338 *
339 * block->version should (usually) be set to the highest value supported
340 * by the application. If the application sets block->version to a value
341 * higher than supported by the current liblzma version, this function will
342 * downgrade block->version to the highest value supported by it. Thus one
343 * should check the value of block->version after calling this function if
344 * block->version was set to a non-zero value and the application doesn't
345 * otherwise know that the liblzma version being used is new enough to
346 * support the specified block->version.
347 *
348 * The size of the Block Header must have already been decoded with
349 * lzma_block_header_size_decode() macro and stored to block->header_size.
350 *
351 * The integrity check type from Stream Header must have been stored
352 * to block->check.
353 *
354 * block->filters must have been allocated, but they don't need to be
355 * initialized (possible existing filter options are not freed).
356 *
357 * \param block Destination for Block options.
358 * \param allocator lzma_allocator for custom allocator functions.
359 * Set to NULL to use malloc() (and also free()
360 * if an error occurs).
361 * \param in Beginning of the input buffer. This must be
362 * at least block->header_size bytes.
363 *
364 * \return - LZMA_OK: Decoding was successful. block->header_size
365 * bytes were read from the input buffer.
366 * - LZMA_OPTIONS_ERROR: The Block Header specifies some
367 * unsupported options such as unsupported filters. This can
368 * happen also if block->version was set to a too low value
369 * compared to what would be required to properly represent
370 * the information stored in the Block Header.
371 * - LZMA_DATA_ERROR: Block Header is corrupt, for example,
372 * the CRC32 doesn't match.
373 * - LZMA_PROG_ERROR: Invalid arguments, for example
374 * block->header_size is invalid or block->filters is NULL.
375 */
376extern LZMA_API(lzma_ret) lzma_block_header_decode(lzma_block *block,
377 const lzma_allocator *allocator, const uint8_t *in)
378 lzma_nothrow lzma_attr_warn_unused_result;
379
380
381/**
382 * \brief Validate and set Compressed Size according to Unpadded Size
383 *
384 * Block Header stores Compressed Size, but Index has Unpadded Size. If the
385 * application has already parsed the Index and is now decoding Blocks,
386 * it can calculate Compressed Size from Unpadded Size. This function does
387 * exactly that with error checking:
388 *
389 * - Compressed Size calculated from Unpadded Size must be positive integer,
390 * that is, Unpadded Size must be big enough that after Block Header and
391 * Check fields there's still at least one byte for Compressed Size.
392 *
393 * - If Compressed Size was present in Block Header, the new value
394 * calculated from Unpadded Size is compared against the value
395 * from Block Header.
396 *
397 * \note This function must be called _after_ decoding the Block Header
398 * field so that it can properly validate Compressed Size if it
399 * was present in Block Header.
400 *
401 * \return - LZMA_OK: block->compressed_size was set successfully.
402 * - LZMA_DATA_ERROR: unpadded_size is too small compared to
403 * block->header_size and lzma_check_size(block->check).
404 * - LZMA_PROG_ERROR: Some values are invalid. For example,
405 * block->header_size must be a multiple of four and
406 * between 8 and 1024 inclusive.
407 */
408extern LZMA_API(lzma_ret) lzma_block_compressed_size(
409 lzma_block *block, lzma_vli unpadded_size)
410 lzma_nothrow lzma_attr_warn_unused_result;
411
412
413/**
414 * \brief Calculate Unpadded Size
415 *
416 * The Index field stores Unpadded Size and Uncompressed Size. The latter
417 * can be taken directly from the lzma_block structure after coding a Block,
418 * but Unpadded Size needs to be calculated from Block Header Size,
419 * Compressed Size, and size of the Check field. This is where this function
420 * is needed.
421 *
422 * \return Unpadded Size on success, or zero on error.
423 */
424extern LZMA_API(lzma_vli) lzma_block_unpadded_size(const lzma_block *block)
425 lzma_nothrow lzma_attr_pure;
426
427
428/**
429 * \brief Calculate the total encoded size of a Block
430 *
431 * This is equivalent to lzma_block_unpadded_size() except that the returned
432 * value includes the size of the Block Padding field.
433 *
434 * \return On success, total encoded size of the Block. On error,
435 * zero is returned.
436 */
437extern LZMA_API(lzma_vli) lzma_block_total_size(const lzma_block *block)
438 lzma_nothrow lzma_attr_pure;
439
440
441/**
442 * \brief Initialize .xz Block encoder
443 *
444 * Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the
445 * filter chain supports it), and LZMA_FINISH.
446 *
447 * \return - LZMA_OK: All good, continue with lzma_code().
448 * - LZMA_MEM_ERROR
449 * - LZMA_OPTIONS_ERROR
450 * - LZMA_UNSUPPORTED_CHECK: block->check specifies a Check ID
451 * that is not supported by this build of liblzma. Initializing
452 * the encoder failed.
453 * - LZMA_PROG_ERROR
454 */
455extern LZMA_API(lzma_ret) lzma_block_encoder(
456 lzma_stream *strm, lzma_block *block)
457 lzma_nothrow lzma_attr_warn_unused_result;
458
459
460/**
461 * \brief Initialize .xz Block decoder
462 *
463 * Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using
464 * LZMA_FINISH is not required. It is supported only for convenience.
465 *
466 * \return - LZMA_OK: All good, continue with lzma_code().
467 * - LZMA_UNSUPPORTED_CHECK: Initialization was successful, but
468 * the given Check ID is not supported, thus Check will be
469 * ignored.
470 * - LZMA_PROG_ERROR
471 * - LZMA_MEM_ERROR
472 */
473extern LZMA_API(lzma_ret) lzma_block_decoder(
474 lzma_stream *strm, lzma_block *block)
475 lzma_nothrow lzma_attr_warn_unused_result;
476
477
478/**
479 * \brief Calculate maximum output size for single-call Block encoding
480 *
481 * This is equivalent to lzma_stream_buffer_bound() but for .xz Blocks.
482 * See the documentation of lzma_stream_buffer_bound().
483 */
484extern LZMA_API(size_t) lzma_block_buffer_bound(size_t uncompressed_size)
485 lzma_nothrow;
486
487
488/**
489 * \brief Single-call .xz Block encoder
490 *
491 * In contrast to the multi-call encoder initialized with
492 * lzma_block_encoder(), this function encodes also the Block Header. This
493 * is required to make it possible to write appropriate Block Header also
494 * in case the data isn't compressible, and different filter chain has to be
495 * used to encode the data in uncompressed form using uncompressed chunks
496 * of the LZMA2 filter.
497 *
498 * When the data isn't compressible, header_size, compressed_size, and
499 * uncompressed_size are set just like when the data was compressible, but
500 * it is possible that header_size is too small to hold the filter chain
501 * specified in block->filters, because that isn't necessarily the filter
502 * chain that was actually used to encode the data. lzma_block_unpadded_size()
503 * still works normally, because it doesn't read the filters array.
504 *
505 * \param block Block options: block->version, block->check,
506 * and block->filters must have been initialized.
507 * \param allocator lzma_allocator for custom allocator functions.
508 * Set to NULL to use malloc() and free().
509 * \param in Beginning of the input buffer
510 * \param in_size Size of the input buffer
511 * \param out Beginning of the output buffer
512 * \param out_pos The next byte will be written to out[*out_pos].
513 * *out_pos is updated only if encoding succeeds.
514 * \param out_size Size of the out buffer; the first byte into
515 * which no data is written to is out[out_size].
516 *
517 * \return - LZMA_OK: Encoding was successful.
518 * - LZMA_BUF_ERROR: Not enough output buffer space.
519 * - LZMA_UNSUPPORTED_CHECK
520 * - LZMA_OPTIONS_ERROR
521 * - LZMA_MEM_ERROR
522 * - LZMA_DATA_ERROR
523 * - LZMA_PROG_ERROR
524 */
525extern LZMA_API(lzma_ret) lzma_block_buffer_encode(
526 lzma_block *block, const lzma_allocator *allocator,
527 const uint8_t *in, size_t in_size,
528 uint8_t *out, size_t *out_pos, size_t out_size)
529 lzma_nothrow lzma_attr_warn_unused_result;
530
531
532/**
533 * \brief Single-call uncompressed .xz Block encoder
534 *
535 * This is like lzma_block_buffer_encode() except this doesn't try to
536 * compress the data and instead encodes the data using LZMA2 uncompressed
537 * chunks. The required output buffer size can be determined with
538 * lzma_block_buffer_bound().
539 *
540 * Since the data won't be compressed, this function ignores block->filters.
541 * This function doesn't take lzma_allocator because this function doesn't
542 * allocate any memory from the heap.
543 */
544extern LZMA_API(lzma_ret) lzma_block_uncomp_encode(lzma_block *block,
545 const uint8_t *in, size_t in_size,
546 uint8_t *out, size_t *out_pos, size_t out_size)
547 lzma_nothrow lzma_attr_warn_unused_result;
548
549
550/**
551 * \brief Single-call .xz Block decoder
552 *
553 * This is single-call equivalent of lzma_block_decoder(), and requires that
554 * the caller has already decoded Block Header and checked its memory usage.
555 *
556 * \param block Block options just like with lzma_block_decoder().
557 * \param allocator lzma_allocator for custom allocator functions.
558 * Set to NULL to use malloc() and free().
559 * \param in Beginning of the input buffer
560 * \param in_pos The next byte will be read from in[*in_pos].
561 * *in_pos is updated only if decoding succeeds.
562 * \param in_size Size of the input buffer; the first byte that
563 * won't be read is in[in_size].
564 * \param out Beginning of the output buffer
565 * \param out_pos The next byte will be written to out[*out_pos].
566 * *out_pos is updated only if encoding succeeds.
567 * \param out_size Size of the out buffer; the first byte into
568 * which no data is written to is out[out_size].
569 *
570 * \return - LZMA_OK: Decoding was successful.
571 * - LZMA_OPTIONS_ERROR
572 * - LZMA_DATA_ERROR
573 * - LZMA_MEM_ERROR
574 * - LZMA_BUF_ERROR: Output buffer was too small.
575 * - LZMA_PROG_ERROR
576 */
577extern LZMA_API(lzma_ret) lzma_block_buffer_decode(
578 lzma_block *block, const lzma_allocator *allocator,
579 const uint8_t *in, size_t *in_pos, size_t in_size,
580 uint8_t *out, size_t *out_pos, size_t out_size)
581 lzma_nothrow;
582

source code of include/lzma/block.h