Merge "Revert "init: use read_file and write_file to implement do_copy builtin"" am: 3428d0c2c0 (9817f4f3) · Commits · e / os / android_system_core

init/README.md

+0 −5

Original line number	Original line	Diff line number	Diff line
	@@ -286,11 +286,6 @@ Commands
	`copy <src> <dst>`		`copy <src> <dst>`
	> Copies a file. Similar to write, but useful for binary/large		> Copies a file. Similar to write, but useful for binary/large
	amounts of data.		amounts of data.
	Regarding to the src file, copying from symbol link file and world-writable
	or group-writable files are not allowed.
	Regarding to the dst file, the default mode created is 0600 if it does not
	exist. And it will be truncated if dst file is a normal regular file and
	already exists.

	`domainname <name>`		`domainname <name>`
	> Set the domain name.		> Set the domain name.

init/builtins.cpp

+55 −5

Original line number	Original line	Diff line number	Diff line
	@@ -702,11 +702,61 @@ static int do_write(const std::vector<std::string>& args) {
	}		}

	static int do_copy(const std::vector<std::string>& args) {		static int do_copy(const std::vector<std::string>& args) {
	std::string data;		char *buffer = NULL;
	if (read_file(args[1].c_str(), &data)) {		int rc = 0;
	return write_file(args[2].c_str(), data.data()) ? 0 : 1;		int fd1 = -1, fd2 = -1;
			struct stat info;
			int brtw, brtr;
			char *p;

			if (stat(args[1].c_str(), &info) < 0)
			return -1;

			if ((fd1 = open(args[1].c_str(), O_RDONLY\|O_CLOEXEC)) < 0)
			goto out_err;

			if ((fd2 = open(args[2].c_str(), O_WRONLY\|O_CREAT\|O_TRUNC\|O_CLOEXEC, 0660)) < 0)
			goto out_err;

			if (!(buffer = (char*) malloc(info.st_size)))
			goto out_err;

			p = buffer;
			brtr = info.st_size;
			while(brtr) {
			rc = read(fd1, p, brtr);
			if (rc < 0)
			goto out_err;
			if (rc == 0)
			break;
			p += rc;
			brtr -= rc;
	}		}
	return 1;
			p = buffer;
			brtw = info.st_size;
			while(brtw) {
			rc = write(fd2, p, brtw);
			if (rc < 0)
			goto out_err;
			if (rc == 0)
			break;
			p += rc;
			brtw -= rc;
			}

			rc = 0;
			goto out;
			out_err:
			rc = -1;
			out:
			if (buffer)
			free(buffer);
			if (fd1 >= 0)
			close(fd1);
			if (fd2 >= 0)
			close(fd2);
			return rc;
	}		}

	static int do_chown(const std::vector<std::string>& args) {		static int do_chown(const std::vector<std::string>& args) {

init/util.cpp

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -185,8 +185,8 @@ bool read_file(const char* path, std::string* content) {
	}		}

	bool write_file(const char* path, const char* content) {		bool write_file(const char* path, const char* content) {
	android::base::unique_fd fd(TEMP_FAILURE_RETRY(		android::base::unique_fd fd(
	open(path, O_WRONLY \| O_CREAT \| O_NOFOLLOW \| O_TRUNC \| O_CLOEXEC, 0600)));		TEMP_FAILURE_RETRY(open(path, O_WRONLY \| O_CREAT \| O_NOFOLLOW \| O_CLOEXEC, 0600)));
	if (fd == -1) {		if (fd == -1) {
	PLOG(ERROR) << "write_file: Unable to open '" << path << "'";		PLOG(ERROR) << "write_file: Unable to open '" << path << "'";
	return false;		return false;

init/util_test.cpp

+0 −71

Original line number	Original line	Diff line number	Diff line
	@@ -17,15 +17,9 @@
	#include "util.h"		#include "util.h"

	#include <errno.h>		#include <errno.h>
	#include <fcntl.h>

	#include <sys/stat.h>

	#include <gtest/gtest.h>		#include <gtest/gtest.h>

	#include <android-base/stringprintf.h>
	#include <android-base/test_utils.h>

	TEST(util, read_file_ENOENT) {		TEST(util, read_file_ENOENT) {
	std::string s("hello");		std::string s("hello");
	errno = 0;		errno = 0;
	@@ -34,35 +28,6 @@ TEST(util, read_file_ENOENT) {
	EXPECT_EQ("", s); // s was cleared.		EXPECT_EQ("", s); // s was cleared.
	}		}

	TEST(util, read_file_group_writeable) {
	std::string s("hello");
	TemporaryFile tf;
	ASSERT_TRUE(tf.fd != -1);
	EXPECT_TRUE(write_file(tf.path, s.c_str())) << strerror(errno);
	EXPECT_NE(-1, fchmodat(AT_FDCWD, tf.path, 0620, AT_SYMLINK_NOFOLLOW)) << strerror(errno);
	EXPECT_FALSE(read_file(tf.path, &s)) << strerror(errno);
	EXPECT_EQ("", s); // s was cleared.
	}

	TEST(util, read_file_world_writeable) {
	std::string s("hello");
	TemporaryFile tf;
	ASSERT_TRUE(tf.fd != -1);
	EXPECT_TRUE(write_file(tf.path, s.c_str())) << strerror(errno);
	EXPECT_NE(-1, fchmodat(AT_FDCWD, tf.path, 0602, AT_SYMLINK_NOFOLLOW)) << strerror(errno);
	EXPECT_FALSE(read_file(tf.path, &s)) << strerror(errno);
	EXPECT_EQ("", s); // s was cleared.
	}

	TEST(util, read_file_symbol_link) {
	std::string s("hello");
	errno = 0;
	// lrwxrwxrwx 1 root root 13 1970-01-01 00:00 charger -> /sbin/healthd
	EXPECT_FALSE(read_file("/charger", &s));
	EXPECT_EQ(ELOOP, errno);
	EXPECT_EQ("", s); // s was cleared.
	}

	TEST(util, read_file_success) {		TEST(util, read_file_success) {
	std::string s("hello");		std::string s("hello");
	EXPECT_TRUE(read_file("/proc/version", &s));		EXPECT_TRUE(read_file("/proc/version", &s));
	@@ -72,42 +37,6 @@ TEST(util, read_file_success) {
	EXPECT_STREQ("Linux", s.c_str());		EXPECT_STREQ("Linux", s.c_str());
	}		}

	TEST(util, write_file_not_exist) {
	std::string s("hello");
	std::string s2("hello");
	TemporaryDir test_dir;
	std::string path = android::base::StringPrintf("%s/does-not-exist", test_dir.path);
	EXPECT_TRUE(write_file(path.c_str(), s.c_str()));
	EXPECT_TRUE(read_file(path.c_str(), &s2));
	EXPECT_EQ(s, s2);
	struct stat sb;
	int fd = open(path.c_str(), O_RDONLY \| O_NOFOLLOW \| O_CLOEXEC);
	EXPECT_NE(-1, fd);
	EXPECT_EQ(0, fstat(fd, &sb));
	EXPECT_NE(0u, sb.st_mode & S_IRUSR);
	EXPECT_NE(0u, sb.st_mode & S_IWUSR);
	EXPECT_EQ(0u, sb.st_mode & S_IXUSR);
	EXPECT_EQ(0u, sb.st_mode & S_IRGRP);
	EXPECT_EQ(0u, sb.st_mode & S_IWGRP);
	EXPECT_EQ(0u, sb.st_mode & S_IXGRP);
	EXPECT_EQ(0u, sb.st_mode & S_IROTH);
	EXPECT_EQ(0u, sb.st_mode & S_IWOTH);
	EXPECT_EQ(0u, sb.st_mode & S_IXOTH);
	EXPECT_EQ(0, unlink(path.c_str()));
	}

	TEST(util, write_file_exist) {
	std::string s2("");
	TemporaryFile tf;
	ASSERT_TRUE(tf.fd != -1);
	EXPECT_TRUE(write_file(tf.path, "1hello1")) << strerror(errno);
	EXPECT_TRUE(read_file(tf.path, &s2));
	EXPECT_STREQ("1hello1", s2.c_str());
	EXPECT_TRUE(write_file(tf.path, "2hello2"));
	EXPECT_TRUE(read_file(tf.path, &s2));
	EXPECT_STREQ("2hello2", s2.c_str());
	}

	TEST(util, decode_uid) {		TEST(util, decode_uid) {
	EXPECT_EQ(0U, decode_uid("root"));		EXPECT_EQ(0U, decode_uid("root"));
	EXPECT_EQ(UINT_MAX, decode_uid("toot"));		EXPECT_EQ(UINT_MAX, decode_uid("toot"));