tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Bring back file-based OTA edify functions [1/2]

Browse source 
Author: Tom Marshall <tdm.code@gmail.com>
Date:   Wed Oct 25 20:27:08 2017 +0200

    Revert "kill package_extract_dir"

    changes for P:
     - bring back the mkdir_recursively variant which takes a timestamp.
     - add libziparchive dependency
     - fix otautil header paths

    changes for Q:
     - change ziputil naming convention to lowercase

    This reverts commit 53c38b1538.

    Change-Id: I71c488e96a1f23aace3c38fc283aae0165129a12

Author: Tom Marshall <tdm.code@gmail.com>
Date:   Thu Dec 14 22:37:17 2017 +0100

    Revert "Remove the obsolete package_extract_dir() test"

    This reverts commit bb7e005a79.

    Change-Id: I643235d6605d7da2a189eca10ec999b25c23e1f9

Author: Tom Marshall <tdm.code@gmail.com>
Date:   Wed Aug 23 18:14:00 2017 +0000

    Revert "updater: Remove some obsoleted functions for file-based OTA."

    This reverts commit 63d786cf22.

    These functions will be used for third party OTA zips, so keep them.

    Change-Id: I24b67ba4c86f8f86d0a41429a395fece1a383efd

Author: Stricted <info@stricted.net>
Date:   Mon Mar 12 18:11:56 2018 +0100

    recovery: updater: Fix SymlinkFn args

    Change-Id: If2ba1b7a8b5ac471a2db84f352273fd0ea7c81a2

Author: Simon Shields <simon@lineageos.org>
Date:   Thu Aug 9 01:17:21 2018 +1000

    Revert "updater: Remove dead make_parents()."

    This reverts commit 5902691764.

    Change-Id: I69eadf1a091f6ecd45531789dedf72a178a055ba

Author: Simon Shields <simon@lineageos.org>
Date:   Thu Aug 9 01:20:40 2018 +1000

    Revert "otautil: Delete dirUnlinkHierarchy()."

    changes for P:
     - Fix missing PATH_MAX macro from limits.h

    This reverts commit 7934985e0c.

    Change-Id: I67ce71a1644b58a393dce45a6c3dee97830b9ee4

Author: XiNGRZ <chenxingyu92@gmail.com>
Date:   Tue Dec 3 14:31:56 2019 +0800

    updater: Fix lost capabilities of set_metadata

    This was broken since Android O. During a file-based incremental OTA,
    capability flags were cleared but not being set again properly, leading
    some critical processes (e.g. surfaceflinger and pm-service) fails.

    For more details, see: 65b8d749f7

    Change-Id: I20e616cd83ec1cd1b79717a6703919316ad77938

[mikeioannina]: Squash for Q and run through clang-format

[Chippa_a]: Adapt for Android R updater and libziparchive API

Change-Id: I91973bc9e9f8d100688c0112fda9043fd45eb86a
This commit is contained in:
Michael Bestas 2019-09-19 21:42:12 +03:00 committed by zlewchan
parent 505722d4e5
commit 0e844b0289
8 changed files with 507 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
otautil/Android.bp
View file

@ -41,6 +41,7 @@ cc_library_static {
"rangeset.cpp",
"sysutil.cpp",
"verifier.cpp",
"ziputil.cpp",
],
shared_libs: [

62
otautil/dirutil.cpp
View file

@ -48,6 +48,11 @@ static DirStatus dir_status(const std::string& path) {
int mkdir_recursively(const std::string& input_path, mode_t mode, bool strip_filename,
const selabel_handle* sehnd) {
return mkdir_recursively(input_path, mode, strip_filename, sehnd, NULL);
}
int mkdir_recursively(const std::string& input_path, mode_t mode, bool strip_filename,
const selabel_handle* sehnd, const struct utimbuf* timestamp) {
// Check for an empty string before we bother making any syscalls.
if (input_path.empty()) {
errno = ENOENT;
@ -104,6 +109,9 @@ int mkdir_recursively(const std::string& input_path, mode_t mode, bool strip_fil
if (err != 0) {
return -1;
}
if (timestamp != NULL && utime(dir_path.c_str(), timestamp)) {
return -1;
}
break;
}
default:
@ -114,3 +122,57 @@ int mkdir_recursively(const std::string& input_path, mode_t mode, bool strip_fil
}
return 0;
}
int dirUnlinkHierarchy(const char* path) {
struct stat st;
DIR* dir;
struct dirent* de;
int fail = 0;
/* is it a file or directory? */
if (lstat(path, &st) < 0) {
return -1;
}
/* a file, so unlink it */
if (!S_ISDIR(st.st_mode)) {
return unlink(path);
}
/* a directory, so open handle */
dir = opendir(path);
if (dir == NULL) {
return -1;
}
/* recurse over components */
errno = 0;
while ((de = readdir(dir)) != NULL) {
// TODO: don't blow the stack
char dn[PATH_MAX];
if (!strcmp(de->d_name, "..") || !strcmp(de->d_name, ".")) {
continue;
}
snprintf(dn, sizeof(dn), "%s/%s", path, de->d_name);
if (dirUnlinkHierarchy(dn) < 0) {
fail = 1;
break;
}
errno = 0;
}
/* in case readdir or unlink_recursive failed */
if (fail || errno < 0) {
int save = errno;
closedir(dir);
errno = save;
return -1;
}
/* close directory handle */
if (closedir(dir) < 0) {
return -1;
}
/* delete target directory */
return rmdir(path);
}

9
otautil/include/otautil/dirutil.h
View file

@ -17,7 +17,9 @@
#ifndef OTAUTIL_DIRUTIL_H_
#define OTAUTIL_DIRUTIL_H_
#include <limits.h> // PATH_MAX
#include <sys/stat.h> // mode_t
#include <utime.h> // utime/utimbuf
#include <string>
@ -36,4 +38,11 @@ struct selabel_handle;
int mkdir_recursively(const std::string& path, mode_t mode, bool strip_filename,
const struct selabel_handle* sehnd);
// As above, but if timestamp is non-NULL, directories will be timestamped accordingly.
int mkdir_recursively(const std::string& input_path, mode_t mode, bool strip_filename,
const selabel_handle* sehnd, const struct utimbuf* timestamp);
// rm -rf <path>
int dirUnlinkHierarchy(const char* path);
#endif // OTAUTIL_DIRUTIL_H_

57
otautil/include/otautil/ziputil.h Normal file
View file

@ -0,0 +1,57 @@
/*
* Copyright (C) 2016 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.
*/
#ifndef _OTAUTIL_ZIPUTIL_H
#define _OTAUTIL_ZIPUTIL_H
#include <utime.h>
#include <string>
#include <selinux/label.h>
#include <ziparchive/zip_archive.h>
/*
* Inflate all files under zip_path to the directory specified by
* dest_path, which must exist and be a writable directory. The zip_path
* is allowed to be an empty string, in which case the whole package
* will be extracted.
*
* Directory entries are not extracted.
*
* The immediate children of zip_path will become the immediate
* children of dest_path; e.g., if the archive contains the entries
*
* a/b/c/one
* a/b/c/two
* a/b/c/d/three
*
* and ExtractPackageRecursive(a, "a/b/c", "/tmp", ...) is called, the resulting
* files will be
*
* /tmp/one
* /tmp/two
* /tmp/d/three
*
* If timestamp is non-NULL, file timestamps will be set accordingly.
*
* Returns true on success, false on failure.
*/
bool ExtractPackageRecursive(ZipArchiveHandle zip, const std::string& zip_path,
const std::string& dest_path, const struct utimbuf* timestamp,
struct selabel_handle* sehnd);
#endif // _OTAUTIL_ZIPUTIL_H

118
otautil/ziputil.cpp Normal file
View file

@ -0,0 +1,118 @@
/*
* Copyright (C) 2016 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 "otautil/ziputil.h"
#include <errno.h>
#include <fcntl.h>
#include <utime.h>
#include <string>
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <selinux/label.h>
#include <selinux/selinux.h>
#include <ziparchive/zip_archive.h>
#include "otautil/dirutil.h"
static constexpr mode_t UNZIP_DIRMODE = 0755;
static constexpr mode_t UNZIP_FILEMODE = 0644;
bool ExtractPackageRecursive(ZipArchiveHandle zip, const std::string& zip_path,
const std::string& dest_path, const struct utimbuf* timestamp,
struct selabel_handle* sehnd) {
if (!zip_path.empty() && zip_path[0] == '/') {
LOG(ERROR) << "ExtractPackageRecursive(): zip_path must be a relative path " << zip_path;
return false;
}
if (dest_path.empty() || dest_path[0] != '/') {
LOG(ERROR) << "ExtractPackageRecursive(): dest_path must be an absolute path " << dest_path;
return false;
}
void* cookie;
std::string target_dir(dest_path);
if (dest_path.back() != '/') {
target_dir += '/';
}
std::string prefix_path(zip_path);
if (!zip_path.empty() && zip_path.back() != '/') {
prefix_path += '/';
}
int ret = StartIteration(zip, &cookie, prefix_path, "");
if (ret != 0) {
LOG(ERROR) << "failed to start iterating zip entries.";
return false;
}
std::unique_ptr<void, decltype(&EndIteration)> guard(cookie, EndIteration);
ZipEntry entry;
std::string name;
int extractCount = 0;
while (Next(cookie, &entry, &name) == 0) {
CHECK_LE(prefix_path.size(), name.size());
std::string path = target_dir + name.substr(prefix_path.size());
// Skip dir.
if (path.back() == '/') {
continue;
}
if (mkdir_recursively(path.c_str(), UNZIP_DIRMODE, true, sehnd, timestamp) != 0) {
LOG(ERROR) << "failed to create dir for " << path;
return false;
}
char* secontext = NULL;
if (sehnd) {
selabel_lookup(sehnd, &secontext, path.c_str(), UNZIP_FILEMODE);
setfscreatecon(secontext);
}
android::base::unique_fd fd(open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, UNZIP_FILEMODE));
if (fd == -1) {
PLOG(ERROR) << "Can't create target file \"" << path << "\"";
return false;
}
if (secontext) {
freecon(secontext);
setfscreatecon(NULL);
}
int err = ExtractEntryToFile(zip, &entry, fd);
if (err != 0) {
LOG(ERROR) << "Error extracting \"" << path << "\" : " << ErrorCodeString(err);
return false;
}
if (fsync(fd) != 0) {
PLOG(ERROR) << "Error syncing file descriptor when extracting \"" << path << "\"";
return false;
}
if (timestamp != nullptr && utime(path.c_str(), timestamp)) {
PLOG(ERROR) << "Error touching \"" << path << "\"";
return false;
}
LOG(INFO) << "Extracted file \"" << path << "\"";
++extractCount;
}
LOG(INFO) << "Extracted " << extractCount << " file(s)";
return true;
}

32
tests/unit/dirutil_test.cpp
View file

@ -107,3 +107,35 @@ TEST(DirUtilTest, create_mode) {
ASSERT_EQ(0, rmdir((prefix + "/a/b").c_str()));
ASSERT_EQ(0, rmdir((prefix + "/a").c_str()));
}
TEST(DirUtilTest, unlink_invalid) {
// File doesn't exist.
ASSERT_EQ(-1, dirUnlinkHierarchy("doesntexist"));
// Nonexistent directory.
TemporaryDir td;
std::string path(td.path);
ASSERT_EQ(-1, dirUnlinkHierarchy((path + "/a").c_str()));
ASSERT_EQ(ENOENT, errno);
}
TEST(DirUtilTest, unlink_smoke) {
// Unlink a file.
TemporaryFile tf;
ASSERT_EQ(0, dirUnlinkHierarchy(tf.path));
ASSERT_EQ(-1, access(tf.path, F_OK));
TemporaryDir td;
std::string path(td.path);
constexpr mode_t mode = 0700;
ASSERT_EQ(0, mkdir((path + "/a").c_str(), mode));
ASSERT_EQ(0, mkdir((path + "/a/b").c_str(), mode));
ASSERT_EQ(0, mkdir((path + "/a/b/c").c_str(), mode));
ASSERT_EQ(0, mkdir((path + "/a/d").c_str(), mode));
// Remove "../a" recursively.
ASSERT_EQ(0, dirUnlinkHierarchy((path + "/a").c_str()));
// Verify it's gone.
ASSERT_EQ(-1, access((path + "/a").c_str(), F_OK));
}

37
tests/unit/zip_test.cpp
View file

@ -22,11 +22,48 @@
#include <android-base/file.h>
#include <gtest/gtest.h>
#include <otautil/ziputil.h>
#include <ziparchive/zip_archive.h>
#include "common/test_constants.h"
#include "otautil/sysutil.h"
TEST(ZipTest, ExtractPackageRecursive) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// Extract the whole package into a temp directory.
TemporaryDir td;
ASSERT_NE(nullptr, td.path);
ExtractPackageRecursive(handle, "", td.path, nullptr, nullptr);
// Make sure all the files are extracted correctly.
std::string path(td.path);
ASSERT_EQ(0, access((path + "/a.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b/c.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b/d.txt").c_str(), F_OK));
// The content of the file is the same as expected.
std::string content1;
ASSERT_TRUE(android::base::ReadFileToString(path + "/a.txt", &content1));
ASSERT_EQ(kATxtContents, content1);
std::string content2;
ASSERT_TRUE(android::base::ReadFileToString(path + "/b/d.txt", &content2));
ASSERT_EQ(kDTxtContents, content2);
CloseArchive(handle);
// Clean up.
ASSERT_EQ(0, unlink((path + "/a.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b/c.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b/d.txt").c_str()));
ASSERT_EQ(0, rmdir((path + "/b").c_str()));
}
TEST(ZipTest, OpenFromMemory) {
std::string zip_path = from_testdata_base("ziptest_fake-update.zip");
MemMapping map;

191
tests/unit/ziputil_test.cpp Normal file
View file

@ -0,0 +1,191 @@
/*
* Copyright 2016 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 <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include <android-base/file.h>
#include <android-base/test_utils.h>
#include <gtest/gtest.h>
#include <otautil/ZipUtil.h>
#include <ziparchive/zip_archive.h>
#include "common/test_constants.h"
TEST(ZipUtilTest, invalid_args) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// zip_path must be a relative path.
ASSERT_FALSE(ExtractPackageRecursive(handle, "/a/b", "/tmp", nullptr, nullptr));
// dest_path must be an absolute path.
ASSERT_FALSE(ExtractPackageRecursive(handle, "a/b", "tmp", nullptr, nullptr));
ASSERT_FALSE(ExtractPackageRecursive(handle, "a/b", "", nullptr, nullptr));
CloseArchive(handle);
}
TEST(ZipUtilTest, extract_all) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// Extract the whole package into a temp directory.
TemporaryDir td;
ExtractPackageRecursive(handle, "", td.path, nullptr, nullptr);
// Make sure all the files are extracted correctly.
std::string path(td.path);
ASSERT_EQ(0, access((path + "/a.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b/c.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/b/d.txt").c_str(), F_OK));
// The content of the file is the same as expected.
std::string content1;
ASSERT_TRUE(android::base::ReadFileToString(path + "/a.txt", &content1));
ASSERT_EQ(kATxtContents, content1);
std::string content2;
ASSERT_TRUE(android::base::ReadFileToString(path + "/b/d.txt", &content2));
ASSERT_EQ(kDTxtContents, content2);
// Clean up the temp files under td.
ASSERT_EQ(0, unlink((path + "/a.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b/c.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/b/d.txt").c_str()));
ASSERT_EQ(0, rmdir((path + "/b").c_str()));
CloseArchive(handle);
}
TEST(ZipUtilTest, extract_prefix_with_slash) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// Extract all the entries starting with "b/".
TemporaryDir td;
ExtractPackageRecursive(handle, "b/", td.path, nullptr, nullptr);
// Make sure all the files with "b/" prefix are extracted correctly.
std::string path(td.path);
ASSERT_EQ(0, access((path + "/c.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/d.txt").c_str(), F_OK));
// And the rest are not extracted.
ASSERT_EQ(-1, access((path + "/a.txt").c_str(), F_OK));
ASSERT_EQ(ENOENT, errno);
ASSERT_EQ(-1, access((path + "/b.txt").c_str(), F_OK));
ASSERT_EQ(ENOENT, errno);
// The content of the file is the same as expected.
std::string content1;
ASSERT_TRUE(android::base::ReadFileToString(path + "/c.txt", &content1));
ASSERT_EQ(kCTxtContents, content1);
std::string content2;
ASSERT_TRUE(android::base::ReadFileToString(path + "/d.txt", &content2));
ASSERT_EQ(kDTxtContents, content2);
// Clean up the temp files under td.
ASSERT_EQ(0, unlink((path + "/c.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/d.txt").c_str()));
CloseArchive(handle);
}
TEST(ZipUtilTest, extract_prefix_without_slash) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// Extract all the file entries starting with "b/".
TemporaryDir td;
ExtractPackageRecursive(handle, "b", td.path, nullptr, nullptr);
// Make sure all the files with "b/" prefix are extracted correctly.
std::string path(td.path);
ASSERT_EQ(0, access((path + "/c.txt").c_str(), F_OK));
ASSERT_EQ(0, access((path + "/d.txt").c_str(), F_OK));
// And the rest are not extracted.
ASSERT_EQ(-1, access((path + "/a.txt").c_str(), F_OK));
ASSERT_EQ(ENOENT, errno);
ASSERT_EQ(-1, access((path + "/b.txt").c_str(), F_OK));
ASSERT_EQ(ENOENT, errno);
// The content of the file is the same as expected.
std::string content1;
ASSERT_TRUE(android::base::ReadFileToString(path + "/c.txt", &content1));
ASSERT_EQ(kCTxtContents, content1);
std::string content2;
ASSERT_TRUE(android::base::ReadFileToString(path + "/d.txt", &content2));
ASSERT_EQ(kDTxtContents, content2);
// Clean up the temp files under td.
ASSERT_EQ(0, unlink((path + "/c.txt").c_str()));
ASSERT_EQ(0, unlink((path + "/d.txt").c_str()));
CloseArchive(handle);
}
TEST(ZipUtilTest, set_timestamp) {
std::string zip_path = from_testdata_base("ziptest_valid.zip");
ZipArchiveHandle handle;
ASSERT_EQ(0, OpenArchive(zip_path.c_str(), &handle));
// Set the timestamp to 8/1/2008.
constexpr struct utimbuf timestamp = { 1217592000, 1217592000 };
// Extract all the entries starting with "b/".
TemporaryDir td;
ExtractPackageRecursive(handle, "b", td.path, &timestamp, nullptr);
// Make sure all the files with "b/" prefix are extracted correctly.
std::string path(td.path);
std::string file_c = path + "/c.txt";
std::string file_d = path + "/d.txt";
ASSERT_EQ(0, access(file_c.c_str(), F_OK));
ASSERT_EQ(0, access(file_d.c_str(), F_OK));
// Verify the timestamp.
timespec time;
time.tv_sec = 1217592000;
time.tv_nsec = 0;
struct stat sb;
ASSERT_EQ(0, stat(file_c.c_str(), &sb)) << strerror(errno);
ASSERT_EQ(time.tv_sec, static_cast<long>(sb.st_atime));
ASSERT_EQ(time.tv_sec, static_cast<long>(sb.st_mtime));
ASSERT_EQ(0, stat(file_d.c_str(), &sb)) << strerror(errno);
ASSERT_EQ(time.tv_sec, static_cast<long>(sb.st_atime));
ASSERT_EQ(time.tv_sec, static_cast<long>(sb.st_mtime));
// Clean up the temp files under td.
ASSERT_EQ(0, unlink(file_c.c_str()));
ASSERT_EQ(0, unlink(file_d.c_str()));
CloseArchive(handle);
}