| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "common/memory_image/memory-image-reader.h" |
| |
| #include <string> |
| |
| #include "base.h" |
| #include "common/memory_image/low-level-memory-reader.h" |
| #include "common/memory_image/memory-image-common.h" |
| #include "common/memory_image/memory-image.pb.h" |
| #include "util/base/logging.h" |
| |
| namespace libtextclassifier { |
| namespace nlp_core { |
| |
| namespace { |
| |
| // Checks that the memory area read by mem_reader starts with the expected |
| // signature. Advances mem_reader past the signature and returns success |
| // status. |
| bool ReadAndCheckSignature(LowLevelMemReader *mem_reader) { |
| const std::string expected_signature = MemoryImageConstants::kSignature; |
| const int signature_size = expected_signature.size(); |
| if (mem_reader->GetNumAvailableBytes() < signature_size) { |
| TC_LOG(ERROR) << "Not enough bytes to check signature"; |
| return false; |
| } |
| const std::string actual_signature(mem_reader->GetCurrent(), signature_size); |
| if (!mem_reader->Advance(signature_size)) { |
| TC_LOG(ERROR) << "Failed to advance past signature"; |
| return false; |
| } |
| if (actual_signature != expected_signature) { |
| TC_LOG(ERROR) << "Different signature: actual \"" << actual_signature |
| << "\" != expected \"" << expected_signature << "\""; |
| return false; |
| } |
| return true; |
| } |
| |
| // Parses MemoryImageHeader from mem_reader. Advances mem_reader past it. |
| // Returns success status. |
| bool ParseMemoryImageHeader( |
| LowLevelMemReader *mem_reader, MemoryImageHeader *header) { |
| std::string header_proto_str; |
| if (!mem_reader->ReadString(&header_proto_str)) { |
| TC_LOG(ERROR) << "Unable to read header_proto_str"; |
| return false; |
| } |
| if (!header->ParseFromString(header_proto_str)) { |
| TC_LOG(ERROR) << "Unable to parse MemoryImageHeader"; |
| return false; |
| } |
| return true; |
| } |
| |
| } // namespace |
| |
| bool GeneralMemoryImageReader::ReadMemoryImage() { |
| LowLevelMemReader mem_reader(start_, num_bytes_); |
| |
| // Read and check signature. |
| if (!ReadAndCheckSignature(&mem_reader)) { |
| return false; |
| } |
| |
| // Parse MemoryImageHeader header_. |
| if (!ParseMemoryImageHeader(&mem_reader, &header_)) { |
| return false; |
| } |
| |
| // Check endianness. |
| if (header_.is_little_endian() != LittleEndian::IsLittleEndian()) { |
| // TODO(salcianu): implement conversion: it will take time, but it's better |
| // than crashing. Not very urgent: [almost] all current Android phones are |
| // little-endian. |
| TC_LOG(ERROR) << "Memory image is " |
| << (header_.is_little_endian() ? "little" : "big") |
| << " endian. " |
| << "Local system is different and we don't currently support " |
| << "conversion between the two."; |
| return false; |
| } |
| |
| // Read binary serialization of trimmed original proto. |
| if (!mem_reader.ReadString(&trimmed_proto_serialization_)) { |
| TC_LOG(ERROR) << "Unable to read trimmed proto binary serialization"; |
| return false; |
| } |
| |
| // Fill vector of pointers to beginning of each data blob. |
| for (int i = 0; i < header_.blob_info_size(); ++i) { |
| const MemoryImageDataBlobInfo &blob_info = header_.blob_info(i); |
| if (!mem_reader.SkipToAlign(header_.alignment())) { |
| TC_LOG(ERROR) << "Unable to align for blob #i" << i; |
| return false; |
| } |
| data_blob_views_.emplace_back( |
| mem_reader.GetCurrent(), |
| blob_info.num_bytes()); |
| if (!mem_reader.Advance(blob_info.num_bytes())) { |
| TC_LOG(ERROR) << "Not enough bytes for blob #i" << i; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| } // namespace nlp_core |
| } // namespace libtextclassifier |