Merge "kill package_extract_dir" am: 99e7216907 am: 49f9c969eb (d1b65aa6) · Commits · e / os / android_bootable_recovery

otautil/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,6 @@ cc_library_static {
		srcs: [
		"SysUtil.cpp",
		"DirUtil.cpp",
		"ZipUtil.cpp",
		"ThermalUtil.cpp",
		],

otautil/ZipUtil.cpp

deleted100644 → 0

+0 −120

Original line number	Diff line number	Diff line
		/*
		* 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 "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 "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 += '/';
		}
		const ZipString zip_prefix(prefix_path.c_str());

		int ret = StartIteration(zip, &cookie, &zip_prefix, nullptr);
		if (ret != 0) {
		LOG(ERROR) << "failed to start iterating zip entries.";
		return false;
		}

		std::unique_ptr<void, decltype(&EndIteration)> guard(cookie, EndIteration);
		ZipEntry entry;
		ZipString name;
		int extractCount = 0;
		while (Next(cookie, &entry, &name) == 0) {
		std::string entry_name(name.name, name.name + name.name_length);
		CHECK_LE(prefix_path.size(), entry_name.size());
		std::string path = target_dir + entry_name.substr(prefix_path.size());
		// Skip dir.
		if (path.back() == '/') {
		continue;
		}

		if (dirCreateHierarchy(path.c_str(), UNZIP_DIRMODE, timestamp, true, sehnd) != 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;
		}

otautil/ZipUtil.h

deleted100644 → 0

+0 −57

Original line number	Diff line number	Diff line
		/*
		* 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

tests/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -39,7 +39,6 @@ LOCAL_SRC_FILES := \
		unit/rangeset_test.cpp \
		unit/sysutil_test.cpp \
		unit/zip_test.cpp \
		unit/ziputil_test.cpp

		LOCAL_C_INCLUDES := bootable/recovery
		LOCAL_SHARED_LIBRARIES := liblog

tests/unit/zip_test.cpp

+0 −37

Original line number	Diff line number	Diff line
		@@ -24,47 +24,10 @@
		#include <android-base/test_utils.h>
		#include <gtest/gtest.h>
		#include <otautil/SysUtil.h>
		#include <otautil/ZipUtil.h>
		#include <ziparchive/zip_archive.h>

		#include "common/test_constants.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_dummy-update.zip");
		MemMapping map;