diff --git a/configure.ac b/configure.ac index 539d9222..fdc4884e 100644 --- a/configure.ac +++ b/configure.ac @@ -530,6 +530,11 @@ PKG_CHECK_MODULES(XXHASH, libxxhash >= $XXHASH_VERSION) AC_SUBST(XXHASH_CFLAGS) AC_SUBST(XXHASH_LIBS) +dnl Check for dependency: liblzma +LIBLZMA_VERSION=5.2.5 +PKG_CHECK_MODULES(LZMA, liblzma >= $LIBLZMA_VERSION) +AC_SUBST(LZMA_CFLAGS) +AC_SUBST(LZMA_LIBS) dnl Check for some programs like rm, mkdir, etc ... AC_CHECK_PROG(HAS_RM, rm, yes, no) @@ -912,7 +917,7 @@ AM_CONDITIONAL(ENABLE_RUNNING_TESTS_WITH_PY3, test x$RUN_TESTS_WITH_PY3 = xyes) AM_CONDITIONAL(ENABLE_PYTHON3_INTERPRETER, test x$PYTHON3_INTERPRETER != xno) AC_SUBST(PYTHON) -DEPS_CPPFLAGS="$XML_CFLAGS $XXHASH_CFLAGS $ELF_CFLAGS $DW_CFLAGS" +DEPS_CPPFLAGS="$XML_CFLAGS $XXHASH_CFLAGS $ELF_CFLAGS $DW_CFLAGS $LZMA_CFLAGS" AC_SUBST(DEPS_CPPFLAGS) dnl Check for the presence of doxygen program @@ -954,7 +959,7 @@ AX_VALGRIND_CHECK dnl Set the list of libraries libabigail depends on -DEPS_LIBS="$XML_LIBS $ELF_LIBS $DW_LIBS $CTF_LIBS $BPF_LIBS XXHASH_LIBS" +DEPS_LIBS="$XML_LIBS $ELF_LIBS $DW_LIBS $CTF_LIBS $BPF_LIBS XXHASH_LIBS LZMA_LIBS" AC_SUBST(DEPS_LIBS) if test x$ABIGAIL_DEVEL != x; then diff --git a/include/abg-tools-utils.h b/include/abg-tools-utils.h index c97e61e0..eb521f33 100644 --- a/include/abg-tools-utils.h +++ b/include/abg-tools-utils.h @@ -233,7 +233,22 @@ enum file_type FILE_TYPE_DIR, /// A tar archive. The archive can be compressed with the popular /// compression schemes recognized by GNU tar. - FILE_TYPE_TAR + FILE_TYPE_TAR, + + // All non-tared compression scheme go under here. When one of + // these is returned, the goal is to look into the uncompressed + // stream to get what format has been compressed, then return an + // enumerator for that compressed format instead. + // + // Please note that each time a new enumerator is added here, one + // needs to add a corresponding enumerator to the @ref + // compression_kind enum in abg-tools-utils.cc and update the + // is_compressed_file_type and get_compressed_streambuf functions + // accordingly. + + /// The XZ (lzma) compresson scheme. + + FILE_TYPE_XZ }; /// Exit status for abidiff and abicompat tools. @@ -370,6 +385,49 @@ create_best_elf_based_reader(const string& elf_file_path, bool show_all_types, bool linux_kernel_mode = false); +/// This is a custom std::streambuf that knows how to decompress an +/// input stream that was compressed using xz. +/// +/// The code was inspired by the example in the source code of the xz +/// project at +/// https://github.com/tukaani-project/xz/blob/master/doc/examples/02_decompress.c. +/// +/// here is an example of how a user code would use this custom +/// streambuf to decode an xz'ed file and emit its content to stdout. +/// +/// ifstream input_file("/path/to/a/compressed/file.xz", ifstream::binary); +/// xz_decompressor_type xzed_streambuf(input_file); +/// istream input_stream(&xzed_streambuf); +/// +/// const size_t BUFFER_SIZE = 1024 * 4; +/// vector decompressed_data(BUFFER_SIZE); +/// input_stream.read(decompressed_data.data(), BUFFER_SIZE); +/// size_t nb_bytes_read = input_stream.gcount(); +/// while (nb_bytes_read && !input_stream.bad()) +/// { +/// for (auto c : decompressed_data) +/// std::out << c; +/// } +/// input_file.close(); +/// +/// Voila. +class xz_decompressor_type : public std::streambuf +{ + struct priv; + + std::unique_ptr priv_; + + public: + xz_decompressor_type(std::istream& xz_istream); + + ~xz_decompressor_type(); + + protected: + + int_type + underflow() override; +}; // end class xz_decompressor_type. + }// end namespace tools_utils /// A macro that expands to aborting the program when executed. diff --git a/src/abg-elf-helpers.h b/src/abg-elf-helpers.h index c6f59444..bd6c127d 100644 --- a/src/abg-elf-helpers.h +++ b/src/abg-elf-helpers.h @@ -13,6 +13,7 @@ #include "config.h" #include +#include #include #include diff --git a/src/abg-elf-reader.cc b/src/abg-elf-reader.cc index e3018757..a7ba4a87 100644 --- a/src/abg-elf-reader.cc +++ b/src/abg-elf-reader.cc @@ -1071,7 +1071,9 @@ get_type_of_elf_file(const string& path, elf::elf_type& type) return false; elf_version (EV_CURRENT); - Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL); + // Note that the dwelf_elf_begin function supports decompressing the + // content of the input file, which is pretty cool. + Elf *elf = dwelf_elf_begin(fd); type = elf_file_type(elf); elf_end(elf); close(fd); diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc index 2f811e7e..ad0bf00f 100644 --- a/src/abg-tools-utils.cc +++ b/src/abg-tools-utils.cc @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -1555,12 +1556,43 @@ operator<<(ostream& output, case FILE_TYPE_TAR: repr = "GNU tar archive type"; break; + case FILE_TYPE_XZ: + repr = "XZ compressed file"; } output << repr; return output; } +/// The kind of compression we want a de-compression std::streambuf +/// for. +/// +/// This enum must be amended to add support for new compression +/// schemes, especially whenever a new enumerator is added to the enum +/// @ref file_type. +enum compression_kind +{ + COMPRESSION_KIND_UNKNOWN, + /// The LZMA compression (used by the xz tool). + COMPRESSION_KIND_XZ +}; //end enum compression_kind + +/// Test if one of the enumerators of @ref file_type designates a +/// compression scheme. +/// +/// This helper function needs to be updated whenever a new +/// compression-related enumerator is added to @ref file_type. +/// +/// @return the kind of compression designated by @p t. +static compression_kind +is_compressed_file_type(file_type t) +{ + if (t == FILE_TYPE_XZ) + return COMPRESSION_KIND_XZ; + + return COMPRESSION_KIND_UNKNOWN; +} + /// Guess the type of the content of an input stream. /// /// @param in the input stream to guess the content type for. @@ -1572,11 +1604,11 @@ guess_file_type(istream& in) const unsigned BUF_LEN = 264; const unsigned NB_BYTES_TO_READ = 263; - char buf[BUF_LEN]; + unsigned char buf[BUF_LEN]; memset(buf, 0, BUF_LEN); std::streampos initial_pos = in.tellg(); - in.read(buf, NB_BYTES_TO_READ); + in.read(reinterpret_cast(buf), NB_BYTES_TO_READ); in.seekg(initial_pos); if (in.gcount() < 4 || in.bad()) @@ -1588,6 +1620,17 @@ guess_file_type(istream& in) && buf[3] == 'F') return FILE_TYPE_ELF; + // XZ format. Described at + // https://tukaani.org/xz/xz-file-format.txt. + if (in.gcount() >= 6 + && buf[0] == 0xFD + && buf[1] == '7' + && buf[2] == 'z' + && buf[3] == 'X' + && buf[4] == 'Z' + && buf[5] == 0) + return FILE_TYPE_XZ; + if (buf[0] == '!' && buf[1] == '<' && buf[2] == 'a' @@ -1596,7 +1639,7 @@ guess_file_type(istream& in) && buf[5] == 'h' && buf[6] == '>') { - if (strstr(buf, "debian-binary")) + if (strstr(reinterpret_cast(buf), "debian-binary")) return FILE_TYPE_DEB; else return FILE_TYPE_AR; @@ -1674,6 +1717,42 @@ guess_file_type(istream& in) return FILE_TYPE_UNKNOWN; } +/// The factory of an std::streambuf aimed at decompressing data +/// coming from an input stream compressed with a particular +/// compression scheme. +/// +/// This function must be amended to add support for new compression +/// schemes. +/// +/// @param compressed_input the compressed input to create the +/// decompressor std::streambuf for. +/// +/// @param compr the compression scheme kind. +/// +/// @return a pointer to the std::streambuf to use for decompression. +/// If the compression scheme is not supported, the function returns +/// nil. +static shared_ptr +get_decompressed_streambuf(std::istream& compressed_input, + compression_kind compr) +{ + shared_ptr result; + + switch(compr) + { + case COMPRESSION_KIND_UNKNOWN: + ABG_ASSERT_NOT_REACHED; + break; + + case COMPRESSION_KIND_XZ: + shared_ptr r(new xz_decompressor_type(compressed_input)); + result = r; + break; + }; + + return result; +};// end struct compression_handler_type + /// Guess the type of the content of an file. /// /// @param file_path the path to the file to consider. @@ -1702,9 +1781,57 @@ guess_file_type(const string& file_path) || string_ends_with(file_path, ".tz")) return FILE_TYPE_TAR; - ifstream in(file_path.c_str(), ifstream::binary); - file_type r = guess_file_type(in); - in.close(); + file_type r = FILE_TYPE_UNKNOWN; + compression_kind compr_kind = COMPRESSION_KIND_UNKNOWN; + shared_ptr decompressor_streambuf; + + if (string_ends_with(file_path, ".lzma") + || string_ends_with(file_path, ".lz") + || string_ends_with(file_path, ".xz")) + compr_kind = COMPRESSION_KIND_XZ; + // else if there are other compression schemes supported, recognize + // their file suffix here! + + do + { + shared_ptr input_fstream(new ifstream(file_path.c_str(), + ifstream::binary)); + shared_ptr input_stream = input_fstream; + + if (compr_kind != COMPRESSION_KIND_UNKNOWN) + decompressor_streambuf = get_decompressed_streambuf(*input_stream, + compr_kind); + + if (decompressor_streambuf) + input_stream.reset(new istream(decompressor_streambuf.get())); + + r = guess_file_type(*input_stream); + + input_fstream->close(); + + if (!decompressor_streambuf) + { + // So we haven't attempted to decompress the input stream. + // + // Have we found out that it was compressed nonetheless? + compr_kind = is_compressed_file_type(r); + if (compr_kind) + { + // yes, we found out the input file is compressed, so we + // do have the means to decompress it. However, we + // haven't yet gotten the de-compressor; that might be + // because we detected the compression just by looking + // at the file name suffix. Let's go back to calling + // get_decompressed_streambuf again to get the + // decompressor. + ; + } + else + // No the file is not compressed let's get out of here. + break; + } + } while (!decompressor_streambuf && compr_kind); + return r; } @@ -3288,6 +3415,115 @@ create_best_elf_based_reader(const string& elf_file_path, return result; } +/// --------------------------------------------------- +/// +///---------------------------------------------------- + +/// The private data of the @ref xz_decompressor_type class. +struct xz_decompressor_type::priv +{ + std::istream& xz_istream; + lzma_stream lzma; + // A 10k bytes buffer for xz data coming from the + // xz'ed istream. That buffer is going to be fed into the lzma + // decoding machinery. + char inbuf[1024 * 10] = {}; + // A 10k bytes buffer for decompressed data coming + // out of the lzma machinery + char outbuf[1024 * 10] = {}; + + priv(std::istream& i) + : xz_istream(i), + lzma(LZMA_STREAM_INIT) + {} +};// end xz_decompressor_type::priv + +/// Constructor of the @ref xz_decompressor_type class. +/// +/// @param xz_istream the input stream containing the xz-compressed +/// data to decompress. +xz_decompressor_type::xz_decompressor_type(std::istream& xz_istream) + : priv_(new priv(xz_istream)) +{ + // Initialize the native LZMA stream to decompress. + lzma_ret status = lzma_stream_decoder(&priv_->lzma, + UINT64_MAX, + LZMA_CONCATENATED); + ABG_ASSERT(status == LZMA_OK); +} + +/// Destructor of the @ref xz_decompressor_type class. +xz_decompressor_type::~xz_decompressor_type() +{ + lzma_end(&priv_->lzma); +} + +/// The implementation of the virtual protected +/// std:streambuf::underlying method. This method is invoked by the +/// std::streambuf facility to re-fill its internals buffers with data +/// coming from the associated input stream and to update the gptr() +/// and egptr() pointers by using the std::streambuf::setg method. +/// +/// This is where the decompression using the lzma library is +/// performed. +std::streambuf::int_type +xz_decompressor_type::underflow() +{ + if (gptr() < egptr()) + return *gptr(); + + // Let's read 'nr' bytes of xz data into inbuf + priv_->xz_istream.read(priv_->inbuf, sizeof(priv_->inbuf)); + size_t nr = priv_->xz_istream.gcount(); + if (nr == 0) + { + // Tell the lzma machinery that we've reached the end of the + // data. + lzma_ret result = lzma_code(&priv_->lzma, LZMA_FINISH); + ABG_ASSERT(result == LZMA_OK || result == LZMA_STREAM_END); + return EOF; + } + + // Let's prepare the lzma input/output stream/machinery. + priv_->lzma.avail_in = nr; + priv_->lzma.next_in = reinterpret_cast(priv_->inbuf); + + priv_->lzma.avail_out = sizeof(priv_->outbuf); + priv_->lzma.next_out = reinterpret_cast(priv_->outbuf); + + // Let's now ask the lzma machinery to decompress the inbuf and + // put the result into outbuf. + lzma_ret result = lzma_code(&priv_->lzma, LZMA_RUN); + if (result != LZMA_OK && result != LZMA_STREAM_END) + { + // TODO: list the possible error codes and tell them explicitely + // to the user, just like what is done in + // https://github.com/tukaani-project/xz/blob/master/doc/examples/02_decompress.c. + std::ostringstream o; + o << "LZMA decompression failed;" + << " return code of lzma_code() is : " + << result; + throw std::runtime_error(o.str()); + } + + // Let's get the number of bytes decompressed by the lzma + // machinery. I got this from the example in the xz code base at + // https://github.com/tukaani-project/xz/blob/master/doc/examples/02_decompress.c. + size_t nr_decompressed_bytes = sizeof(priv_->outbuf) - priv_->lzma.avail_out; + + // Now set the relevant index pointers of this streambuf. + setg(priv_->outbuf, priv_->outbuf, priv_->outbuf + nr_decompressed_bytes); + + if (nr_decompressed_bytes > 0) + return *gptr(); + + return EOF; +} + +/// --------------------------------------------------- +/// +///---------------------------------------------------- + }//end namespace tools_utils using abigail::ir::function_decl; diff --git a/tests/data/Makefile.am b/tests/data/Makefile.am index 91b8bdbd..eee5e2b2 100644 --- a/tests/data/Makefile.am +++ b/tests/data/Makefile.am @@ -29,6 +29,8 @@ test-read-write/test25.xml \ test-read-write/test26.xml \ test-read-write/test27.xml \ test-read-write/test28.xml \ +test-read-write/test28.xml.xz \ +test-read-write/test28.xml.xzed \ test-read-write/test28-drop-std-fns.abignore \ test-read-write/test28-without-std-fns.xml \ test-read-write/test28-without-std-fns-ref.xml \ @@ -714,14 +716,16 @@ test-read-common/PR27700/test-PR27700.c \ test-read-common/PR27700/test-PR27700.o \ \ test-read-dwarf/test0 \ -test-read-dwarf/test0.abi \ +test-read-dwarf/test0.xzbinary \ +test-read-dwarf/test0.xz \ +test-read-dwarf/test0.abi \ test-read-dwarf/test0.hash.abi \ -test-read-dwarf/test0.cc \ +test-read-dwarf/test0.cc \ test-read-dwarf/test1 \ -test-read-dwarf/test1.abi \ +test-read-dwarf/test1.abi \ test-read-dwarf/test1.hash.abi \ -test-read-dwarf/test1.cc \ -test-read-dwarf/test2.h \ +test-read-dwarf/test1.cc \ +test-read-dwarf/test2.h \ test-read-dwarf/test2-0.cc \ test-read-dwarf/test2-1.cc \ test-read-dwarf/test2.so \ diff --git a/tests/data/test-read-dwarf/test0.xz b/tests/data/test-read-dwarf/test0.xz new file mode 100755 index 0000000000000000000000000000000000000000..95d6ab45e24becda925c48ac1e7d1d4901e38ec2 GIT binary patch literal 3140 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 literal 0 HcmV?d00001 diff --git a/tests/data/test-read-dwarf/test0.xzbinary b/tests/data/test-read-dwarf/test0.xzbinary diff --git a/tests/data/test-read-write/test28.xml.xz b/tests/data/test-read-write/test28.xml.xz new file mode 100644 index 0000000000000000000000000000000000000000..2f48c6d00fc7a2e7a57b06c5ae47598849218cae GIT binary patch literal 4244 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