Merge "libandroidfw: introduce ExecuteBinary (POSIX only)" (120b7fba) · Commits · e / os / android_frameworks_base

libs/androidfw/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -50,6 +50,7 @@ cc_library {
		"LocaleData.cpp",
		"misc.cpp",
		"ObbFile.cpp",
		"PosixUtils.cpp",
		"ResourceTypes.cpp",
		"ResourceUtils.cpp",
		"StreamingZipInflater.cpp",
		@@ -156,6 +157,7 @@ cc_test {
		srcs: [
		"tests/BackupData_test.cpp",
		"tests/ObbFile_test.cpp",
		"tests/PosixUtils_test.cpp",
		],
		shared_libs: common_test_libs + ["libui"],
		},

libs/androidfw/PosixUtils.cpp

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#ifdef _WIN32
		// nothing to see here
		#else
		#include <memory>
		#include <string>
		#include <vector>

		#include <sys/types.h>
		#include <sys/wait.h>
		#include <unistd.h>

		#include "android-base/logging.h"

		#include "androidfw/PosixUtils.h"

		namespace {

		std::unique_ptr<std::string> ReadFile(int fd) {
		std::unique_ptr<std::string> str(new std::string());
		char buf[1024];
		ssize_t r;
		while ((r = read(fd, buf, sizeof(buf))) > 0) {
		str->append(buf, r);
		}
		if (r != 0) {
		return nullptr;
		}
		return str;
		}

		}

		namespace android {
		namespace util {

		std::unique_ptr<ProcResult> ExecuteBinary(const std::vector<std::string>& argv) {
		int stdout[2]; // stdout[0] read, stdout[1] write
		if (pipe(stdout) != 0) {
		PLOG(ERROR) << "pipe";
		return nullptr;
		}

		int stderr[2]; // stdout[0] read, stdout[1] write
		if (pipe(stderr) != 0) {
		PLOG(ERROR) << "pipe";
		close(stdout[0]);
		close(stdout[1]);
		return nullptr;
		}

		char const argv0 = (char const)malloc(sizeof(char) (argv.size() + 1));
		for (size_t i = 0; i < argv.size(); i++) {
		argv0[i] = argv[i].c_str();
		}
		argv0[argv.size()] = nullptr;
		switch (fork()) {
		case -1: // error
		free(argv0);
		PLOG(ERROR) << "fork";
		return nullptr;
		case 0: // child
		close(stdout[0]);
		if (dup2(stdout[1], STDOUT_FILENO) == -1) {
		abort();
		}
		close(stderr[0]);
		if (dup2(stderr[1], STDERR_FILENO) == -1) {
		abort();
		}
		execvp(argv0[0], const_cast<char* const*>(argv0));
		PLOG(ERROR) << "execv";
		abort();
		default: // parent
		free(argv0);
		close(stdout[1]);
		close(stderr[1]);
		int status;
		wait(&status);
		if (!WIFEXITED(status)) {
		return nullptr;
		}
		std::unique_ptr<ProcResult> result(new ProcResult());
		result->status = status;
		const auto out = ReadFile(stdout[0]);
		result->stdout = out ? *out : "";
		close(stdout[0]);
		const auto err = ReadFile(stderr[0]);
		result->stderr = err ? *err : "";
		close(stderr[0]);
		return result;
		}
		}

		} // namespace util
		} // namespace android
		#endif

libs/androidfw/include/androidfw/PosixUtils.h

0 → 100644

+36 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 <memory>
		#include <string>
		#include <vector>

		namespace android {
		namespace util {

		struct ProcResult {
		int status;
		std::string stdout;
		std::string stderr;
		};

		// Fork, exec and wait for an external process. Return nullptr if the process could not be launched,
		// otherwise a ProcResult containing the external process' exit status and captured stdout and
		// stderr.
		std::unique_ptr<ProcResult> ExecuteBinary(const std::vector<std::string>& argv);

		} // namespace util
		} // namespace android

libs/androidfw/tests/PosixUtils_test.cpp

0 → 100644

+55 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 <utility>

		#include "androidfw/PosixUtils.h"

		#include "TestHelpers.h"

		using ::testing::IsNull;
		using ::testing::NotNull;

		namespace android {
		namespace util {

		TEST(PosixUtilsTest, AbsolutePathToBinary) {
		const auto result = ExecuteBinary({"/bin/date", "--help"});
		ASSERT_THAT(result, NotNull());
		ASSERT_EQ(result->status, 0);
		ASSERT_EQ(result->stdout.find("usage: date "), 0);
		}

		TEST(PosixUtilsTest, RelativePathToBinary) {
		const auto result = ExecuteBinary({"date", "--help"});
		ASSERT_THAT(result, NotNull());
		ASSERT_EQ(result->status, 0);
		ASSERT_EQ(result->stdout.find("usage: date "), 0);
		}

		TEST(PosixUtilsTest, BadParameters) {
		const auto result = ExecuteBinary({"/bin/date", "--this-parameter-is-not-supported"});
		ASSERT_THAT(result, NotNull());
		ASSERT_NE(result->status, 0);
		}

		TEST(PosixUtilsTest, NoSuchBinary) {
		const auto result = ExecuteBinary({"/this/binary/does/not/exist"});
		ASSERT_THAT(result, IsNull());
		}

		} // android
		} // util