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 */ 30 typedef 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 */ 309 extern 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 */ 331 extern 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 */ 376 extern 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 */ 408 extern 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 */ 424 extern 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 */ 437 extern 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 */ 455 extern 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 */ 473 extern 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 */ 484 extern 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 */ 525 extern 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 */ 544 extern 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 */ 577 extern 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