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

Commit 281531bd authored by Wonsik Kim's avatar Wonsik Kim
Browse files

Revert "init: use read_file and write_file to implement do_copy builtin" 

Bug: 36726045
Test: gts-tradefed run gts --abi x86 -m GtsMediaTestCases -t com.google.android.media.gts.MediaCodecCencTest#testCENC_DASH_FMP4_H264_360P_PLAYREADY_CENC
This reverts commit 82bac0de.

Change-Id: I3b754f429499daec804a0ad25529294216c39a40
parent e41bf08f

init/README.md

+0 −5
Original line number Diff line number Diff line
@@ -286,11 +286,6 @@ Commands 
`copy <src> <dst>`

> Copies a file. Similar to write, but useful for binary/large

  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>`

> Set the domain name.

init/builtins.cpp

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



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

    std::string data;

    if (read_file(args[1].c_str(), &data)) {

        return write_file(args[2].c_str(), data.data()) ? 0 : 1;

    }

    return 1;

    char* buffer = NULL;

    int rc = 0;

    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;

    }



    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) {

init/util.cpp

+2 −2
Original line number 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) {

    android::base::unique_fd fd(TEMP_FAILURE_RETRY(

        open(path, O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0600)));

    android::base::unique_fd fd(

        TEMP_FAILURE_RETRY(open(path, O_WRONLY | O_CREAT | O_NOFOLLOW | O_CLOEXEC, 0600)));

    if (fd == -1) {

        PLOG(ERROR) << "write_file: Unable to open '" << path << "'";

        return false;

init/util_test.cpp

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



#include <errno.h>

#include <fcntl.h>



#include <sys/stat.h>



#include <gtest/gtest.h>



#include <android-base/stringprintf.h>

#include <android-base/test_utils.h>



TEST(util, read_file_ENOENT) {

  std::string s("hello");

  errno = 0;
@@ -34,35 +28,6 @@ TEST(util, read_file_ENOENT) { 
  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) {

  std::string s("hello");

  EXPECT_TRUE(read_file("/proc/version", &s));
@@ -72,42 +37,6 @@ TEST(util, read_file_success) { 
  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) {

  EXPECT_EQ(0U, decode_uid("root"));

  EXPECT_EQ(UINT_MAX, decode_uid("toot"));