updater/target_files.cpp - SHIFTPHONES/android_bootable_recovery - Gitiles

 /*
  * Copyright (C) 2019 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 "updater/target_files.h"

 #include <unistd.h>

 #include <algorithm>
 #include <filesystem>
 #include <memory>

 #include <android-base/logging.h>
 #include <android-base/strings.h>
 #include <sparse/sparse.h>

 static bool SimgToImg(int input_fd, int output_fd) {
   if (lseek64(input_fd, 0, SEEK_SET) == -1) {
     PLOG(ERROR) << "Failed to lseek64 on the input sparse image";
     return false;
   }

   if (lseek64(output_fd, 0, SEEK_SET) == -1) {
     PLOG(ERROR) << "Failed to lseek64 on the output raw image";
     return false;
   }

   std::unique_ptr<sparse_file, decltype(&sparse_file_destroy)> s_file(
       sparse_file_import(input_fd, true, false), sparse_file_destroy);
   if (!s_file) {
     LOG(ERROR) << "Failed to import the sparse image.";
     return false;
   }

   if (sparse_file_write(s_file.get(), output_fd, false, false, false) < 0) {
     PLOG(ERROR) << "Failed to output the raw image file.";
     return false;
   }

   return true;
 }

 static bool ParsePropertyFile(const std::string_view prop_content,
                               std::map<std::string, std::string, std::less<>>* props_map) {
   LOG(INFO) << "Start parsing build property\n";
   std::vector<std::string> lines = android::base::Split(std::string(prop_content), "\n");
   for (const auto& line : lines) {
     if (line.empty() || line[0] == '#') continue;
     auto pos = line.find('=');
     if (pos == std::string::npos) continue;
     std::string key = line.substr(0, pos);
     std::string value = line.substr(pos + 1);
     LOG(INFO) << key << ": " << value;
     props_map->emplace(key, value);
   }

   return true;
 }

 static bool ParseFstab(const std::string_view fstab, std::vector<FstabInfo>* fstab_info_list) {
   LOG(INFO) << "parsing fstab\n";
   std::vector<std::string> lines = android::base::Split(std::string(fstab), "\n");
   for (const auto& line : lines) {
     if (line.empty() || line[0] == '#') continue;

     // <block_device>  <mount_point>  <fs_type>  <mount_flags>  optional:<fs_mgr_flags>
     std::vector<std::string> tokens = android::base::Split(line, " ");
     tokens.erase(std::remove(tokens.begin(), tokens.end(), ""), tokens.end());
     if (tokens.size() != 4 && tokens.size() != 5) {
       LOG(ERROR) << "Unexpected token size: " << tokens.size() << std::endl
                  << "Error parsing fstab line: " << line;
       return false;
     }

     const auto& blockdev = tokens[0];
     const auto& mount_point = tokens[1];
     const auto& fs_type = tokens[2];
     if (!android::base::StartsWith(mount_point, "/")) {
       LOG(WARNING) << "mount point '" << mount_point << "' does not start with '/'";
       continue;
     }

     // The simulator only supports ext4 and emmc for now.
     if (fs_type != "ext4" && fs_type != "emmc") {
       LOG(WARNING) << "Unsupported fs_type in " << line;
       continue;
     }

     fstab_info_list->emplace_back(blockdev, mount_point, fs_type);
   }

   return true;
 }

 bool TargetFile::EntryExists(const std::string_view name) const {
   if (extracted_input_) {
     std::string entry_path = path_ + "/" + std::string(name);
     if (access(entry_path.c_str(), O_RDONLY) != 0) {
       PLOG(WARNING) << "Failed to access " << entry_path;
       return false;
     }
     return true;
   }

   CHECK(handle_);
   ZipEntry64 img_entry;
   return FindEntry(handle_, name, &img_entry) == 0;
 }

 bool TargetFile::ReadEntryToString(const std::string_view name, std::string* content) const {
   if (extracted_input_) {
     std::string entry_path = path_ + "/" + std::string(name);
     return android::base::ReadFileToString(entry_path, content);
   }

   CHECK(handle_);
   ZipEntry64 entry;
   if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
     LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
     return false;
   }

   if (entry.uncompressed_length == 0) {
     content->clear();
     return true;
   }

   if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
     LOG(ERROR) << "Failed to extract " << name
                << " because's uncompressed size exceeds size of address space. "
                << entry.uncompressed_length;
     return false;
   }

   content->resize(entry.uncompressed_length);
   if (auto extract_err = ExtractToMemory(
           handle_, &entry, reinterpret_cast<uint8_t*>(&content->at(0)), entry.uncompressed_length);
       extract_err != 0) {
     LOG(ERROR) << "failed to read " << name << " from package: " << ErrorCodeString(extract_err);
     return false;
   }

   return true;
 }

 bool TargetFile::ExtractEntryToTempFile(const std::string_view name,
                                         TemporaryFile* temp_file) const {
   if (extracted_input_) {
     std::string entry_path = path_ + "/" + std::string(name);
     return std::filesystem::copy_file(entry_path, temp_file->path,
                                       std::filesystem::copy_options::overwrite_existing);
   }

   CHECK(handle_);
   ZipEntry64 entry;
   if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
     LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
     return false;
   }

   if (auto status = ExtractEntryToFile(handle_, &entry, temp_file->fd); status != 0) {
     LOG(ERROR) << "Failed to extract zip entry " << name << " : " << ErrorCodeString(status);
     return false;
   }
   return true;
 }

 bool TargetFile::Open() {
   if (!extracted_input_) {
     if (auto ret = OpenArchive(path_.c_str(), &handle_); ret != 0) {
       LOG(ERROR) << "failed to open source target file " << path_ << ": " << ErrorCodeString(ret);
       return false;
     }
   }

   // Parse the misc info.
   std::string misc_info_content;
   if (!ReadEntryToString("META/misc_info.txt", &misc_info_content)) {
     return false;
   }
   if (!ParsePropertyFile(misc_info_content, &misc_info_)) {
     return false;
   }

   return true;
 }

 bool TargetFile::GetBuildProps(std::map<std::string, std::string, std::less<>>* props_map) const {
   props_map->clear();
   // Parse the source zip to mock the system props and block devices. We try all the possible
   // locations for build props.
   constexpr std::string_view kPropLocations[] = {
     "SYSTEM/build.prop",
     "VENDOR/build.prop",
     "PRODUCT/build.prop",
     "SYSTEM_EXT/build.prop",
     "SYSTEM/vendor/build.prop",
     "SYSTEM/product/build.prop",
     "SYSTEM/system_ext/build.prop",
     "ODM/build.prop",  // legacy
     "ODM/etc/build.prop",
     "VENDOR/odm/build.prop",  // legacy
     "VENDOR/odm/etc/build.prop",
   };
   for (const auto& name : kPropLocations) {
     std::string build_prop_content;
     if (!ReadEntryToString(name, &build_prop_content)) {
       continue;
     }
     std::map<std::string, std::string, std::less<>> props;
     if (!ParsePropertyFile(build_prop_content, &props)) {
       LOG(ERROR) << "Failed to parse build prop in " << name;
       return false;
     }
     for (const auto& [key, value] : props) {
       if (auto it = props_map->find(key); it != props_map->end() && it->second != value) {
         LOG(WARNING) << "Property " << key << " has different values in property files, we got "
                      << it->second << " and " << value;
       }
       props_map->emplace(key, value);
     }
   }

   return true;
 }

 bool TargetFile::ExtractImage(const std::string_view entry_name, const FstabInfo& fstab_info,
                               const std::string_view work_dir, TemporaryFile* image_file) const {
   if (!EntryExists(entry_name)) {
     return false;
   }

   // We don't need extra work for 'emmc'; use the image file as the block device.
   if (fstab_info.fs_type == "emmc" || misc_info_.find("extfs_sparse_flag") == misc_info_.end()) {
     if (!ExtractEntryToTempFile(entry_name, image_file)) {
       return false;
     }
   } else {  // treated as ext4 sparse image
     TemporaryFile sparse_image{ std::string(work_dir) };
     if (!ExtractEntryToTempFile(entry_name, &sparse_image)) {
       return false;
     }

     // Convert the sparse image to raw.
     if (!SimgToImg(sparse_image.fd, image_file->fd)) {
       LOG(ERROR) << "Failed to convert " << fstab_info.mount_point << " to raw.";
       return false;
     }
   }

   return true;
 }

 bool TargetFile::ParseFstabInfo(std::vector<FstabInfo>* fstab_info_list) const {
   // Parse the fstab file and extract the image files. The location of the fstab actually depends
   // on some flags e.g. "no_recovery", "recovery_as_boot". Here we just try all possibilities.
   constexpr std::string_view kRecoveryFstabLocations[] = {
     "RECOVERY/RAMDISK/system/etc/recovery.fstab",
     "RECOVERY/RAMDISK/etc/recovery.fstab",
     "BOOT/RAMDISK/system/etc/recovery.fstab",
     "BOOT/RAMDISK/etc/recovery.fstab",
   };
   std::string fstab_content;
   for (const auto& name : kRecoveryFstabLocations) {
     if (std::string content; ReadEntryToString(name, &content)) {
       fstab_content = std::move(content);
       break;
     }
   }
   if (fstab_content.empty()) {
     LOG(ERROR) << "Failed to parse the recovery fstab file";
     return false;
   }

   // Extract the images and convert them to raw.
   if (!ParseFstab(fstab_content, fstab_info_list)) {
     LOG(ERROR) << "Failed to mount the block devices for source build.";
     return false;
   }

   return true;
 }
	/*
	* Copyright (C) 2019 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 "updater/target_files.h"

	#include <unistd.h>

	#include <algorithm>
	#include <filesystem>
	#include <memory>

	#include <android-base/logging.h>
	#include <android-base/strings.h>
	#include <sparse/sparse.h>

	static bool SimgToImg(int input_fd, int output_fd) {
	if (lseek64(input_fd, 0, SEEK_SET) == -1) {
	PLOG(ERROR) << "Failed to lseek64 on the input sparse image";
	return false;
	}

	if (lseek64(output_fd, 0, SEEK_SET) == -1) {
	PLOG(ERROR) << "Failed to lseek64 on the output raw image";
	return false;
	}

	std::unique_ptr<sparse_file, decltype(&sparse_file_destroy)> s_file(
	sparse_file_import(input_fd, true, false), sparse_file_destroy);
	if (!s_file) {
	LOG(ERROR) << "Failed to import the sparse image.";
	return false;
	}

	if (sparse_file_write(s_file.get(), output_fd, false, false, false) < 0) {
	PLOG(ERROR) << "Failed to output the raw image file.";
	return false;
	}

	return true;
	}

	static bool ParsePropertyFile(const std::string_view prop_content,
	std::map<std::string, std::string, std::less<>>* props_map) {
	LOG(INFO) << "Start parsing build property\n";
	std::vector<std::string> lines = android::base::Split(std::string(prop_content), "\n");
	for (const auto& line : lines) {
	if (line.empty() \|\| line[0] == '#') continue;
	auto pos = line.find('=');
	if (pos == std::string::npos) continue;
	std::string key = line.substr(0, pos);
	std::string value = line.substr(pos + 1);
	LOG(INFO) << key << ": " << value;
	props_map->emplace(key, value);
	}

	return true;
	}

	static bool ParseFstab(const std::string_view fstab, std::vector<FstabInfo>* fstab_info_list) {
	LOG(INFO) << "parsing fstab\n";
	std::vector<std::string> lines = android::base::Split(std::string(fstab), "\n");
	for (const auto& line : lines) {
	if (line.empty() \|\| line[0] == '#') continue;

	// <block_device> <mount_point> <fs_type> <mount_flags> optional:<fs_mgr_flags>
	std::vector<std::string> tokens = android::base::Split(line, " ");
	tokens.erase(std::remove(tokens.begin(), tokens.end(), ""), tokens.end());
	if (tokens.size() != 4 && tokens.size() != 5) {
	LOG(ERROR) << "Unexpected token size: " << tokens.size() << std::endl
	<< "Error parsing fstab line: " << line;
	return false;
	}

	const auto& blockdev = tokens[0];
	const auto& mount_point = tokens[1];
	const auto& fs_type = tokens[2];
	if (!android::base::StartsWith(mount_point, "/")) {
	LOG(WARNING) << "mount point '" << mount_point << "' does not start with '/'";
	continue;
	}

	// The simulator only supports ext4 and emmc for now.
	if (fs_type != "ext4" && fs_type != "emmc") {
	LOG(WARNING) << "Unsupported fs_type in " << line;
	continue;
	}

	fstab_info_list->emplace_back(blockdev, mount_point, fs_type);
	}

	return true;
	}

	bool TargetFile::EntryExists(const std::string_view name) const {
	if (extracted_input_) {
	std::string entry_path = path_ + "/" + std::string(name);
	if (access(entry_path.c_str(), O_RDONLY) != 0) {
	PLOG(WARNING) << "Failed to access " << entry_path;
	return false;
	}
	return true;
	}

	CHECK(handle_);
	ZipEntry64 img_entry;
	return FindEntry(handle_, name, &img_entry) == 0;
	}

	bool TargetFile::ReadEntryToString(const std::string_view name, std::string* content) const {
	if (extracted_input_) {
	std::string entry_path = path_ + "/" + std::string(name);
	return android::base::ReadFileToString(entry_path, content);
	}

	CHECK(handle_);
	ZipEntry64 entry;
	if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
	LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
	return false;
	}

	if (entry.uncompressed_length == 0) {
	content->clear();
	return true;
	}

	if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
	LOG(ERROR) << "Failed to extract " << name
	<< " because's uncompressed size exceeds size of address space. "
	<< entry.uncompressed_length;
	return false;
	}

	content->resize(entry.uncompressed_length);
	if (auto extract_err = ExtractToMemory(
	handle_, &entry, reinterpret_cast<uint8_t*>(&content->at(0)), entry.uncompressed_length);
	extract_err != 0) {
	LOG(ERROR) << "failed to read " << name << " from package: " << ErrorCodeString(extract_err);
	return false;
	}

	return true;
	}

	bool TargetFile::ExtractEntryToTempFile(const std::string_view name,
	TemporaryFile* temp_file) const {
	if (extracted_input_) {
	std::string entry_path = path_ + "/" + std::string(name);
	return std::filesystem::copy_file(entry_path, temp_file->path,
	std::filesystem::copy_options::overwrite_existing);
	}

	CHECK(handle_);
	ZipEntry64 entry;
	if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
	LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
	return false;
	}

	if (auto status = ExtractEntryToFile(handle_, &entry, temp_file->fd); status != 0) {
	LOG(ERROR) << "Failed to extract zip entry " << name << " : " << ErrorCodeString(status);
	return false;
	}
	return true;
	}

	bool TargetFile::Open() {
	if (!extracted_input_) {
	if (auto ret = OpenArchive(path_.c_str(), &handle_); ret != 0) {
	LOG(ERROR) << "failed to open source target file " << path_ << ": " << ErrorCodeString(ret);
	return false;
	}
	}

	// Parse the misc info.
	std::string misc_info_content;
	if (!ReadEntryToString("META/misc_info.txt", &misc_info_content)) {
	return false;
	}
	if (!ParsePropertyFile(misc_info_content, &misc_info_)) {
	return false;
	}

	return true;
	}

	bool TargetFile::GetBuildProps(std::map<std::string, std::string, std::less<>>* props_map) const {
	props_map->clear();
	// Parse the source zip to mock the system props and block devices. We try all the possible
	// locations for build props.
	constexpr std::string_view kPropLocations[] = {
	"SYSTEM/build.prop",
	"VENDOR/build.prop",
	"PRODUCT/build.prop",
	"SYSTEM_EXT/build.prop",
	"SYSTEM/vendor/build.prop",
	"SYSTEM/product/build.prop",
	"SYSTEM/system_ext/build.prop",
	"ODM/build.prop", // legacy
	"ODM/etc/build.prop",
	"VENDOR/odm/build.prop", // legacy
	"VENDOR/odm/etc/build.prop",
	};
	for (const auto& name : kPropLocations) {
	std::string build_prop_content;
	if (!ReadEntryToString(name, &build_prop_content)) {
	continue;
	}
	std::map<std::string, std::string, std::less<>> props;
	if (!ParsePropertyFile(build_prop_content, &props)) {
	LOG(ERROR) << "Failed to parse build prop in " << name;
	return false;
	}
	for (const auto& [key, value] : props) {
	if (auto it = props_map->find(key); it != props_map->end() && it->second != value) {
	LOG(WARNING) << "Property " << key << " has different values in property files, we got "
	<< it->second << " and " << value;
	}
	props_map->emplace(key, value);
	}
	}

	return true;
	}

	bool TargetFile::ExtractImage(const std::string_view entry_name, const FstabInfo& fstab_info,
	const std::string_view work_dir, TemporaryFile* image_file) const {
	if (!EntryExists(entry_name)) {
	return false;
	}

	// We don't need extra work for 'emmc'; use the image file as the block device.
	if (fstab_info.fs_type == "emmc" \|\| misc_info_.find("extfs_sparse_flag") == misc_info_.end()) {
	if (!ExtractEntryToTempFile(entry_name, image_file)) {
	return false;
	}
	} else { // treated as ext4 sparse image
	TemporaryFile sparse_image{ std::string(work_dir) };
	if (!ExtractEntryToTempFile(entry_name, &sparse_image)) {
	return false;
	}

	// Convert the sparse image to raw.
	if (!SimgToImg(sparse_image.fd, image_file->fd)) {
	LOG(ERROR) << "Failed to convert " << fstab_info.mount_point << " to raw.";
	return false;
	}
	}

	return true;
	}

	bool TargetFile::ParseFstabInfo(std::vector<FstabInfo>* fstab_info_list) const {
	// Parse the fstab file and extract the image files. The location of the fstab actually depends
	// on some flags e.g. "no_recovery", "recovery_as_boot". Here we just try all possibilities.
	constexpr std::string_view kRecoveryFstabLocations[] = {
	"RECOVERY/RAMDISK/system/etc/recovery.fstab",
	"RECOVERY/RAMDISK/etc/recovery.fstab",
	"BOOT/RAMDISK/system/etc/recovery.fstab",
	"BOOT/RAMDISK/etc/recovery.fstab",
	};
	std::string fstab_content;
	for (const auto& name : kRecoveryFstabLocations) {
	if (std::string content; ReadEntryToString(name, &content)) {
	fstab_content = std::move(content);
	break;
	}
	}
	if (fstab_content.empty()) {
	LOG(ERROR) << "Failed to parse the recovery fstab file";
	return false;
	}

	// Extract the images and convert them to raw.
	if (!ParseFstab(fstab_content, fstab_info_list)) {
	LOG(ERROR) << "Failed to mount the block devices for source build.";
	return false;
	}

	return true;
	}