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> |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 8 | #include <limits> |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 9 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 10 | #include "bsdiff/brotli_compressor.h" |
| 11 | #include "bsdiff/bz2_compressor.h" |
Tianjie Xu | 4d10c3e | 2017-10-26 14:02:06 -0700 | [diff] [blame] | 12 | #include "bsdiff/constants.h" |
Tianjie Xu | 6528812 | 2017-10-13 15:10:58 -0700 | [diff] [blame] | 13 | #include "bsdiff/control_entry.h" |
Alex Deymo | dcd423b | 2017-09-13 20:54:24 +0200 | [diff] [blame] | 14 | #include "bsdiff/logging.h" |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 15 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 16 | namespace { |
| 17 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 18 | void EncodeInt64(int64_t x, uint8_t* buf) { |
| 19 | uint64_t y = x < 0 ? (1ULL << 63ULL) - x : x; |
| 20 | for (int i = 0; i < 8; ++i) { |
| 21 | buf[i] = y & 0xff; |
| 22 | y /= 256; |
| 23 | } |
| 24 | } |
| 25 | |
| 26 | } // namespace |
| 27 | |
| 28 | namespace bsdiff { |
| 29 | |
Tianjie Xu | 1f1cdb2 | 2017-11-20 11:05:55 -0800 | [diff] [blame] | 30 | BsdiffPatchWriter::BsdiffPatchWriter(const std::string& patch_filename) |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 31 | : patch_filename_(patch_filename), |
| 32 | format_(BsdiffFormat::kLegacy), |
Tianjie Xu | 77833b6 | 2018-03-07 18:13:47 -0800 | [diff] [blame] | 33 | brotli_quality_(-1) { |
| 34 | types_.emplace_back(CompressorType::kBZ2); |
| 35 | } |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 36 | |
Tianjie Xu | 1f1cdb2 | 2017-11-20 11:05:55 -0800 | [diff] [blame] | 37 | |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 38 | BsdiffPatchWriter::BsdiffPatchWriter(const std::string& patch_filename, |
Tianjie Xu | 77833b6 | 2018-03-07 18:13:47 -0800 | [diff] [blame] | 39 | const std::vector<CompressorType>& types, |
Tianjie Xu | 2e70b55 | 2018-03-02 16:22:10 -0800 | [diff] [blame] | 40 | int brotli_quality) |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 41 | : patch_filename_(patch_filename), |
| 42 | format_(BsdiffFormat::kBsdf2), |
Tianjie Xu | 77833b6 | 2018-03-07 18:13:47 -0800 | [diff] [blame] | 43 | types_(types), |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 44 | brotli_quality_(brotli_quality) {} |
| 45 | |
| 46 | bool BsdiffPatchWriter::InitializeCompressorList( |
| 47 | std::vector<std::unique_ptr<bsdiff::CompressorInterface>>* |
| 48 | compressor_list) { |
Tianjie Xu | 77833b6 | 2018-03-07 18:13:47 -0800 | [diff] [blame] | 49 | if (types_.empty()) { |
| 50 | LOG(ERROR) << "Patch writer expects at least one compressor."; |
| 51 | return false; |
| 52 | } |
| 53 | |
| 54 | for (const auto& type : types_) { |
| 55 | switch (type) { |
| 56 | case CompressorType::kBZ2: |
| 57 | compressor_list->emplace_back(new BZ2Compressor()); |
| 58 | break; |
| 59 | case CompressorType::kBrotli: |
| 60 | compressor_list->emplace_back(new BrotliCompressor(brotli_quality_)); |
| 61 | break; |
| 62 | case CompressorType::kNoCompression: |
| 63 | LOG(ERROR) << "Unsupported compression type " << static_cast<int>(type); |
Sen Jiang | eb95b7e | 2018-11-26 13:32:54 -0800 | [diff] [blame] | 64 | return false; |
Tianjie Xu | 77833b6 | 2018-03-07 18:13:47 -0800 | [diff] [blame] | 65 | } |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 66 | } |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 67 | |
| 68 | for (const auto& compressor : *compressor_list) { |
| 69 | if (!compressor) { |
| 70 | return false; |
| 71 | } |
| 72 | } |
| 73 | |
| 74 | return true; |
Tianjie Xu | 1c26e2e | 2017-10-26 17:19:41 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Alex Deymo | 4dadd8b | 2017-10-26 16:19:33 +0200 | [diff] [blame] | 77 | bool BsdiffPatchWriter::Init(size_t /* new_size */) { |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 78 | if (!InitializeCompressorList(&ctrl_stream_list_)) { |
| 79 | LOG(ERROR) << "Failed to initialize control stream compressors."; |
| 80 | return false; |
| 81 | } |
| 82 | |
| 83 | if (!InitializeCompressorList(&diff_stream_list_)) { |
| 84 | LOG(ERROR) << "Failed to initialize diff stream compressors."; |
| 85 | return false; |
| 86 | } |
| 87 | |
| 88 | if (!InitializeCompressorList(&extra_stream_list_)) { |
| 89 | LOG(ERROR) << "Failed to initialize extra stream compressors."; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 90 | return false; |
| 91 | } |
| 92 | |
Alex Deymo | 538a75d | 2017-09-27 15:34:59 +0200 | [diff] [blame] | 93 | fp_ = fopen(patch_filename_.c_str(), "w"); |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 94 | if (!fp_) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 95 | LOG(ERROR) << "Opening " << patch_filename_; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 96 | return false; |
| 97 | } |
| 98 | return true; |
| 99 | } |
| 100 | |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 101 | bool BsdiffPatchWriter::WriteDiffStream(const uint8_t* data, size_t size) { |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 102 | for (const auto& compressor : diff_stream_list_) { |
| 103 | if (!compressor->Write(data, size)) { |
| 104 | return false; |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | return true; |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | bool BsdiffPatchWriter::WriteExtraStream(const uint8_t* data, size_t size) { |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 112 | for (const auto& compressor : extra_stream_list_) { |
| 113 | if (!compressor->Write(data, size)) { |
| 114 | return false; |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | return true; |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 119 | } |
| 120 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 121 | bool BsdiffPatchWriter::AddControlEntry(const ControlEntry& entry) { |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 122 | // Generate the 24 byte control entry. |
| 123 | uint8_t buf[24]; |
| 124 | EncodeInt64(entry.diff_size, buf); |
| 125 | EncodeInt64(entry.extra_size, buf + 8); |
| 126 | EncodeInt64(entry.offset_increment, buf + 16); |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 127 | |
| 128 | for (const auto& compressor : ctrl_stream_list_) { |
| 129 | if (!compressor->Write(buf, sizeof(buf))) { |
| 130 | return false; |
| 131 | } |
| 132 | } |
| 133 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 134 | written_output_ += entry.diff_size + entry.extra_size; |
| 135 | return true; |
| 136 | } |
| 137 | |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 138 | bool BsdiffPatchWriter::SelectSmallestResult( |
| 139 | const std::vector<std::unique_ptr<CompressorInterface>>& compressor_list, |
| 140 | CompressorInterface** smallest_compressor) { |
| 141 | size_t min_size = std::numeric_limits<size_t>::max(); |
| 142 | for (const auto& compressor : compressor_list) { |
| 143 | if (!compressor->Finish()) { |
| 144 | LOG(ERROR) << "Failed to finalize compressed streams."; |
| 145 | return false; |
| 146 | } |
| 147 | |
| 148 | // Update |smallest_compressor| if the current compressor produces a |
| 149 | // smaller result. |
| 150 | if (compressor->GetCompressedData().size() < min_size) { |
| 151 | min_size = compressor->GetCompressedData().size(); |
| 152 | *smallest_compressor = compressor.get(); |
| 153 | } |
| 154 | } |
| 155 | |
| 156 | return true; |
| 157 | } |
| 158 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 159 | bool BsdiffPatchWriter::Close() { |
| 160 | if (!fp_) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 161 | LOG(ERROR) << "File not open."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 162 | return false; |
| 163 | } |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 164 | |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 165 | CompressorInterface* ctrl_stream = nullptr; |
| 166 | if (!SelectSmallestResult(ctrl_stream_list_, &ctrl_stream) || !ctrl_stream) { |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 167 | return false; |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 168 | } |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 169 | |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 170 | CompressorInterface* diff_stream = nullptr; |
| 171 | if (!SelectSmallestResult(diff_stream_list_, &diff_stream) || !diff_stream) { |
| 172 | return false; |
| 173 | } |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 174 | |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 175 | CompressorInterface* extra_stream = nullptr; |
| 176 | if (!SelectSmallestResult(extra_stream_list_, &extra_stream) || |
| 177 | !extra_stream) { |
| 178 | return false; |
| 179 | } |
| 180 | |
| 181 | auto ctrl_data = ctrl_stream->GetCompressedData(); |
| 182 | auto diff_data = diff_stream->GetCompressedData(); |
| 183 | auto extra_data = extra_stream->GetCompressedData(); |
| 184 | |
| 185 | uint8_t types[3] = {static_cast<uint8_t>(ctrl_stream->Type()), |
| 186 | static_cast<uint8_t>(diff_stream->Type()), |
| 187 | static_cast<uint8_t>(extra_stream->Type())}; |
| 188 | |
| 189 | if (!WriteHeader(types, ctrl_data.size(), diff_data.size())) |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 190 | return false; |
| 191 | |
| 192 | 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] | 193 | LOG(ERROR) << "Writing ctrl_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 194 | return false; |
| 195 | } |
| 196 | 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] | 197 | LOG(ERROR) << "Writing diff_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 198 | return false; |
| 199 | } |
| 200 | if (fwrite(extra_data.data(), 1, extra_data.size(), fp_) != |
| 201 | extra_data.size()) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 202 | LOG(ERROR) << "Writing extra_data."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 203 | return false; |
| 204 | } |
| 205 | if (fclose(fp_) != 0) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 206 | LOG(ERROR) << "Closing the patch file."; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 207 | return false; |
| 208 | } |
| 209 | fp_ = nullptr; |
| 210 | return true; |
| 211 | } |
| 212 | |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 213 | bool BsdiffPatchWriter::WriteHeader(uint8_t types[3], |
| 214 | uint64_t ctrl_size, |
| 215 | uint64_t diff_size) { |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 216 | /* Header format is |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 217 | * 0 8 magic header |
| 218 | * 8 8 length of compressed ctrl block |
| 219 | * 16 8 length of compressed diff block |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 220 | * 24 8 length of new file |
| 221 | * |
| 222 | * File format is |
| 223 | * 0 32 Header |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 224 | * 32 ?? compressed ctrl block |
| 225 | * ?? ?? compressed diff block |
| 226 | * ?? ?? compressed extra block |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 227 | */ |
| 228 | uint8_t header[32]; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 229 | if (format_ == BsdiffFormat::kLegacy) { |
| 230 | // The magic header is "BSDIFF40" for legacy format. |
| 231 | memcpy(header, kLegacyMagicHeader, 8); |
| 232 | } else if (format_ == BsdiffFormat::kBsdf2) { |
| 233 | // The magic header for BSDF2 format: |
| 234 | // 0 5 BSDF2 |
| 235 | // 5 1 compressed type for control stream |
| 236 | // 6 1 compressed type for diff stream |
| 237 | // 7 1 compressed type for extra stream |
| 238 | memcpy(header, kBSDF2MagicHeader, 5); |
Tianjie Xu | 32b1f21 | 2018-03-06 11:42:45 -0800 | [diff] [blame] | 239 | memcpy(header + 5, types, 3); |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 240 | } else { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 241 | LOG(ERROR) << "Unsupported bsdiff format."; |
Tianjie Xu | b4cba64 | 2017-11-14 22:46:38 -0800 | [diff] [blame] | 242 | return false; |
| 243 | } |
| 244 | |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 245 | EncodeInt64(ctrl_size, header + 8); |
| 246 | EncodeInt64(diff_size, header + 16); |
Alex Deymo | 68c0e7f | 2017-10-02 20:38:12 +0200 | [diff] [blame] | 247 | EncodeInt64(written_output_, header + 24); |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 248 | if (fwrite(header, sizeof(header), 1, fp_) != 1) { |
Tianjie Xu | 18480eb | 2017-11-29 16:21:43 -0800 | [diff] [blame] | 249 | LOG(ERROR) << "writing to the patch file"; |
Alex Deymo | a28e019 | 2017-09-08 14:21:05 +0200 | [diff] [blame] | 250 | return false; |
| 251 | } |
| 252 | return true; |
| 253 | } |
| 254 | |
| 255 | } // namespace bsdiff |