Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9d090b2c authored by Automerger Merge Worker's avatar Automerger Merge Worker
Browse files

Merge "Delete VINTF compatibility check during OTA." am: cae99c43 am: 567ae2f9 

Change-Id: I40359f387e70e8055c12d0245a0e5d2132007889
parents 0c6c04c6 567ae2f9

install/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ cc_defaults { 
        "libsnapshot_nobinder",



        // external dependencies

        "libvintf_recovery",

        "libvintf",

    ],

}

install/include/install/install.h

+0 −4
Original line number Diff line number Diff line
@@ -59,10 +59,6 @@ bool verify_package(Package* package, RecoveryUI* ui); 
// result to |metadata|. Return true if succeed, otherwise return false.

bool ReadMetadataFromPackage(ZipArchiveHandle zip, std::map<std::string, std::string>* metadata);



// Verifies the compatibility info in a Treble-compatible package. Returns true directly if the

// entry doesn't exist.

bool verify_package_compatibility(ZipArchiveHandle package_zip);



// Checks if the metadata in the OTA package has expected values. Mandatory checks: ota-type,

// pre-device and serial number (if presents). A/B OTA specific checks: pre-build version,

// fingerprint, timestamp.

install/install.cpp

+0 −81
Original line number Diff line number Diff line
@@ -44,7 +44,6 @@ 
#include <android-base/stringprintf.h>

#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <vintf/VintfObjectRecovery.h>



#include "install/package.h"

#include "install/verifier.h"
@@ -505,73 +504,6 @@ static InstallResult TryUpdateBinary(Package* package, bool* wipe_cache, 
  return INSTALL_SUCCESS;

}



// Verifies the compatibility info in a Treble-compatible package. Returns true directly if the

// entry doesn't exist. Note that the compatibility info is packed in a zip file inside the OTA

// package.

bool verify_package_compatibility(ZipArchiveHandle package_zip) {

  LOG(INFO) << "Verifying package compatibility...";



  static constexpr const char* COMPATIBILITY_ZIP_ENTRY = "compatibility.zip";

  ZipEntry compatibility_entry;

  if (FindEntry(package_zip, COMPATIBILITY_ZIP_ENTRY, &compatibility_entry) != 0) {

    LOG(INFO) << "Package doesn't contain " << COMPATIBILITY_ZIP_ENTRY << " entry";

    return true;

  }



  std::string zip_content(compatibility_entry.uncompressed_length, '\0');

  int32_t ret;

  if ((ret = ExtractToMemory(package_zip, &compatibility_entry,

                             reinterpret_cast<uint8_t*>(&zip_content[0]),

                             compatibility_entry.uncompressed_length)) != 0) {

    LOG(ERROR) << "Failed to read " << COMPATIBILITY_ZIP_ENTRY << ": " << ErrorCodeString(ret);

    return false;

  }



  ZipArchiveHandle zip_handle;

  ret = OpenArchiveFromMemory(static_cast<void*>(const_cast<char*>(zip_content.data())),

                              zip_content.size(), COMPATIBILITY_ZIP_ENTRY, &zip_handle);

  if (ret != 0) {

    LOG(ERROR) << "Failed to OpenArchiveFromMemory: " << ErrorCodeString(ret);

    return false;

  }



  // Iterate all the entries inside COMPATIBILITY_ZIP_ENTRY and read the contents.

  void* cookie;

  ret = StartIteration(zip_handle, &cookie);

  if (ret != 0) {

    LOG(ERROR) << "Failed to start iterating zip entries: " << ErrorCodeString(ret);

    CloseArchive(zip_handle);

    return false;

  }

  std::unique_ptr<void, decltype(&EndIteration)> guard(cookie, EndIteration);



  std::vector<std::string> compatibility_info;

  ZipEntry info_entry;

  std::string_view info_name;

  while (Next(cookie, &info_entry, &info_name) == 0) {

    std::string content(info_entry.uncompressed_length, '\0');

    int32_t ret = ExtractToMemory(zip_handle, &info_entry, reinterpret_cast<uint8_t*>(&content[0]),

                                  info_entry.uncompressed_length);

    if (ret != 0) {

      LOG(ERROR) << "Failed to read " << info_name << ": " << ErrorCodeString(ret);

      CloseArchive(zip_handle);

      return false;

    }

    compatibility_info.emplace_back(std::move(content));

  }

  CloseArchive(zip_handle);



  // VintfObjectRecovery::CheckCompatibility returns zero on success.

  std::string err;

  int result = android::vintf::VintfObjectRecovery::CheckCompatibility(compatibility_info, &err);

  if (result == 0) {

    return true;

  }



  LOG(ERROR) << "Failed to verify package compatibility (result " << result << "): " << err;

  return false;

}



static InstallResult VerifyAndInstallPackage(Package* package, bool* wipe_cache,

                                             std::vector<std::string>* log_buffer, int retry_count,

                                             int* max_temperature, RecoveryUI* ui) {
@@ -586,19 +518,6 @@ static InstallResult VerifyAndInstallPackage(Package* package, bool* wipe_cache, 
    return INSTALL_CORRUPT;

  }



  // Try to open the package.

  ZipArchiveHandle zip = package->GetZipArchiveHandle();

  if (!zip) {

    log_buffer->push_back(android::base::StringPrintf("error: %d", kZipOpenFailure));

    return INSTALL_CORRUPT;

  }



  // Additionally verify the compatibility of the package if it's a fresh install.

  if (retry_count == 0 && !verify_package_compatibility(zip)) {

    log_buffer->push_back(android::base::StringPrintf("error: %d", kPackageCompatibilityFailure));

    return INSTALL_CORRUPT;

  }



  // Verify and install the contents of the package.

  ui->Print("Installing update...\n");

  if (retry_count > 0) {

tests/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -81,7 +81,6 @@ librecovery_static_libs = [ 
    "libotautil",



    "libhealthhalutils",

    "libvintf_recovery",

    "libvintf",



    "android.hardware.health@2.0",

tests/unit/install_test.cpp

+0 −82
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#include <android-base/properties.h>

#include <android-base/strings.h>

#include <gtest/gtest.h>

#include <vintf/VintfObjectRecovery.h>

#include <ziparchive/zip_archive.h>

#include <ziparchive/zip_writer.h>
@@ -50,29 +49,6 @@ static void BuildZipArchive(const std::map<std::string, std::string>& file_map, 
  ASSERT_EQ(0, fclose(zip_file));

}



TEST(InstallTest, verify_package_compatibility_no_entry) {

  TemporaryFile temp_file;

  // The archive must have something to be opened correctly.

  BuildZipArchive({ { "dummy_entry", "" } }, temp_file.release(), kCompressStored);



  // Doesn't contain compatibility zip entry.

  ZipArchiveHandle zip;

  ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));

  ASSERT_TRUE(verify_package_compatibility(zip));

  CloseArchive(zip);

}



TEST(InstallTest, verify_package_compatibility_invalid_entry) {

  TemporaryFile temp_file;

  BuildZipArchive({ { "compatibility.zip", "" } }, temp_file.release(), kCompressStored);



  // Empty compatibility zip entry.

  ZipArchiveHandle zip;

  ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));

  ASSERT_FALSE(verify_package_compatibility(zip));

  CloseArchive(zip);

}



TEST(InstallTest, read_metadata_from_package_smoke) {

  TemporaryFile temp_file;

  const std::string content("abc=defg");
@@ -134,64 +110,6 @@ TEST(InstallTest, read_wipe_ab_partition_list) { 
  ASSERT_EQ(expected, read_partition_list);

}



TEST(InstallTest, verify_package_compatibility_with_libvintf_malformed_xml) {

  TemporaryFile compatibility_zip_file;

  std::string malformed_xml = "malformed";

  BuildZipArchive({ { "system_manifest.xml", malformed_xml } }, compatibility_zip_file.release(),

                  kCompressDeflated);



  TemporaryFile temp_file;

  std::string compatibility_zip_content;

  ASSERT_TRUE(

      android::base::ReadFileToString(compatibility_zip_file.path, &compatibility_zip_content));

  BuildZipArchive({ { "compatibility.zip", compatibility_zip_content } }, temp_file.release(),

                  kCompressStored);



  ZipArchiveHandle zip;

  ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));

  std::vector<std::string> compatibility_info;

  compatibility_info.push_back(malformed_xml);

  // Malformed compatibility zip is expected to be rejected by libvintf. But we defer that to

  // libvintf.

  std::string err;

  bool result =

      android::vintf::VintfObjectRecovery::CheckCompatibility(compatibility_info, &err) == 0;

  ASSERT_EQ(result, verify_package_compatibility(zip));

  CloseArchive(zip);

}



TEST(InstallTest, verify_package_compatibility_with_libvintf_system_manifest_xml) {

  static constexpr const char* system_manifest_xml_path = "/system/manifest.xml";

  if (access(system_manifest_xml_path, R_OK) == -1) {

    GTEST_LOG_(INFO) << "Test skipped on devices w/o /system/manifest.xml.";

    return;

  }

  std::string system_manifest_xml_content;

  ASSERT_TRUE(

      android::base::ReadFileToString(system_manifest_xml_path, &system_manifest_xml_content));

  TemporaryFile compatibility_zip_file;

  BuildZipArchive({ { "system_manifest.xml", system_manifest_xml_content } },

                  compatibility_zip_file.release(), kCompressDeflated);



  TemporaryFile temp_file;

  std::string compatibility_zip_content;

  ASSERT_TRUE(

      android::base::ReadFileToString(compatibility_zip_file.path, &compatibility_zip_content));

  BuildZipArchive({ { "compatibility.zip", compatibility_zip_content } }, temp_file.release(),

                  kCompressStored);



  ZipArchiveHandle zip;

  ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));

  std::vector<std::string> compatibility_info;

  compatibility_info.push_back(system_manifest_xml_content);

  std::string err;

  bool result =

      android::vintf::VintfObjectRecovery::CheckCompatibility(compatibility_info, &err) == 0;

  // Make sure the result is consistent with libvintf library.

  ASSERT_EQ(result, verify_package_compatibility(zip));

  CloseArchive(zip);

}



TEST(InstallTest, SetUpNonAbUpdateCommands) {

  TemporaryFile temp_file;

  static constexpr const char* UPDATE_BINARY_NAME = "META-INF/com/google/android/update-binary";