Xz.h 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
  1. /*
  2. * Copyright (c) 2023, Tim Schumacher <timschumi@gmx.de>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #pragma once
  7. #include <AK/ConstrainedStream.h>
  8. #include <AK/CountingStream.h>
  9. #include <AK/Endian.h>
  10. #include <AK/Error.h>
  11. #include <AK/MaybeOwned.h>
  12. #include <AK/NonnullOwnPtr.h>
  13. #include <AK/OwnPtr.h>
  14. #include <AK/Stream.h>
  15. #include <AK/Vector.h>
  16. namespace Compress {
  17. // This implementation is based on the "The .xz File Format" specification version 1.1.0:
  18. // https://tukaani.org/xz/xz-file-format-1.1.0.txt
  19. // 1.2. Multibyte Integers
  20. class [[gnu::packed]] XzMultibyteInteger {
  21. public:
  22. constexpr XzMultibyteInteger() = default;
  23. constexpr XzMultibyteInteger(u64 value)
  24. : m_value(value)
  25. {
  26. }
  27. constexpr operator u64() const { return m_value; }
  28. static ErrorOr<XzMultibyteInteger> read_from_stream(Stream& stream);
  29. private:
  30. u64 m_value { 0 };
  31. };
  32. // 2.1.1.2. Stream Flags
  33. enum XzStreamCheckType : u8 {
  34. None = 0x00,
  35. CRC32 = 0x01,
  36. CRC64 = 0x04,
  37. SHA256 = 0x0A,
  38. };
  39. // 2.1.1.2. Stream Flags
  40. struct [[gnu::packed]] XzStreamFlags {
  41. u8 reserved;
  42. XzStreamCheckType check_type : 4;
  43. u8 reserved_bits : 4;
  44. };
  45. static_assert(sizeof(XzStreamFlags) == 2);
  46. // 2.1.1. Stream Header
  47. struct [[gnu::packed]] XzStreamHeader {
  48. u8 magic[6];
  49. XzStreamFlags flags;
  50. LittleEndian<u32> flags_crc32;
  51. ErrorOr<void> validate() const;
  52. };
  53. static_assert(sizeof(XzStreamHeader) == 12);
  54. // 2.1.2. Stream Footer
  55. struct [[gnu::packed]] XzStreamFooter {
  56. LittleEndian<u32> size_and_flags_crc32;
  57. LittleEndian<u32> encoded_backward_size;
  58. XzStreamFlags flags;
  59. u8 magic[2];
  60. ErrorOr<void> validate() const;
  61. u32 backward_size() const;
  62. };
  63. static_assert(sizeof(XzStreamFooter) == 12);
  64. // 3.1.2. Block Flags
  65. struct [[gnu::packed]] XzBlockFlags {
  66. u8 encoded_number_of_filters : 2;
  67. u8 reserved : 4;
  68. bool compressed_size_present : 1;
  69. bool uncompressed_size_present : 1;
  70. u8 number_of_filters() const;
  71. };
  72. static_assert(sizeof(XzBlockFlags) == 1);
  73. // 5.3.1. LZMA2
  74. struct [[gnu::packed]] XzFilterLzma2Properties {
  75. u8 encoded_dictionary_size : 6;
  76. u8 reserved : 2;
  77. ErrorOr<void> validate() const;
  78. u32 dictionary_size() const;
  79. };
  80. static_assert(sizeof(XzFilterLzma2Properties) == 1);
  81. class XzDecompressor : public Stream {
  82. public:
  83. static ErrorOr<NonnullOwnPtr<XzDecompressor>> create(MaybeOwned<Stream>);
  84. virtual ErrorOr<Bytes> read_some(Bytes) override;
  85. virtual ErrorOr<size_t> write_some(ReadonlyBytes) override;
  86. virtual bool is_eof() const override;
  87. virtual bool is_open() const override;
  88. virtual void close() override;
  89. private:
  90. XzDecompressor(NonnullOwnPtr<CountingStream>);
  91. ErrorOr<bool> load_next_stream();
  92. ErrorOr<void> load_next_block(u8 encoded_block_header_size);
  93. ErrorOr<void> finish_current_block();
  94. ErrorOr<void> finish_current_stream();
  95. NonnullOwnPtr<CountingStream> m_stream;
  96. Optional<XzStreamFlags> m_stream_flags;
  97. bool m_found_first_stream_header { false };
  98. bool m_found_last_stream_footer { false };
  99. Optional<MaybeOwned<Stream>> m_current_block_stream {};
  100. Optional<u64> m_current_block_expected_uncompressed_size {};
  101. u64 m_current_block_uncompressed_size {};
  102. u64 m_current_block_start_offset {};
  103. struct BlockMetadata {
  104. u64 uncompressed_size {};
  105. u64 unpadded_size {};
  106. };
  107. Vector<BlockMetadata> m_processed_blocks;
  108. };
  109. }
  110. template<>
  111. struct AK::Traits<Compress::XzStreamHeader> : public AK::GenericTraits<Compress::XzStreamHeader> {
  112. static constexpr bool is_trivially_serializable() { return true; }
  113. };
  114. template<>
  115. struct AK::Traits<Compress::XzStreamFooter> : public AK::GenericTraits<Compress::XzStreamFooter> {
  116. static constexpr bool is_trivially_serializable() { return true; }
  117. };
  118. template<>
  119. struct AK::Traits<Compress::XzBlockFlags> : public AK::GenericTraits<Compress::XzBlockFlags> {
  120. static constexpr bool is_trivially_serializable() { return true; }
  121. };