Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 1 | // Copyright 2017 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Alex Deymo | dcd423b | 2017-09-13 20:54:24 +0200 | [diff] [blame] | 5 | #include "bsdiff/patch_writer.h" |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 6 | |
| 7 | #include <string.h> |
| 8 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 9 | #include "bsdiff/brotli_compressor.h" |
| 10 | #include "bsdiff/bz2_compressor.h" |
Tianjie Xu | 4d10c3e | 2017-10-26 14:02:06 -0700 | [diff] [blame] | 11 | #include "bsdiff/constants.h" |
Tianjie Xu | 6528812 | 2017-10-13 15:10:58 -0700 | [diff] [blame] | 12 | #include "bsdiff/control_entry.h" |
Alex Deymo | dcd423b | 2017-09-13 20:54:24 +0200 | [diff] [blame] | 13 | #include "bsdiff/logging.h" |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 14 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 15 | namespace { |
| 16 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 17 | void EncodeInt64(int64_t x, uint8_t* buf) { |
| 18 | uint64_t y = x < 0 ? (1ULL << 63ULL) - x : x; |
| 19 | for (int i = 0; i < 8; ++i) { |
| 20 | buf[i] = y & 0xff; |
| 21 | y /= 256; |
| 22 | } |
| 23 | } |
| 24 | |
| 25 | } // namespace |
| 26 | |
| 27 | namespace bsdiff { |
| 28 | |
Tianjie Xu | 1f1cdb2 | 2017-11-20 11:05:55 -0800 | [diff] [blame] | 29 | BsdiffPatchWriter::BsdiffPatchWriter(const std::string& patch_filename) |
| 30 | : patch_filename_(patch_filename), format_(BsdiffFormat::kLegacy) { |
| 31 | ctrl_stream_.reset(new BZ2Compressor()); |
| 32 | diff_stream_.reset(new BZ2Compressor()); |
| 33 | extra_stream_.reset(new BZ2Compressor()); |
| 34 | } |
| 35 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 36 | BsdiffPatchWriter::BsdiffPatchWriter(const std::string& patch_filename, |
Tianjie Xu | 1f1cdb2 | 2017-11-20 11:05:55 -0800 | [diff] [blame] | 37 | CompressorType type, |
| 38 | int quality) |
| 39 | : patch_filename_(patch_filename), format_(BsdiffFormat::kBsdf2) { |
| 40 | if (type == CompressorType::kBZ2) { |
| 41 | ctrl_stream_.reset(new BZ2Compressor()); |
| 42 | diff_stream_.reset(new BZ2Compressor()); |
| 43 | extra_stream_.reset(new BZ2Compressor()); |
| 44 | } else if (type == CompressorType::kBrotli) { |
| 45 | ctrl_stream_.reset(new BrotliCompressor(quality)); |
| 46 | diff_stream_.reset(new BrotliCompressor(quality)); |
| 47 | extra_stream_.reset(new BrotliCompressor(quality)); |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 48 | } |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 49 | } |
| 50 | |
Alex Deymo | 4dadd8b | 2017-10-26 16:19:33 +0200 | [diff] [blame] | 51 | bool BsdiffPatchWriter::Init(size_t /* new_size */) { |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 52 | if (!(ctrl_stream_ && diff_stream_ && extra_stream_)) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 53 | LOG(ERROR) << "uninitialized compressor stream"; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 54 | return false; |
| 55 | } |
| 56 | |
Alex Deymo | 538a75d | 2017-09-27 15:34:59 +0200 | [diff] [blame] | 57 | fp_ = fopen(patch_filename_.c_str(), "w"); |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 58 | if (!fp_) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 59 | LOG(ERROR) << "Opening " << patch_filename_; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 60 | return false; |
| 61 | } |
| 62 | return true; |
| 63 | } |
| 64 | |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 65 | bool BsdiffPatchWriter::WriteDiffStream(const uint8_t* data, size_t size) { |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 66 | return diff_stream_->Write(data, size); |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | bool BsdiffPatchWriter::WriteExtraStream(const uint8_t* data, size_t size) { |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 70 | return extra_stream_->Write(data, size); |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 71 | } |
| 72 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 73 | bool BsdiffPatchWriter::AddControlEntry(const ControlEntry& entry) { |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 74 | // Generate the 24 byte control entry. |
| 75 | uint8_t buf[24]; |
| 76 | EncodeInt64(entry.diff_size, buf); |
| 77 | EncodeInt64(entry.extra_size, buf + 8); |
| 78 | EncodeInt64(entry.offset_increment, buf + 16); |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 79 | if (!ctrl_stream_->Write(buf, sizeof(buf))) |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 80 | return false; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 81 | written_output_ += entry.diff_size + entry.extra_size; |
| 82 | return true; |
| 83 | } |
| 84 | |
| 85 | bool BsdiffPatchWriter::Close() { |
| 86 | if (!fp_) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 87 | LOG(ERROR) << "File not open."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 88 | return false; |
| 89 | } |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 90 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 91 | if (!ctrl_stream_->Finish() || !diff_stream_->Finish() || |
| 92 | !extra_stream_->Finish()) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 93 | LOG(ERROR) << "Finalizing compressed streams."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 94 | return false; |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 95 | } |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 96 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 97 | auto ctrl_data = ctrl_stream_->GetCompressedData(); |
| 98 | auto diff_data = diff_stream_->GetCompressedData(); |
| 99 | auto extra_data = extra_stream_->GetCompressedData(); |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 100 | |
| 101 | if (!WriteHeader(ctrl_data.size(), diff_data.size())) |
| 102 | return false; |
| 103 | |
| 104 | if (fwrite(ctrl_data.data(), 1, ctrl_data.size(), fp_) != ctrl_data.size()) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 105 | LOG(ERROR) << "Writing ctrl_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 106 | return false; |
| 107 | } |
| 108 | if (fwrite(diff_data.data(), 1, diff_data.size(), fp_) != diff_data.size()) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 109 | LOG(ERROR) << "Writing diff_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 110 | return false; |
| 111 | } |
| 112 | if (fwrite(extra_data.data(), 1, extra_data.size(), fp_) != |
| 113 | extra_data.size()) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 114 | LOG(ERROR) << "Writing extra_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 115 | return false; |
| 116 | } |
| 117 | if (fclose(fp_) != 0) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 118 | LOG(ERROR) << "Closing the patch file."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 119 | return false; |
| 120 | } |
| 121 | fp_ = nullptr; |
| 122 | return true; |
| 123 | } |
| 124 | |
| 125 | bool BsdiffPatchWriter::WriteHeader(uint64_t ctrl_size, uint64_t diff_size) { |
| 126 | /* Header format is |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 127 | * 0 8 magic header |
| 128 | * 8 8 length of compressed ctrl block |
| 129 | * 16 8 length of compressed diff block |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 130 | * 24 8 length of new file |
| 131 | * |
| 132 | * File format is |
| 133 | * 0 32 Header |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 134 | * 32 ?? compressed ctrl block |
| 135 | * ?? ?? compressed diff block |
| 136 | * ?? ?? compressed extra block |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 137 | */ |
| 138 | uint8_t header[32]; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 139 | if (format_ == BsdiffFormat::kLegacy) { |
| 140 | // The magic header is "BSDIFF40" for legacy format. |
| 141 | memcpy(header, kLegacyMagicHeader, 8); |
| 142 | } else if (format_ == BsdiffFormat::kBsdf2) { |
| 143 | // The magic header for BSDF2 format: |
| 144 | // 0 5 BSDF2 |
| 145 | // 5 1 compressed type for control stream |
| 146 | // 6 1 compressed type for diff stream |
| 147 | // 7 1 compressed type for extra stream |
| 148 | memcpy(header, kBSDF2MagicHeader, 5); |
| 149 | header[5] = static_cast<uint8_t>(ctrl_stream_->Type()); |
| 150 | header[6] = static_cast<uint8_t>(diff_stream_->Type()); |
| 151 | header[7] = static_cast<uint8_t>(extra_stream_->Type()); |
| 152 | } else { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 153 | LOG(ERROR) << "Unsupported bsdiff format."; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 154 | return false; |
| 155 | } |
| 156 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 157 | EncodeInt64(ctrl_size, header + 8); |
| 158 | EncodeInt64(diff_size, header + 16); |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 159 | EncodeInt64(written_output_, header + 24); |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 160 | if (fwrite(header, sizeof(header), 1, fp_) != 1) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 161 | LOG(ERROR) << "writing to the patch file"; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 162 | return false; |
| 163 | } |
| 164 | return true; |
| 165 | } |
| 166 | |
| 167 | } // namespace bsdiff |