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 5 #include "bsdiff/patch_writer.h" 6 7 #include <string.h> 8 9 #include "bsdiff/brotli_compressor.h" 10 #include "bsdiff/bz2_compressor.h" 11 #include "bsdiff/constants.h" 12 #include "bsdiff/control_entry.h" 13 #include "bsdiff/logging.h" 14 15 namespace { 16 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 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 36 BsdiffPatchWriter::BsdiffPatchWriter(const std::string& patch_filename, 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)); 48 } 49 } 50 51 bool BsdiffPatchWriter::Init(size_t /* new_size */) { 52 if (!(ctrl_stream_ && diff_stream_ && extra_stream_)) { 53 LOG(ERROR) << "uninitialized compressor stream"; 54 return false; 55 } 56 57 fp_ = fopen(patch_filename_.c_str(), "w"); 58 if (!fp_) { 59 LOG(ERROR) << "Opening " << patch_filename_; 60 return false; 61 } 62 return true; 63 } 64 65 bool BsdiffPatchWriter::WriteDiffStream(const uint8_t* data, size_t size) { 66 return diff_stream_->Write(data, size); 67 } 68 69 bool BsdiffPatchWriter::WriteExtraStream(const uint8_t* data, size_t size) { 70 return extra_stream_->Write(data, size); 71 } 72 73 bool BsdiffPatchWriter::AddControlEntry(const ControlEntry& entry) { 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); 79 if (!ctrl_stream_->Write(buf, sizeof(buf))) 80 return false; 81 written_output_ += entry.diff_size + entry.extra_size; 82 return true; 83 } 84 85 bool BsdiffPatchWriter::Close() { 86 if (!fp_) { 87 LOG(ERROR) << "File not open."; 88 return false; 89 } 90 91 if (!ctrl_stream_->Finish() || !diff_stream_->Finish() || 92 !extra_stream_->Finish()) { 93 LOG(ERROR) << "Finalizing compressed streams."; 94 return false; 95 } 96 97 auto ctrl_data = ctrl_stream_->GetCompressedData(); 98 auto diff_data = diff_stream_->GetCompressedData(); 99 auto extra_data = extra_stream_->GetCompressedData(); 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()) { 105 LOG(ERROR) << "Writing ctrl_data."; 106 return false; 107 } 108 if (fwrite(diff_data.data(), 1, diff_data.size(), fp_) != diff_data.size()) { 109 LOG(ERROR) << "Writing diff_data."; 110 return false; 111 } 112 if (fwrite(extra_data.data(), 1, extra_data.size(), fp_) != 113 extra_data.size()) { 114 LOG(ERROR) << "Writing extra_data."; 115 return false; 116 } 117 if (fclose(fp_) != 0) { 118 LOG(ERROR) << "Closing the patch file."; 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 127 * 0 8 magic header 128 * 8 8 length of compressed ctrl block 129 * 16 8 length of compressed diff block 130 * 24 8 length of new file 131 * 132 * File format is 133 * 0 32 Header 134 * 32 ?? compressed ctrl block 135 * ?? ?? compressed diff block 136 * ?? ?? compressed extra block 137 */ 138 uint8_t header[32]; 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 { 153 LOG(ERROR) << "Unsupported bsdiff format."; 154 return false; 155 } 156 157 EncodeInt64(ctrl_size, header + 8); 158 EncodeInt64(diff_size, header + 16); 159 EncodeInt64(written_output_, header + 24); 160 if (fwrite(header, sizeof(header), 1, fp_) != 1) { 161 LOG(ERROR) << "writing to the patch file"; 162 return false; 163 } 164 return true; 165 } 166 167 } // namespace bsdiff 168
