1 // 2 // Copyright (C) 2016 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "update_engine/payload_generator/xz.h" 18 19 #include <7zCrc.h> 20 #include <Xz.h> 21 #include <XzEnc.h> 22 23 #include <algorithm> 24 25 #include <base/logging.h> 26 27 namespace { 28 29 bool xz_initialized = false; 30 31 // An ISeqInStream implementation that reads all the data from the passed Blob. 32 struct BlobReaderStream : public ISeqInStream { 33 explicit BlobReaderStream(const brillo::Blob& data) : data_(data) { 34 Read = &BlobReaderStream::ReadStatic; 35 } 36 37 static SRes ReadStatic(void* p, void* buf, size_t* size) { 38 auto* self = 39 static_cast<BlobReaderStream*>(reinterpret_cast<ISeqInStream*>(p)); 40 *size = std::min(*size, self->data_.size() - self->pos_); 41 memcpy(buf, self->data_.data() + self->pos_, *size); 42 self->pos_ += *size; 43 return SZ_OK; 44 } 45 46 const brillo::Blob& data_; 47 48 // The current reader position. 49 size_t pos_ = 0; 50 }; 51 52 // An ISeqOutStream implementation that writes all the data to the passed Blob. 53 struct BlobWriterStream : public ISeqOutStream { 54 explicit BlobWriterStream(brillo::Blob* data) : data_(data) { 55 Write = &BlobWriterStream::WriteStatic; 56 } 57 58 static size_t WriteStatic(void* p, const void* buf, size_t size) { 59 auto* self = 60 static_cast<BlobWriterStream*>(reinterpret_cast<ISeqOutStream*>(p)); 61 const uint8_t* buffer = reinterpret_cast<const uint8_t*>(buf); 62 self->data_->reserve(self->data_->size() + size); 63 self->data_->insert(self->data_->end(), buffer, buffer + size); 64 return size; 65 } 66 67 brillo::Blob* data_; 68 }; 69 70 } // namespace 71 72 namespace chromeos_update_engine { 73 74 void XzCompressInit() { 75 if (xz_initialized) 76 return; 77 xz_initialized = true; 78 // Although we don't include a CRC32 for the stream, the xz file header has 79 // a CRC32 of the header itself, which required the CRC table to be 80 // initialized. 81 CrcGenerateTable(); 82 } 83 84 bool XzCompress(const brillo::Blob& in, brillo::Blob* out) { 85 CHECK(xz_initialized) << "Initialize XzCompress first"; 86 out->clear(); 87 if (in.empty()) 88 return true; 89 90 // Xz compression properties. 91 CXzProps props; 92 XzProps_Init(&props); 93 // No checksum in the xz stream. xz-embedded (used by the decompressor) only 94 // supports CRC32, but we already check the sha-1 of the whole blob during 95 // payload application. 96 props.checkId = XZ_CHECK_NO; 97 98 // LZMA2 compression properties. 99 CLzma2EncProps lzma2Props; 100 props.lzma2Props = &lzma2Props; 101 Lzma2EncProps_Init(&lzma2Props); 102 // LZMA compression "level 6" requires 9 MB of RAM to decompress in the worst 103 // case. 104 lzma2Props.lzmaProps.level = 6; 105 lzma2Props.lzmaProps.numThreads = 1; 106 // The input size data is used to reduce the dictionary size if possible. 107 lzma2Props.lzmaProps.reduceSize = in.size(); 108 Lzma2EncProps_Normalize(&lzma2Props); 109 110 BlobWriterStream out_writer(out); 111 BlobReaderStream in_reader(in); 112 SRes res = Xz_Encode(&out_writer, &in_reader, &props, nullptr /* progress */); 113 return res == SZ_OK; 114 } 115 116 } // namespace chromeos_update_engine 117
