@@ -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
@@ -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<char> 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> 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.
@@ -13,6 +13,7 @@
#include "config.h"
#include <elfutils/libdwfl.h>
+#include <elfutils/libdwelf.h>
#include <gelf.h>
#include <string>
@@ -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);
@@ -35,6 +35,7 @@
#include <libgen.h>
#include <libxml/parser.h>
#include <libxml/xmlversion.h>
+#include <lzma.h>
#include <algorithm>
#include <cstdlib>
#include <cstring>
@@ -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<char*>(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<char*>(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<std::streambuf>
+get_decompressed_streambuf(std::istream& compressed_input,
+ compression_kind compr)
+{
+ shared_ptr<std::streambuf> result;
+
+ switch(compr)
+ {
+ case COMPRESSION_KIND_UNKNOWN:
+ ABG_ASSERT_NOT_REACHED;
+ break;
+
+ case COMPRESSION_KIND_XZ:
+ shared_ptr<std::streambuf> 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<std::streambuf> 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<ifstream> input_fstream(new ifstream(file_path.c_str(),
+ ifstream::binary));
+ shared_ptr<istream> 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;
}
+/// ---------------------------------------------------
+/// <xz_decompressor definition>
+///----------------------------------------------------
+
+/// 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<uint8_t*>(priv_->inbuf);
+
+ priv_->lzma.avail_out = sizeof(priv_->outbuf);
+ priv_->lzma.next_out = reinterpret_cast<uint8_t*>(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;
+}
+
+/// ---------------------------------------------------
+/// </xz_decompressor definition>
+///----------------------------------------------------
+
}//end namespace tools_utils
using abigail::ir::function_decl;
@@ -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 \
new file mode 100755
GIT binary patch
literal 3140
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
literal 0
HcmV?d00001
new file mode 100644
GIT binary patch
literal 4244
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
literal 0
HcmV?d00001
@@ -46,6 +46,24 @@ static InOutSpec in_out_specs[] =
"output/test-read-dwarf/test0.abi",
NULL,
},
+ {
+ "data/test-read-dwarf/test0.xz",
+ "",
+ "",
+ SEQUENCE_TYPE_ID_STYLE,
+ "data/test-read-dwarf/test0.abi",
+ "output/test-read-dwarf/test0-xz.abi",
+ NULL,
+ },
+ {
+ "data/test-read-dwarf/test0.xzbinary",
+ "",
+ "",
+ SEQUENCE_TYPE_ID_STYLE,
+ "data/test-read-dwarf/test0.abi",
+ "output/test-read-dwarf/test0-xzbinary.abi",
+ NULL,
+ },
{
"data/test-read-dwarf/test0",
"",
@@ -229,6 +229,18 @@ InOutSpec in_out_specs[] =
"data/test-read-write/test28-without-std-fns-ref.xml",
"output/test-read-write/test28-without-std-fns.xml"
},
+ {
+ "data/test-read-write/test28.xml.xz",
+ "data/test-read-write/test28-drop-std-fns.abignore",
+ "data/test-read-write/test28-without-std-fns-ref.xml",
+ "output/test-read-write/test28-without-std-fns-xz.xml"
+ },
+ {
+ "data/test-read-write/test28.xml.xzed",
+ "data/test-read-write/test28-drop-std-fns.abignore",
+ "data/test-read-write/test28-without-std-fns-ref.xml",
+ "output/test-read-write/test28-without-std-fns-xzed.xml"
+ },
{
"data/test-read-write/test28.xml",
"data/test-read-write/test28-drop-std-vars.abignore",
@@ -899,6 +899,7 @@ read_corpus(options opts,
case abigail::tools_utils::FILE_TYPE_DIR:
case abigail::tools_utils::FILE_TYPE_TAR:
case abigail::tools_utils::FILE_TYPE_NATIVE_BI:
+ case abigail::tools_utils::FILE_TYPE_XZ:
break;
}
@@ -1487,6 +1487,7 @@ main(int argc, char* argv[])
case abigail::tools_utils::FILE_TYPE_DEB:
case abigail::tools_utils::FILE_TYPE_DIR:
case abigail::tools_utils::FILE_TYPE_TAR:
+ case abigail::tools_utils::FILE_TYPE_XZ:
break;
}
@@ -1576,6 +1577,7 @@ main(int argc, char* argv[])
case abigail::tools_utils::FILE_TYPE_DEB:
case abigail::tools_utils::FILE_TYPE_DIR:
case abigail::tools_utils::FILE_TYPE_TAR:
+ case abigail::tools_utils::FILE_TYPE_XZ:
break;
}
@@ -836,14 +836,11 @@ main(int argc, char* argv[])
}
break;
case abigail::tools_utils::FILE_TYPE_RPM:
- break;
case abigail::tools_utils::FILE_TYPE_SRPM:
- break;
case abigail::tools_utils::FILE_TYPE_DEB:
- break;
case abigail::tools_utils::FILE_TYPE_DIR:
- break;
case abigail::tools_utils::FILE_TYPE_TAR:
+ case abigail::tools_utils::FILE_TYPE_XZ:
break;
}