diff --git a/Android.bp b/Android.bp index 3d042d8..c0d3498 100644 --- a/Android.bp +++ b/Android.bp @@ -41,12 +41,15 @@ cc_library_static { srcs: [ "bspatch.cc", + "bz2_decompressor.cc", "buffer_file.cc", "extents.cc", "extents_file.cc", "file.cc", "memory_file.cc", + "patch_reader.cc", "sink_file.cc", + "utils.cc", ], } @@ -105,6 +108,7 @@ cc_test { "diff_encoder_unittest.cc", "extents_file_unittest.cc", "extents_unittest.cc", + "patch_reader_unittest.cc", "patch_writer_unittest.cc", "split_patch_writer_unittest.cc", "suffix_array_index_unittest.cc", diff --git a/Makefile b/Makefile index c3ecc85..f32bba1 100644 --- a/Makefile +++ b/Makefile @@ -43,12 +43,15 @@ bsdiff_src_files := \ # "bspatch" program. bspatch_src_files := \ bspatch.cc \ + bz2_decompressor.cc \ buffer_file.cc \ extents.cc \ extents_file.cc \ file.cc \ memory_file.cc \ - sink_file.cc + patch_reader.cc \ + sink_file.cc \ + utils.cc # Unit test files. bsdiff_common_unittests := \ @@ -57,6 +60,7 @@ bsdiff_common_unittests := \ diff_encoder_unittest.cc \ extents_file_unittest.cc \ extents_unittest.cc \ + patch_reader_unittest.cc \ patch_writer_unittest.cc \ split_patch_writer_unittest.cc \ suffix_array_index_unittest.cc \ diff --git a/bsdiff.gyp b/bsdiff.gyp index cc81588..fcb1d7c 100644 --- a/bsdiff.gyp +++ b/bsdiff.gyp @@ -31,12 +31,15 @@ 'variables': { 'bspatch_sources': [ 'bspatch.cc', + 'bz2_decompressor.cc', 'buffer_file.cc', 'extents.cc', 'extents_file.cc', 'file.cc', 'memory_file.cc', + 'patch_reader.cc', 'sink_file.cc', + 'utils.cc', ], }, 'targets': [ @@ -132,6 +135,7 @@ 'diff_encoder_unittest.cc', 'extents_file_unittest.cc', 'extents_unittest.cc', + 'patch_reader_unittest.cc', 'patch_writer_unittest.cc', 'split_patch_writer_unittest.cc', 'suffix_array_index_unittest.cc', diff --git a/bspatch.cc b/bspatch.cc index 50c870f..491fc01 100644 --- a/bspatch.cc +++ b/bspatch.cc @@ -30,7 +30,6 @@ __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59: #include "bsdiff/bspatch.h" -#include #include #include #include @@ -41,75 +40,42 @@ __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59: #include #include -#include #include #include #include "bsdiff/buffer_file.h" +#include "bsdiff/control_entry.h" #include "bsdiff/extents.h" #include "bsdiff/extents_file.h" #include "bsdiff/file.h" #include "bsdiff/file_interface.h" #include "bsdiff/memory_file.h" +#include "bsdiff/patch_reader.h" #include "bsdiff/sink_file.h" +#include "bsdiff/utils.h" namespace { - -int64_t ParseInt64(const u_char* buf) { - int64_t y; - - y = buf[7] & 0x7F; - y = y * 256; - y += buf[6]; - y = y * 256; - y += buf[5]; - y = y * 256; - y += buf[4]; - y = y * 256; - y += buf[3]; - y = y * 256; - y += buf[2]; - y = y * 256; - y += buf[1]; - y = y * 256; - y += buf[0]; - - if (buf[7] & 0x80) - y = -y; - - return y; -} - -bool ReadBZ2(bz_stream* stream, uint8_t* data, size_t size) { - stream->next_out = (char*)data; +// Read the data in |stream| and write |size| decompressed data to |file|; +// using the buffer in |buf| with size |buf_size|. +// Returns 0 on success, 1 on I/O error and 2 on data error. +int ReadStreamAndWriteAll( + const std::unique_ptr& file, + size_t size, + uint8_t* buf, + size_t buf_size, + const std::function& read_func) { while (size > 0) { - unsigned int read_size = std::min( - static_cast(std::numeric_limits::max()), size); - stream->avail_out = read_size; - int bz2err = BZ2_bzDecompress(stream); - if (bz2err != BZ_OK && bz2err != BZ_STREAM_END) - return false; - size -= read_size - stream->avail_out; - } - return true; -} - -int ReadBZ2AndWriteAll(const std::unique_ptr& file, - bz_stream* stream, - size_t size, - uint8_t* buf, - size_t buf_size) { - while (size > 0) { - size_t bytes_to_read = std::min(size, buf_size); - if (!ReadBZ2(stream, buf, bytes_to_read)) { - fprintf(stderr, "Failed to read bzip stream.\n"); + size_t bytes_to_output = std::min(size, buf_size); + if (!read_func(buf, bytes_to_output)) { + fprintf(stderr, "Failed to read stream.\n"); return 2; } - if (!WriteAll(file, buf, bytes_to_read)) { + + if (!WriteAll(file, buf, bytes_to_output)) { perror("WriteAll() failed"); return 1; } - size -= bytes_to_read; + size -= bytes_to_output; } return 0; } @@ -282,76 +248,14 @@ int bspatch(const std::unique_ptr& old_file, const std::unique_ptr& new_file, const uint8_t* patch_data, size_t patch_size) { - int bz2err; - u_char buf[8]; - off_t ctrl[3]; - - // File format: - // 0 8 "BSDIFF40" - // 8 8 X - // 16 8 Y - // 24 8 sizeof(new_filename) - // 32 X bzip2(control block) - // 32+X Y bzip2(diff block) - // 32+X+Y ??? bzip2(extra block) - // with control block a set of triples (x,y,z) meaning "add x bytes - // from oldfile to x bytes from the diff block; copy y bytes from the - // extra block; seek forwards in oldfile by z bytes". - - // Check for appropriate magic. - if (memcmp(patch_data, "BSDIFF40", 8) != 0) { - fprintf(stderr, "Not a bsdiff patch.\n"); + BsdiffPatchReader patch_reader; + if (!patch_reader.Init(patch_data, patch_size)) { + fprintf(stderr, "Failed to initialize patch reader\n"); return 2; } - // Read lengths from header. - uint64_t oldsize, newsize; - int64_t ctrl_len = ParseInt64(patch_data + 8); - int64_t data_len = ParseInt64(patch_data + 16); - int64_t signed_newsize = ParseInt64(patch_data + 24); - newsize = signed_newsize; - if ((ctrl_len < 0) || (data_len < 0) || (signed_newsize < 0) || - (32 + ctrl_len + data_len > static_cast(patch_size))) { - fprintf(stderr, "Corrupt patch.\n"); - return 2; - } - - bz_stream cstream; - cstream.next_in = (char*)patch_data + 32; - cstream.avail_in = ctrl_len; - cstream.bzalloc = nullptr; - cstream.bzfree = nullptr; - cstream.opaque = nullptr; - if ((bz2err = BZ2_bzDecompressInit(&cstream, 0, 0)) != BZ_OK) { - fprintf(stderr, "Failed to bzinit control stream (%d)\n", bz2err); - return 2; - } - - bz_stream dstream; - dstream.next_in = (char*)patch_data + 32 + ctrl_len; - dstream.avail_in = data_len; - dstream.bzalloc = nullptr; - dstream.bzfree = nullptr; - dstream.opaque = nullptr; - if ((bz2err = BZ2_bzDecompressInit(&dstream, 0, 0)) != BZ_OK) { - fprintf(stderr, "Failed to bzinit diff stream (%d)\n", bz2err); - return 2; - } - - bz_stream estream; - estream.next_in = (char*)patch_data + 32 + ctrl_len + data_len; - estream.avail_in = patch_size - (32 + ctrl_len + data_len); - estream.bzalloc = nullptr; - estream.bzfree = nullptr; - estream.opaque = nullptr; - if ((bz2err = BZ2_bzDecompressInit(&estream, 0, 0)) != BZ_OK) { - fprintf(stderr, "Failed to bzinit extra stream (%d)\n", bz2err); - return 2; - } - - uint64_t old_file_pos = 0; - - if (!old_file->GetSize(&oldsize)) { + uint64_t old_file_size; + if (!old_file->GetSize(&old_file_size)) { fprintf(stderr, "Cannot obtain the size of old file.\n"); return 1; } @@ -359,26 +263,18 @@ int bspatch(const std::unique_ptr& old_file, // The oldpos can be negative, but the new pos is only incremented linearly. int64_t oldpos = 0; uint64_t newpos = 0; - std::vector old_buf(1024 * 1024), new_buf(1024 * 1024); - while (newpos < newsize) { - int64_t i; - // Read control data. - for (i = 0; i <= 2; i++) { - if (!ReadBZ2(&cstream, buf, 8)) { - fprintf(stderr, "Failed to read control stream.\n"); - return 2; - } - ctrl[i] = ParseInt64(buf); - } - - // Sanity-check. - if (ctrl[0] < 0 || ctrl[1] < 0) { - fprintf(stderr, "Corrupt patch.\n"); + std::vector old_buf(1024 * 1024); + std::vector new_buf(1024 * 1024); + uint64_t old_file_pos = 0; + while (newpos < patch_reader.new_file_size()) { + ControlEntry control_entry(0, 0, 0); + if (!patch_reader.ParseControlEntry(&control_entry)) { + fprintf(stderr, "Failed to read control stream\n"); return 2; } // Sanity-check. - if (newpos + ctrl[0] > newsize) { + if (newpos + control_entry.diff_size > patch_reader.new_file_size()) { fprintf(stderr, "Corrupt patch.\n"); return 2; } @@ -386,26 +282,30 @@ int bspatch(const std::unique_ptr& old_file, int ret = 0; // Add old data to diff string. It is enough to fseek once, at // the beginning of the sequence, to avoid unnecessary overhead. - if ((i = oldpos) < 0) { + int64_t seek_offset = oldpos; + if (seek_offset < 0) { // Write diff block directly to new file without adding old data, // because we will skip part where |oldpos| < 0. - ret = ReadBZ2AndWriteAll(new_file, &dstream, -i, new_buf.data(), - new_buf.size()); + ret = ReadStreamAndWriteAll( + new_file, oldpos - old_file_size, new_buf.data(), new_buf.size(), + std::bind(&BsdiffPatchReader::ReadDiffStream, &patch_reader, + std::placeholders::_1, std::placeholders::_2)); if (ret) return ret; - i = 0; + seek_offset = 0; } - // We just checked that |i| is not negative. - if (static_cast(i) != old_file_pos && !old_file->Seek(i)) { - fprintf(stderr, "Error seeking input file to offset %" PRId64 ": %s\n", i, - strerror(errno)); + // We just checked that |seek_offset| is not negative. + if (static_cast(seek_offset) != old_file_pos && + !old_file->Seek(seek_offset)) { + fprintf(stderr, "Error seeking input file to offset %" PRId64 ": %s\n", + seek_offset, strerror(errno)); return 1; } - if ((old_file_pos = oldpos + ctrl[0]) > oldsize) - old_file_pos = oldsize; - size_t chunk_size = old_file_pos - i; + old_file_pos = + std::min(oldpos + control_entry.diff_size, old_file_size); + size_t chunk_size = old_file_pos - seek_offset; while (chunk_size > 0) { size_t read_bytes; size_t bytes_to_read = std::min(chunk_size, old_buf.size()); @@ -418,7 +318,7 @@ int bspatch(const std::unique_ptr& old_file, return 2; } // Read same amount of bytes from diff block - if (!ReadBZ2(&dstream, new_buf.data(), read_bytes)) { + if (!patch_reader.ReadDiffStream(new_buf.data(), read_bytes)) { fprintf(stderr, "Failed to read diff stream.\n"); return 2; } @@ -433,42 +333,46 @@ int bspatch(const std::unique_ptr& old_file, } // Adjust pointers. - newpos += ctrl[0]; - oldpos += ctrl[0]; + newpos += control_entry.diff_size; + oldpos += control_entry.diff_size; - if (oldpos > static_cast(oldsize)) { + if (oldpos > static_cast(old_file_size)) { // Write diff block directly to new file without adding old data, - // because we skipped part where |oldpos| > oldsize. - ret = ReadBZ2AndWriteAll(new_file, &dstream, oldpos - oldsize, - new_buf.data(), new_buf.size()); + // because we skipped part where |oldpos| > old_file_size. + ret = ReadStreamAndWriteAll( + new_file, oldpos - old_file_size, new_buf.data(), new_buf.size(), + std::bind(&BsdiffPatchReader::ReadDiffStream, &patch_reader, + std::placeholders::_1, std::placeholders::_2)); if (ret) return ret; } // Sanity-check. - if (newpos + ctrl[1] > newsize) { + if (newpos + control_entry.extra_size > patch_reader.new_file_size()) { fprintf(stderr, "Corrupt patch.\n"); return 2; } // Read extra block. - ret = ReadBZ2AndWriteAll(new_file, &estream, ctrl[1], new_buf.data(), - new_buf.size()); + ret = ReadStreamAndWriteAll( + new_file, control_entry.extra_size, new_buf.data(), new_buf.size(), + std::bind(&BsdiffPatchReader::ReadExtraStream, &patch_reader, + std::placeholders::_1, std::placeholders::_2)); if (ret) return ret; // Adjust pointers. - newpos += ctrl[1]; - oldpos += ctrl[2]; + newpos += control_entry.extra_size; + oldpos += control_entry.offset_increment; } // Close input file. old_file->Close(); - // Clean up the bzip2 reads. - BZ2_bzDecompressEnd(&cstream); - BZ2_bzDecompressEnd(&dstream); - BZ2_bzDecompressEnd(&estream); + if (!patch_reader.Finish()) { + fprintf(stderr, "Failed to finish the patch reader\n"); + return 2; + } if (!new_file->Close()) { perror("Error closing new file"); diff --git a/bz2_decompressor.cc b/bz2_decompressor.cc new file mode 100644 index 0000000..99ecd71 --- /dev/null +++ b/bz2_decompressor.cc @@ -0,0 +1,65 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "bsdiff/bz2_decompressor.h" + +#include +#include + +#include + +#include "bsdiff/logging.h" + +using std::endl; + +namespace bsdiff { + +bool BZ2Decompressor::SetInputData(const uint8_t* input_data, size_t size) { + // TODO(xunchang) update the avail_in for size > 2GB. + if (size > std::numeric_limits::max()) { + LOG(ERROR) << "Oversized input data" << size << endl; + return false; + } + + stream_.next_in = reinterpret_cast(const_cast(input_data)); + stream_.avail_in = size; + stream_.bzalloc = nullptr; + stream_.bzfree = nullptr; + stream_.opaque = nullptr; + int bz2err = BZ2_bzDecompressInit(&stream_, 0, 0); + if (bz2err != BZ_OK) { + LOG(ERROR) << "Failed to bzinit control stream: " << bz2err << endl; + return false; + } + return true; +} + +bool BZ2Decompressor::Read(uint8_t* output_data, size_t bytes_to_output) { + stream_.next_out = reinterpret_cast(output_data); + while (bytes_to_output > 0) { + size_t output_size = std::min( + std::numeric_limits::max(), bytes_to_output); + stream_.avail_out = output_size; + + int bz2err = BZ2_bzDecompress(&stream_); + if (bz2err != BZ_OK && bz2err != BZ_STREAM_END) { + LOG(ERROR) << "Failed to decompress " << output_size + << " bytes of data, error: " << bz2err << endl; + return false; + } + bytes_to_output -= (output_size - stream_.avail_out); + } + return true; +} + +bool BZ2Decompressor::Close() { + int bz2err = BZ2_bzDecompressEnd(&stream_); + if (bz2err != BZ_OK) { + LOG(ERROR) << "BZ2_bzDecompressEnd returns with " << bz2err << endl; + return false; + } + return true; +} + +} // namespace bsdiff \ No newline at end of file diff --git a/bz2_decompressor.h b/bz2_decompressor.h new file mode 100644 index 0000000..4b698ce --- /dev/null +++ b/bz2_decompressor.h @@ -0,0 +1,30 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef _BSDIFF_BZ2_DECOMPRESSOR_H_ +#define _BSDIFF_BZ2_DECOMPRESSOR_H_ + +#include + +#include "bsdiff/decompressor_interface.h" + +namespace bsdiff { + +class BZ2Decompressor : public DecompressorInterface { + public: + BZ2Decompressor() = default; + + bool SetInputData(const uint8_t* input_data, size_t size) override; + + bool Read(uint8_t* output_data, size_t bytes_to_output) override; + + bool Close() override; + + private: + bz_stream stream_; +}; + +} // namespace bsdiff + +#endif \ No newline at end of file diff --git a/decompressor_interface.h b/decompressor_interface.h new file mode 100644 index 0000000..c072dbf --- /dev/null +++ b/decompressor_interface.h @@ -0,0 +1,32 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef _BSDIFF_DECOMPRESSOR_INTERFACE_H_ +#define _BSDIFF_DECOMPRESSOR_INTERFACE_H_ + +#include +#include + +namespace bsdiff { + +class DecompressorInterface { + public: + virtual ~DecompressorInterface() {} + + // Set the buffer starting from |input_data| with length |size| as the input + // compressed stream. This buffer is owned by the caller and should stay + // valid until the Close() function is called. + virtual bool SetInputData(const uint8_t* input_data, size_t size) = 0; + + // Decompress the stream and output |bytes_to_output| bytes of data to + // |output_data|. Returns false if not all bytes_to_output can be + // decompressed from the stream due to a decompressor error or EOF. + virtual bool Read(uint8_t* output_data, size_t bytes_to_output) = 0; + + // Close the decompression stream. + virtual bool Close() = 0; +}; + +} // namespace bsdiff +#endif // _BSDIFF_DECOMPRESSOR_INTERFACE_H_ diff --git a/include/bsdiff/control_entry.h b/include/bsdiff/control_entry.h new file mode 100644 index 0000000..2c849f6 --- /dev/null +++ b/include/bsdiff/control_entry.h @@ -0,0 +1,33 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef _BSDIFF_CONTROL_ENTRY_H_ +#define _BSDIFF_CONTROL_ENTRY_H_ + +#include + +struct ControlEntry { + ControlEntry(uint64_t diff_size, + uint64_t extra_size, + int64_t offset_increment) + : diff_size(diff_size), + extra_size(extra_size), + offset_increment(offset_increment) {} + + // The number of bytes to copy from the source and diff stream. + uint64_t diff_size; + + // The number of bytes to copy from the extra stream. + uint64_t extra_size; + + // The value to add to the source pointer after patching from the diff stream. + int64_t offset_increment; + + bool operator==(const ControlEntry& o) const { + return diff_size == o.diff_size && extra_size == o.extra_size && + offset_increment == o.offset_increment; + } +}; + +#endif // _BSDIFF_CONTROL_ENTRY_H_ diff --git a/include/bsdiff/patch_writer_interface.h b/include/bsdiff/patch_writer_interface.h index 04f1675..45d2cf0 100644 --- a/include/bsdiff/patch_writer_interface.h +++ b/include/bsdiff/patch_writer_interface.h @@ -9,31 +9,10 @@ #include +#include "bsdiff/control_entry.h" + namespace bsdiff { -struct ControlEntry { - ControlEntry(uint64_t diff_size, - uint64_t extra_size, - int64_t offset_increment) - : diff_size(diff_size), - extra_size(extra_size), - offset_increment(offset_increment) {} - - // The number of bytes to copy from the source and diff stream. - uint64_t diff_size; - - // The number of bytes to copy from the extra stream. - uint64_t extra_size; - - // The value to add to the source pointer after patching from the diff stream. - int64_t offset_increment; - - bool operator==(const ControlEntry& o) const { - return diff_size == o.diff_size && extra_size == o.extra_size && - offset_increment == o.offset_increment; - } -}; - class PatchWriterInterface { public: virtual ~PatchWriterInterface() = default; diff --git a/patch_reader.cc b/patch_reader.cc new file mode 100644 index 0000000..ee9e9c4 --- /dev/null +++ b/patch_reader.cc @@ -0,0 +1,141 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "bsdiff/patch_reader.h" + +#include + +#include + +#include "bsdiff/bspatch.h" +#include "bsdiff/bz2_decompressor.h" +#include "bsdiff/logging.h" +#include "bsdiff/utils.h" + +using std::endl; + +namespace bsdiff { + +const uint8_t kMagicHeader[] = "BSDIFF40"; + +bool BsdiffPatchReader::Init(const uint8_t* patch_data, size_t patch_size) { + // File format: + // 0 8 "BSDIFF40" + // 8 8 X + // 16 8 Y + // 24 8 new_file_size + // 32 X compressed control block + // 32+X Y compressed diff block + // 32+X+Y ??? compressed extra block + // with control block a set of triples (x,y,z) meaning "add x bytes + // from oldfile to x bytes from the diff block; copy y bytes from the + // extra block; seek forwards in oldfile by z bytes". + + // Check for appropriate magic. + if (memcmp(patch_data, kMagicHeader, 8) != 0) { + LOG(ERROR) << "Not a bsdiff patch." << endl; + return false; + } + + // Read lengths from header. + int64_t ctrl_len = ParseInt64(patch_data + 8); + int64_t diff_len = ParseInt64(patch_data + 16); + int64_t signed_newsize = ParseInt64(patch_data + 24); + if ((ctrl_len < 0) || (diff_len < 0) || (signed_newsize < 0) || + (32 + ctrl_len + diff_len > static_cast(patch_size))) { + LOG(ERROR) << "Corrupt patch. ctrl_len: " << ctrl_len + << ", data_len: " << diff_len + << ", new_file_size: " << signed_newsize + << ", patch_size: " << patch_size; + return false; + } + new_file_size_ = signed_newsize; + + // TODO(xunchang) set the correct decompressor based on the info in the + // header. + ctrl_stream_.reset(new BZ2Decompressor()); + diff_stream_.reset(new BZ2Decompressor()); + extra_stream_.reset(new BZ2Decompressor()); + + int64_t offset = 32; + if (!ctrl_stream_->SetInputData(const_cast(patch_data) + offset, + ctrl_len)) { + LOG(ERROR) << "Failed to init ctrl stream, ctrl_len: " << ctrl_len << endl; + return false; + } + + offset += ctrl_len; + if (!diff_stream_->SetInputData(const_cast(patch_data) + offset, + diff_len)) { + LOG(ERROR) << "Failed to init ctrl stream, diff_len: " << diff_len << endl; + return false; + } + + offset += diff_len; + if (!extra_stream_->SetInputData(const_cast(patch_data) + offset, + patch_size - offset)) { + LOG(ERROR) << "Failed to init extra stream, extra_offset: " << offset + << ", patch_size: " << patch_size << endl; + return false; + } + return true; +} + +bool BsdiffPatchReader::ParseControlEntry(ControlEntry* control_entry) { + if (!control_entry) + return false; + + uint8_t buf[8]; + if (!ctrl_stream_->Read(buf, 8)) + return false; + int64_t diff_size = ParseInt64(buf); + + if (!ctrl_stream_->Read(buf, 8)) + return false; + int64_t extra_size = ParseInt64(buf); + + // Sanity check. + if (diff_size < 0 || extra_size < 0) { + LOG(ERROR) << "Corrupt patch; diff_size: " << diff_size + << ", extra_size: " << extra_size << endl; + return false; + } + + control_entry->diff_size = diff_size; + control_entry->extra_size = extra_size; + + if (!ctrl_stream_->Read(buf, 8)) + return false; + control_entry->offset_increment = ParseInt64(buf); + + return true; +} + +bool BsdiffPatchReader::ReadDiffStream(uint8_t* buf, size_t size) { + return diff_stream_->Read(buf, size); +} + +bool BsdiffPatchReader::ReadExtraStream(uint8_t* buf, size_t size) { + return extra_stream_->Read(buf, size); +} + +bool BsdiffPatchReader::Finish() { + if (!ctrl_stream_->Close()) { + LOG(ERROR) << "Failed to close the control stream"; + return false; + } + + if (!diff_stream_->Close()) { + LOG(ERROR) << "Failed to close the diff stream"; + return false; + } + + if (!extra_stream_->Close()) { + LOG(ERROR) << "Failed to close the extra stream"; + return false; + } + return true; +} + +} // namespace bsdiff diff --git a/patch_reader.h b/patch_reader.h new file mode 100644 index 0000000..ea287d3 --- /dev/null +++ b/patch_reader.h @@ -0,0 +1,68 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef _BSDIFF_PATCH_READER_H_ +#define _BSDIFF_PATCH_READER_H_ + +#include +#include + +#include + +#include "bsdiff/control_entry.h" +#include "bsdiff/decompressor_interface.h" +#include "bsdiff/file_interface.h" + +namespace bsdiff { + +extern const uint8_t kMagicHeader[]; + +// A wrapper class to read and parse the data in a bsdiff patch. The reader +// class contains the concatenated streams of control, diff, and extra data. +// After initialization, this class provides the function to read the metadata +// embedded in the control stream sequentially and decompresses the diff & extra +// stream based on this metadata. + +class BsdiffPatchReader { + public: + BsdiffPatchReader() = default; + + // Initialize the control stream, diff stream and extra stream from the + // corresponding offset of |patch_data|. + bool Init(const uint8_t* data_start, size_t patch_size); + + // Read the control stream and parse the metadata of |diff_size_|, + // |extra_size_| and |offset_incremental_|. + bool ParseControlEntry(ControlEntry* control_entry); + + // Read the data in |diff_stream_| and write |size| decompressed data to + // |buf|. + bool ReadDiffStream(uint8_t* buf, size_t size); + + // Read the data in |extra_stream_| and write |size| decompressed data to + // |buf|. + bool ReadExtraStream(uint8_t* buf, size_t size); + + uint64_t new_file_size() const { return new_file_size_; } + + // Close the control/diff/extra stream. Return false if errors occur when + // closing any of these streams. + bool Finish(); + + private: + // The compressed stream that contains the control data; i.e. length of each + // diff/extra block and the corresponding offset to read in the source file. + std::unique_ptr ctrl_stream_{nullptr}; + // The compressed stream that contains the concatenated diff blocks. + std::unique_ptr diff_stream_{nullptr}; + // The compressed stream that contains the concatenated extra blocks. + std::unique_ptr extra_stream_{nullptr}; + + // Size of the target file. + uint64_t new_file_size_; +}; + +} // namespace bsdiff + +#endif // _BSDIFF_PATCH_READER_H_ diff --git a/patch_reader_unittest.cc b/patch_reader_unittest.cc new file mode 100644 index 0000000..85fae28 --- /dev/null +++ b/patch_reader_unittest.cc @@ -0,0 +1,96 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include + +#include +#include +#include + +#include + +#include "bsdiff/bz2_compressor.h" +#include "bsdiff/patch_reader.h" +#include "bsdiff/utils.h" + +namespace { + +void EncodeInt64(int64_t x, uint8_t* buf) { + uint64_t y = x < 0 ? (1ULL << 63ULL) - x : x; + for (int i = 0; i < 8; ++i) { + buf[i] = y & 0xff; + y /= 256; + } +} + +} // namespace + +namespace bsdiff { + +TEST(PatchReaderTest, BZ2PatchReaderSmoke) { + BZ2Compressor ctrl_stream; + BZ2Compressor diff_stream; + BZ2Compressor extra_stream; + + // Write 3 blocks of data to diff stream & extra stream respectively. + std::vector diff_data = {"HelloWorld", "BspatchPatchTest", + "BspatchDiffData"}; + std::vector extra_data = {"HelloWorld!", "BZ2PatchReaderSmoke", + "BspatchExtraData"}; + std::vector offset_increment = {100, 200, 300}; + for (size_t i = 0; i < diff_data.size(); i++) { + uint8_t buf[24]; + EncodeInt64(diff_data[i].size(), buf); + EncodeInt64(extra_data[i].size(), buf + 8); + EncodeInt64(offset_increment[i], buf + 16); + EXPECT_TRUE(ctrl_stream.Write(buf, sizeof(buf))); + EXPECT_TRUE( + diff_stream.Write(reinterpret_cast(diff_data[i].data()), + diff_data[i].size())); + EXPECT_TRUE(extra_stream.Write( + reinterpret_cast(extra_data[i].data()), + extra_data[i].size())); + } + EXPECT_TRUE(ctrl_stream.Finish()); + EXPECT_TRUE(diff_stream.Finish()); + EXPECT_TRUE(extra_stream.Finish()); + + // Encode the header + uint8_t buf[24]; + EncodeInt64(ctrl_stream.GetCompressedData().size(), buf); + EncodeInt64(diff_stream.GetCompressedData().size(), buf + 8); + EncodeInt64(500, buf + 16); + + std::vector patch_data; + std::copy(kMagicHeader, kMagicHeader + 8, std::back_inserter(patch_data)); + std::copy(buf, buf + sizeof(buf), std::back_inserter(patch_data)); + + // Concatenate the three streams into one patch. + std::copy(ctrl_stream.GetCompressedData().begin(), + ctrl_stream.GetCompressedData().end(), + std::back_inserter(patch_data)); + std::copy(diff_stream.GetCompressedData().begin(), + diff_stream.GetCompressedData().end(), + std::back_inserter(patch_data)); + std::copy(extra_stream.GetCompressedData().begin(), + extra_stream.GetCompressedData().end(), + std::back_inserter(patch_data)); + + BsdiffPatchReader patch_reader; + EXPECT_TRUE(patch_reader.Init(patch_data.data(), patch_data.size())); + EXPECT_EQ(500ull, patch_reader.new_file_size()); + // Check that the decompressed data matches what we wrote. + for (size_t i = 0; i < diff_data.size(); i++) { + ControlEntry control_entry(0, 0, 0); + EXPECT_TRUE(patch_reader.ParseControlEntry(&control_entry)); + uint8_t buffer[128] = {}; + EXPECT_TRUE(patch_reader.ReadDiffStream(buffer, diff_data[i].size())); + EXPECT_EQ(0, memcmp(buffer, diff_data[i].data(), diff_data[i].size())); + EXPECT_TRUE(patch_reader.ReadExtraStream(buffer, extra_data[i].size())); + EXPECT_EQ(0, memcmp(buffer, extra_data[i].data(), extra_data[i].size())); + } + EXPECT_TRUE(patch_reader.Finish()); +} + +} // namespace bsdiff diff --git a/patch_writer.cc b/patch_writer.cc index 4b6abbb..e6eb8ad 100644 --- a/patch_writer.cc +++ b/patch_writer.cc @@ -6,6 +6,7 @@ #include +#include "bsdiff/control_entry.h" #include "bsdiff/logging.h" using std::endl; diff --git a/utils.cc b/utils.cc new file mode 100644 index 0000000..63941f5 --- /dev/null +++ b/utils.cc @@ -0,0 +1,20 @@ +#include + +#include "bsdiff/utils.h" + +namespace bsdiff { + + +int64_t ParseInt64(const uint8_t* buf) { + int64_t result = buf[7] & 0x7F; + for (int i = 6; i >= 0; i--) { + result <<= 8; + result |= buf[i]; + } + + if (buf[7] & 0x80) + result = -result; + return result; +} + +} // namespace bsdiff \ No newline at end of file diff --git a/utils.h b/utils.h new file mode 100644 index 0000000..1ee57c7 --- /dev/null +++ b/utils.h @@ -0,0 +1,16 @@ +// Copyright 2017 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef _BSDIFF_UTILS_H_ +#define _BSDIFF_UTILS_H_ + +#include + +namespace bsdiff { + +int64_t ParseInt64(const uint8_t* buf); + +} // namespace bsdiff + +#endif