3 * \brief Handling of .xz Index and related information
9 * This file has been put into the public domain.
10 * You can do whatever you want with this file.
12 * See ../lzma.h for information about liblzma as a whole.
15 #ifndef LZMA_H_INTERNAL
16 # error Never include this file directly. Use <lzma.h> instead.
21 * \brief Opaque data type to hold the Index(es) and other information
23 * lzma_index often holds just one .xz Index and possibly the Stream Flags
24 * of the same Stream and size of the Stream Padding field. However,
25 * multiple lzma_indexes can be concatenated with lzma_index_cat() and then
26 * there may be information about multiple Streams in the same lzma_index.
28 * Notes about thread safety: Only one thread may modify lzma_index at
29 * a time. All functions that take non-const pointer to lzma_index
30 * modify it. As long as no thread is modifying the lzma_index, getting
31 * information from the same lzma_index can be done from multiple threads
32 * at the same time with functions that take a const pointer to
33 * lzma_index or use lzma_index_iter. The same iterator must be used
34 * only by one thread at a time, of course, but there can be as many
35 * iterators for the same lzma_index as needed.
37 typedef struct lzma_index_s lzma_index;
41 * \brief Iterator to get information about Blocks and Streams
46 * \brief Pointer to Stream Flags
48 * This is NULL if Stream Flags have not been set for
49 * this Stream with lzma_index_stream_flags().
51 const lzma_stream_flags *flags;
53 const void *reserved_ptr1;
54 const void *reserved_ptr2;
55 const void *reserved_ptr3;
58 * \brief Stream number in the lzma_index
60 * The first Stream is 1.
65 * \brief Number of Blocks in the Stream
67 * If this is zero, the block structure below has
73 * \brief Compressed start offset of this Stream
75 * The offset is relative to the beginning of the lzma_index
76 * (i.e. usually the beginning of the .xz file).
78 lzma_vli compressed_offset;
81 * \brief Uncompressed start offset of this Stream
83 * The offset is relative to the beginning of the lzma_index
84 * (i.e. usually the beginning of the .xz file).
86 lzma_vli uncompressed_offset;
89 * \brief Compressed size of this Stream
91 * This includes all headers except the possible
92 * Stream Padding after this Stream.
94 lzma_vli compressed_size;
97 * \brief Uncompressed size of this Stream
99 lzma_vli uncompressed_size;
102 * \brief Size of Stream Padding after this Stream
104 * If it hasn't been set with lzma_index_stream_padding(),
105 * this defaults to zero. Stream Padding is always
106 * a multiple of four bytes.
110 lzma_vli reserved_vli1;
111 lzma_vli reserved_vli2;
112 lzma_vli reserved_vli3;
113 lzma_vli reserved_vli4;
118 * \brief Block number in the file
120 * The first Block is 1.
122 lzma_vli number_in_file;
125 * \brief Compressed start offset of this Block
127 * This offset is relative to the beginning of the
128 * lzma_index (i.e. usually the beginning of the .xz file).
129 * Normally this is where you should seek in the .xz file
130 * to start decompressing this Block.
132 lzma_vli compressed_file_offset;
135 * \brief Uncompressed start offset of this Block
137 * This offset is relative to the beginning of the lzma_index
138 * (i.e. usually the beginning of the .xz file).
140 lzma_vli uncompressed_file_offset;
143 * \brief Block number in this Stream
145 * The first Block is 1.
147 lzma_vli number_in_stream;
150 * \brief Compressed start offset of this Block
152 * This offset is relative to the beginning of the Stream
153 * containing this Block.
155 lzma_vli compressed_stream_offset;
158 * \brief Uncompressed start offset of this Block
160 * This offset is relative to the beginning of the Stream
161 * containing this Block.
163 lzma_vli uncompressed_stream_offset;
166 * \brief Uncompressed size of this Block
168 * You should pass this to the Block decoder if you will
171 * When doing random-access reading, it is possible that
172 * the target offset is not exactly at Block boundary. One
173 * will need to compare the target offset against
174 * uncompressed_file_offset or uncompressed_stream_offset,
175 * and possibly decode and throw away some amount of data
176 * before reaching the target offset.
178 lzma_vli uncompressed_size;
181 * \brief Unpadded size of this Block
183 * You should pass this to the Block decoder if you will
186 lzma_vli unpadded_size;
189 * \brief Total compressed size
191 * This includes all headers and padding in this Block.
192 * This is useful if you need to know how many bytes
193 * the Block decoder will actually read.
197 lzma_vli reserved_vli1;
198 lzma_vli reserved_vli2;
199 lzma_vli reserved_vli3;
200 lzma_vli reserved_vli4;
202 const void *reserved_ptr1;
203 const void *reserved_ptr2;
204 const void *reserved_ptr3;
205 const void *reserved_ptr4;
209 * Internal data which is used to store the state of the iterator.
210 * The exact format may vary between liblzma versions, so don't
211 * touch these in any way.
222 * \brief Operation mode for lzma_index_iter_next()
225 LZMA_INDEX_ITER_ANY = 0,
227 * \brief Get the next Block or Stream
229 * Go to the next Block if the current Stream has at least
230 * one Block left. Otherwise go to the next Stream even if
231 * it has no Blocks. If the Stream has no Blocks
232 * (lzma_index_iter.stream.block_count == 0),
233 * lzma_index_iter.block will have undefined values.
236 LZMA_INDEX_ITER_STREAM = 1,
238 * \brief Get the next Stream
240 * Go to the next Stream even if the current Stream has
241 * unread Blocks left. If the next Stream has at least one
242 * Block, the iterator will point to the first Block.
243 * If there are no Blocks, lzma_index_iter.block will have
247 LZMA_INDEX_ITER_BLOCK = 2,
249 * \brief Get the next Block
251 * Go to the next Block if the current Stream has at least
252 * one Block left. If the current Stream has no Blocks left,
253 * the next Stream with at least one Block is located and
254 * the iterator will be made to point to the first Block of
258 LZMA_INDEX_ITER_NONEMPTY_BLOCK = 3
260 * \brief Get the next non-empty Block
262 * This is like LZMA_INDEX_ITER_BLOCK except that it will
263 * skip Blocks whose Uncompressed Size is zero.
266 } lzma_index_iter_mode;
270 * \brief Calculate memory usage of lzma_index
272 * On disk, the size of the Index field depends on both the number of Records
273 * stored and how big values the Records store (due to variable-length integer
274 * encoding). When the Index is kept in lzma_index structure, the memory usage
275 * depends only on the number of Records/Blocks stored in the Index(es), and
276 * in case of concatenated lzma_indexes, the number of Streams. The size in
277 * RAM is almost always significantly bigger than in the encoded form on disk.
279 * This function calculates an approximate amount of memory needed hold
280 * the given number of Streams and Blocks in lzma_index structure. This
281 * value may vary between CPU architectures and also between liblzma versions
282 * if the internal implementation is modified.
284 extern LZMA_API(uint64_t) lzma_index_memusage(
285 lzma_vli streams, lzma_vli blocks) lzma_nothrow;
289 * \brief Calculate the memory usage of an existing lzma_index
291 * This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i),
292 * lzma_index_block_count(i)).
294 extern LZMA_API(uint64_t) lzma_index_memused(const lzma_index *i)
299 * \brief Allocate and initialize a new lzma_index structure
301 * \return On success, a pointer to an empty initialized lzma_index is
302 * returned. If allocation fails, NULL is returned.
304 extern LZMA_API(lzma_index *) lzma_index_init(lzma_allocator *allocator)
309 * \brief Deallocate lzma_index
311 * If i is NULL, this does nothing.
313 extern LZMA_API(void) lzma_index_end(lzma_index *i, lzma_allocator *allocator)
318 * \brief Add a new Block to lzma_index
320 * \param i Pointer to a lzma_index structure
321 * \param allocator Pointer to lzma_allocator, or NULL to
323 * \param unpadded_size Unpadded Size of a Block. This can be
324 * calculated with lzma_block_unpadded_size()
325 * after encoding or decoding the Block.
326 * \param uncompressed_size Uncompressed Size of a Block. This can be
327 * taken directly from lzma_block structure
328 * after encoding or decoding the Block.
330 * Appending a new Block does not invalidate iterators. For example,
331 * if an iterator was pointing to the end of the lzma_index, after
332 * lzma_index_append() it is possible to read the next Block with
333 * an existing iterator.
337 * - LZMA_DATA_ERROR: Compressed or uncompressed size of the
338 * Stream or size of the Index field would grow too big.
341 extern LZMA_API(lzma_ret) lzma_index_append(
342 lzma_index *i, lzma_allocator *allocator,
343 lzma_vli unpadded_size, lzma_vli uncompressed_size)
344 lzma_nothrow lzma_attr_warn_unused_result;
348 * \brief Set the Stream Flags
350 * Set the Stream Flags of the last (and typically the only) Stream
351 * in lzma_index. This can be useful when reading information from the
352 * lzma_index, because to decode Blocks, knowing the integrity check type
355 * The given Stream Flags are copied into internal preallocated structure
356 * in the lzma_index, thus the caller doesn't need to keep the *stream_flags
357 * available after calling this function.
360 * - LZMA_OPTIONS_ERROR: Unsupported stream_flags->version.
363 extern LZMA_API(lzma_ret) lzma_index_stream_flags(
364 lzma_index *i, const lzma_stream_flags *stream_flags)
365 lzma_nothrow lzma_attr_warn_unused_result;
369 * \brief Get the types of integrity Checks
371 * If lzma_index_stream_padding() is used to set the Stream Flags for
372 * every Stream, lzma_index_checks() can be used to get a bitmask to
373 * indicate which Check types have been used. It can be useful e.g. if
374 * showing the Check types to the user.
376 * The bitmask is 1 << check_id, e.g. CRC32 is 1 << 1 and SHA-256 is 1 << 10.
378 extern LZMA_API(uint32_t) lzma_index_checks(const lzma_index *i)
379 lzma_nothrow lzma_attr_pure;
383 * \brief Set the amount of Stream Padding
385 * Set the amount of Stream Padding of the last (and typically the only)
386 * Stream in the lzma_index. This is needed when planning to do random-access
387 * reading within multiple concatenated Streams.
389 * By default, the amount of Stream Padding is assumed to be zero bytes.
392 * - LZMA_DATA_ERROR: The file size would grow too big.
395 extern LZMA_API(lzma_ret) lzma_index_stream_padding(
396 lzma_index *i, lzma_vli stream_padding)
397 lzma_nothrow lzma_attr_warn_unused_result;
401 * \brief Get the number of Streams
403 extern LZMA_API(lzma_vli) lzma_index_stream_count(const lzma_index *i)
404 lzma_nothrow lzma_attr_pure;
408 * \brief Get the number of Blocks
410 * This returns the total number of Blocks in lzma_index. To get number
411 * of Blocks in individual Streams, use lzma_index_iter.
413 extern LZMA_API(lzma_vli) lzma_index_block_count(const lzma_index *i)
414 lzma_nothrow lzma_attr_pure;
418 * \brief Get the size of the Index field as bytes
420 * This is needed to verify the Backward Size field in the Stream Footer.
422 extern LZMA_API(lzma_vli) lzma_index_size(const lzma_index *i)
423 lzma_nothrow lzma_attr_pure;
427 * \brief Get the total size of the Stream
429 * If multiple lzma_indexes have been combined, this works as if the Blocks
430 * were in a single Stream. This is useful if you are going to combine
431 * Blocks from multiple Streams into a single new Stream.
433 extern LZMA_API(lzma_vli) lzma_index_stream_size(const lzma_index *i)
434 lzma_nothrow lzma_attr_pure;
438 * \brief Get the total size of the Blocks
440 * This doesn't include the Stream Header, Stream Footer, Stream Padding,
443 extern LZMA_API(lzma_vli) lzma_index_total_size(const lzma_index *i)
444 lzma_nothrow lzma_attr_pure;
448 * \brief Get the total size of the file
450 * When no lzma_indexes have been combined with lzma_index_cat() and there is
451 * no Stream Padding, this function is identical to lzma_index_stream_size().
452 * If multiple lzma_indexes have been combined, this includes also the headers
453 * of each separate Stream and the possible Stream Padding fields.
455 extern LZMA_API(lzma_vli) lzma_index_file_size(const lzma_index *i)
456 lzma_nothrow lzma_attr_pure;
460 * \brief Get the uncompressed size of the file
462 extern LZMA_API(lzma_vli) lzma_index_uncompressed_size(const lzma_index *i)
463 lzma_nothrow lzma_attr_pure;
467 * \brief Initialize an iterator
469 * \param iter Pointer to a lzma_index_iter structure
470 * \param i lzma_index to which the iterator will be associated
472 * This function associates the iterator with the given lzma_index, and calls
473 * lzma_index_iter_rewind() on the iterator.
475 * This function doesn't allocate any memory, thus there is no
476 * lzma_index_iter_end(). The iterator is valid as long as the
477 * associated lzma_index is valid, that is, until lzma_index_end() or
478 * using it as source in lzma_index_cat(). Specifically, lzma_index doesn't
479 * become invalid if new Blocks are added to it with lzma_index_append() or
480 * if it is used as the destination in lzma_index_cat().
482 * It is safe to make copies of an initialized lzma_index_iter, for example,
483 * to easily restart reading at some particular position.
485 extern LZMA_API(void) lzma_index_iter_init(
486 lzma_index_iter *iter, const lzma_index *i) lzma_nothrow;
490 * \brief Rewind the iterator
492 * Rewind the iterator so that next call to lzma_index_iter_next() will
493 * return the first Block or Stream.
495 extern LZMA_API(void) lzma_index_iter_rewind(lzma_index_iter *iter)
500 * \brief Get the next Block or Stream
502 * \param iter Iterator initialized with lzma_index_iter_init()
503 * \param mode Specify what kind of information the caller wants
504 * to get. See lzma_index_iter_mode for details.
506 * \return If next Block or Stream matching the mode was found, *iter
507 * is updated and this function returns false. If no Block or
508 * Stream matching the mode is found, *iter is not modified
509 * and this function returns true. If mode is set to an unknown
510 * value, *iter is not modified and this function returns true.
512 extern LZMA_API(lzma_bool) lzma_index_iter_next(
513 lzma_index_iter *iter, lzma_index_iter_mode mode)
514 lzma_nothrow lzma_attr_warn_unused_result;
518 * \brief Locate a Block
520 * If it is possible to seek in the .xz file, it is possible to parse
521 * the Index field(s) and use lzma_index_iter_locate() to do random-access
522 * reading with granularity of Block size.
524 * \param iter Iterator that was earlier initialized with
525 * lzma_index_iter_init().
526 * \param target Uncompressed target offset which the caller would
527 * like to locate from the Stream
529 * If the target is smaller than the uncompressed size of the Stream (can be
530 * checked with lzma_index_uncompressed_size()):
531 * - Information about the Stream and Block containing the requested
532 * uncompressed offset is stored into *iter.
533 * - Internal state of the iterator is adjusted so that
534 * lzma_index_iter_next() can be used to read subsequent Blocks or Streams.
535 * - This function returns false.
537 * If target is greater than the uncompressed size of the Stream, *iter
538 * is not modified, and this function returns true.
540 extern LZMA_API(lzma_bool) lzma_index_iter_locate(
541 lzma_index_iter *iter, lzma_vli target) lzma_nothrow;
545 * \brief Concatenate lzma_indexes
547 * Concatenating lzma_indexes is useful when doing random-access reading in
548 * multi-Stream .xz file, or when combining multiple Streams into single
551 * \param dest lzma_index after which src is appended
552 * \param src lzma_index to be appended after dest. If this
553 * function succeeds, the memory allocated for src
554 * is freed or moved to be part of dest, and all
555 * iterators pointing to src will become invalid.
556 * \param allocator Custom memory allocator; can be NULL to use
557 * malloc() and free().
559 * \return - LZMA_OK: lzma_indexes were concatenated successfully.
560 * src is now a dangling pointer.
561 * - LZMA_DATA_ERROR: *dest would grow too big.
565 extern LZMA_API(lzma_ret) lzma_index_cat(
566 lzma_index *dest, lzma_index *src, lzma_allocator *allocator)
567 lzma_nothrow lzma_attr_warn_unused_result;
571 * \brief Duplicate lzma_index
573 * \return A copy of the lzma_index, or NULL if memory allocation failed.
575 extern LZMA_API(lzma_index *) lzma_index_dup(
576 const lzma_index *i, lzma_allocator *allocator)
577 lzma_nothrow lzma_attr_warn_unused_result;
581 * \brief Initialize .xz Index encoder
583 * \param strm Pointer to properly prepared lzma_stream
584 * \param i Pointer to lzma_index which should be encoded.
586 * The only valid action value for lzma_code() is LZMA_RUN.
588 * \return - LZMA_OK: Initialization succeeded, continue with lzma_code().
592 extern LZMA_API(lzma_ret) lzma_index_encoder(
593 lzma_stream *strm, const lzma_index *i)
594 lzma_nothrow lzma_attr_warn_unused_result;
598 * \brief Initialize .xz Index decoder
600 * \param strm Pointer to properly prepared lzma_stream
601 * \param i The decoded Index will be made available via
602 * this pointer. Initially this function will
603 * set *i to NULL (the old value is ignored). If
604 * decoding succeeds (lzma_code() returns
605 * LZMA_STREAM_END), *i will be set to point
606 * to a new lzma_index, which the application
607 * has to later free with lzma_index_end().
608 * \param memlimit How much memory the resulting lzma_index is
609 * allowed to require.
611 * The only valid action value for lzma_code() is LZMA_RUN.
613 * \return - LZMA_OK: Initialization succeeded, continue with lzma_code().
615 * - LZMA_MEMLIMIT_ERROR
618 extern LZMA_API(lzma_ret) lzma_index_decoder(
619 lzma_stream *strm, lzma_index **i, uint64_t memlimit)
620 lzma_nothrow lzma_attr_warn_unused_result;
624 * \brief Single-call .xz Index encoder
626 * \param i lzma_index to be encoded
627 * \param out Beginning of the output buffer
628 * \param out_pos The next byte will be written to out[*out_pos].
629 * *out_pos is updated only if encoding succeeds.
630 * \param out_size Size of the out buffer; the first byte into
631 * which no data is written to is out[out_size].
633 * \return - LZMA_OK: Encoding was successful.
634 * - LZMA_BUF_ERROR: Output buffer is too small. Use
635 * lzma_index_size() to find out how much output
639 * \note This function doesn't take allocator argument since all
640 * the internal data is allocated on stack.
642 extern LZMA_API(lzma_ret) lzma_index_buffer_encode(const lzma_index *i,
643 uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
647 * \brief Single-call .xz Index decoder
649 * \param i If decoding succeeds, *i will point to a new
650 * lzma_index, which the application has to
651 * later free with lzma_index_end(). If an error
652 * occurs, *i will be NULL. The old value of *i
653 * is always ignored and thus doesn't need to be
654 * initialized by the caller.
655 * \param memlimit Pointer to how much memory the resulting
656 * lzma_index is allowed to require. The value
657 * pointed by this pointer is modified if and only
658 * if LZMA_MEMLIMIT_ERROR is returned.
659 * \param allocator Pointer to lzma_allocator, or NULL to use malloc()
660 * \param in Beginning of the input buffer
661 * \param in_pos The next byte will be read from in[*in_pos].
662 * *in_pos is updated only if decoding succeeds.
663 * \param in_size Size of the input buffer; the first byte that
664 * won't be read is in[in_size].
666 * \return - LZMA_OK: Decoding was successful.
668 * - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached.
669 * The minimum required memlimit value was stored to *memlimit.
673 extern LZMA_API(lzma_ret) lzma_index_buffer_decode(lzma_index **i,
674 uint64_t *memlimit, lzma_allocator *allocator,
675 const uint8_t *in, size_t *in_pos, size_t in_size)