diff options
| -rw-r--r-- | updater/blockimg.cpp | 194 | ||||
| -rw-r--r-- | updater/install.cpp | 1484 | ||||
| -rw-r--r-- | updater/updater.cpp | 309 |
3 files changed, 994 insertions, 993 deletions
diff --git a/updater/blockimg.cpp b/updater/blockimg.cpp index c939cf89d..7257e2399 100644 --- a/updater/blockimg.cpp +++ b/updater/blockimg.cpp @@ -18,7 +18,6 @@ #include <errno.h> #include <dirent.h> #include <fcntl.h> -#include <inttypes.h> #include <linux/fs.h> #include <pthread.h> #include <stdarg.h> @@ -38,6 +37,7 @@ #include <unordered_map> #include <vector> +#include <android-base/logging.h> #include <android-base/parseint.h> #include <android-base/strings.h> #include <android-base/unique_fd.h> @@ -52,7 +52,7 @@ #include "print_sha1.h" #include "updater/updater.h" -#define BLOCKSIZE 4096 +static constexpr size_t BLOCKSIZE = 4096; // Set this to 0 to interpret 'erase' transfers to mean do a // BLKDISCARD ioctl (the normal behavior). Set to 1 to interpret @@ -121,7 +121,7 @@ static void parse_range(const std::string& range_text, RangeSet& rs) { return; err: - fprintf(stderr, "failed to parse range '%s'\n", range_text.c_str()); + LOG(ERROR) << "failed to parse range '" << range_text << "'"; exit(1); } @@ -149,11 +149,11 @@ static int read_all(int fd, uint8_t* data, size_t size) { ssize_t r = TEMP_FAILURE_RETRY(ota_read(fd, data+so_far, size-so_far)); if (r == -1) { failure_type = kFreadFailure; - fprintf(stderr, "read failed: %s\n", strerror(errno)); + PLOG(ERROR) << "read failed"; return -1; } else if (r == 0) { failure_type = kFreadFailure; - fprintf(stderr, "read reached unexpected EOF.\n"); + LOG(ERROR) << "read reached unexpected EOF."; return -1; } so_far += r; @@ -171,7 +171,7 @@ static int write_all(int fd, const uint8_t* data, size_t size) { ssize_t w = TEMP_FAILURE_RETRY(ota_write(fd, data+written, size-written)); if (w == -1) { failure_type = kFwriteFailure; - fprintf(stderr, "write failed: %s\n", strerror(errno)); + PLOG(ERROR) << "write failed"; return -1; } written += w; @@ -193,7 +193,7 @@ static bool discard_blocks(int fd, off64_t offset, uint64_t size) { uint64_t args[2] = {static_cast<uint64_t>(offset), size}; int status = ioctl(fd, BLKDISCARD, &args); if (status == -1) { - fprintf(stderr, "BLKDISCARD ioctl failed: %s\n", strerror(errno)); + PLOG(ERROR) << "BLKDISCARD ioctl failed"; return false; } return true; @@ -203,7 +203,7 @@ static bool check_lseek(int fd, off64_t offset, int whence) { off64_t rc = TEMP_FAILURE_RETRY(lseek64(fd, offset, whence)); if (rc == -1) { failure_type = kLseekFailure; - fprintf(stderr, "lseek64 failed: %s\n", strerror(errno)); + PLOG(ERROR) << "lseek64 failed"; return false; } return true; @@ -229,7 +229,7 @@ static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) { RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token); if (rss->p_remain == 0) { - fprintf(stderr, "range sink write overrun"); + LOG(ERROR) << "range sink write overrun"; return 0; } @@ -426,7 +426,7 @@ static int LoadSrcTgtVersion1(CommandParameters& params, RangeSet& tgt, size_t& std::vector<uint8_t>& buffer, int fd) { if (params.cpos + 1 >= params.tokens.size()) { - fprintf(stderr, "invalid parameters\n"); + LOG(ERROR) << "invalid parameters"; return -1; } @@ -455,8 +455,8 @@ static int VerifyBlocks(const std::string& expected, const std::vector<uint8_t>& if (hexdigest != expected) { if (printerror) { - fprintf(stderr, "failed to verify blocks (expected %s, read %s)\n", - expected.c_str(), hexdigest.c_str()); + LOG(ERROR) << "failed to verify blocks (expected " << expected << ", read " + << hexdigest << ")"; } return -1; } @@ -492,7 +492,7 @@ static void EnumerateStash(const std::string& dirname, StashCallback callback, v if (directory == nullptr) { if (errno != ENOENT) { - fprintf(stderr, "opendir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno)); + PLOG(ERROR) << "opendir \"" << dirname << "\" failed"; } return; } @@ -515,7 +515,7 @@ static void UpdateFileSize(const std::string& fn, void* data) { struct stat sb; if (stat(fn.c_str(), &sb) == -1) { - fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "stat \"" << fn << "\" failed"; return; } @@ -529,10 +529,10 @@ static void UpdateFileSize(const std::string& fn, void* data) { static void DeleteFile(const std::string& fn, void* /* data */) { if (!fn.empty()) { - fprintf(stderr, "deleting %s\n", fn.c_str()); + LOG(INFO) << "deleting " << fn; if (unlink(fn.c_str()) == -1 && errno != ENOENT) { - fprintf(stderr, "unlink \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "unlink \"" << fn << "\" failed"; } } } @@ -548,14 +548,14 @@ static void DeleteStash(const std::string& base) { return; } - fprintf(stderr, "deleting stash %s\n", base.c_str()); + LOG(INFO) << "deleting stash " << base; std::string dirname = GetStashFileName(base, "", ""); EnumerateStash(dirname, DeleteFile, nullptr); if (rmdir(dirname.c_str()) == -1) { if (errno != ENOENT && errno != ENOTDIR) { - fprintf(stderr, "rmdir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno)); + PLOG(ERROR) << "rmdir \"" << dirname << "\" failed"; } } } @@ -571,11 +571,11 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s allocate(src.size * BLOCKSIZE, buffer); if (ReadBlocks(src, buffer, params.fd) == -1) { - fprintf(stderr, "failed to read source blocks in stash map.\n"); + LOG(ERROR) << "failed to read source blocks in stash map."; return -1; } if (VerifyBlocks(id, buffer, src.size, true) != 0) { - fprintf(stderr, "failed to verify loaded source blocks in stash map.\n"); + LOG(ERROR) << "failed to verify loaded source blocks in stash map."; return -1; } return 0; @@ -599,22 +599,21 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s if (res == -1) { if (errno != ENOENT || printnoent) { - fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "stat \"" << fn << "\" failed"; } return -1; } - fprintf(stderr, " loading %s\n", fn.c_str()); + LOG(INFO) << " loading " << fn; if ((sb.st_size % BLOCKSIZE) != 0) { - fprintf(stderr, "%s size %" PRId64 " not multiple of block size %d", - fn.c_str(), static_cast<int64_t>(sb.st_size), BLOCKSIZE); + LOG(ERROR) << fn << " size " << sb.st_size << " not multiple of block size " << BLOCKSIZE; return -1; } android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_RDONLY))); if (fd == -1) { - fprintf(stderr, "open \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "open \"" << fn << "\" failed"; return -1; } @@ -627,7 +626,7 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s *blocks = sb.st_size / BLOCKSIZE; if (verify && VerifyBlocks(id, buffer, *blocks, true) != 0) { - fprintf(stderr, "unexpected contents in %s\n", fn.c_str()); + LOG(ERROR) << "unexpected contents in " << fn; DeleteFile(fn, nullptr); return -1; } @@ -642,7 +641,7 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks } if (checkspace && CacheSizeCheck(blocks * BLOCKSIZE) != 0) { - fprintf(stderr, "not enough space to write stash\n"); + LOG(ERROR) << "not enough space to write stash"; return -1; } @@ -657,7 +656,7 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks // The file already exists and since the name is the hash of the contents, // it's safe to assume the contents are identical (accidental hash collisions // are unlikely) - fprintf(stderr, " skipping %d existing blocks in %s\n", blocks, cn.c_str()); + LOG(INFO) << " skipping " << blocks << " existing blocks in " << cn; *exists = true; return 0; } @@ -665,13 +664,12 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks *exists = false; } - fprintf(stderr, " writing %d blocks to %s\n", blocks, cn.c_str()); + LOG(INFO) << " writing " << blocks << " blocks to " << cn; - android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), - O_WRONLY | O_CREAT | O_TRUNC, - STASH_FILE_MODE))); + android::base::unique_fd fd( + TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_WRONLY | O_CREAT | O_TRUNC, STASH_FILE_MODE))); if (fd == -1) { - fprintf(stderr, "failed to create \"%s\": %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "failed to create \"" << fn << "\""; return -1; } @@ -681,13 +679,12 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks if (ota_fsync(fd) == -1) { failure_type = kFsyncFailure; - fprintf(stderr, "fsync \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); + PLOG(ERROR) << "fsync \"" << fn << "\" failed"; return -1; } if (rename(fn.c_str(), cn.c_str()) == -1) { - fprintf(stderr, "rename(\"%s\", \"%s\") failed: %s\n", fn.c_str(), cn.c_str(), - strerror(errno)); + PLOG(ERROR) << "rename(\"" << fn << "\", \"" << cn << "\") failed"; return -1; } @@ -696,13 +693,13 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks O_RDONLY | O_DIRECTORY))); if (dfd == -1) { failure_type = kFileOpenFailure; - fprintf(stderr, "failed to open \"%s\" failed: %s\n", dname.c_str(), strerror(errno)); + PLOG(ERROR) << "failed to open \"" << dname << "\" failed"; return -1; } if (ota_fsync(dfd) == -1) { failure_type = kFsyncFailure; - fprintf(stderr, "fsync \"%s\" failed: %s\n", dname.c_str(), strerror(errno)); + PLOG(ERROR) << "fsync \"" << dname << "\" failed"; return -1; } @@ -734,7 +731,7 @@ static int CreateStash(State* state, int maxblocks, const char* blockdev, std::s dirname.c_str(), strerror(errno)); return -1; } else if (res != 0) { - fprintf(stderr, "creating stash %s\n", dirname.c_str()); + LOG(INFO) << "creating stash " << dirname; res = mkdir(dirname.c_str(), STASH_DIRECTORY_MODE); if (res != 0) { @@ -751,7 +748,7 @@ static int CreateStash(State* state, int maxblocks, const char* blockdev, std::s return 1; // Created directory } - fprintf(stderr, "using existing stash %s\n", dirname.c_str()); + LOG(INFO) << "using existing stash " << dirname; // If the directory already exists, calculate the space already allocated to // stash files and check if there's enough for all required blocks. Delete any @@ -777,7 +774,7 @@ static int SaveStash(CommandParameters& params, const std::string& base, // <stash_id> <src_range> if (params.cpos + 1 >= params.tokens.size()) { - fprintf(stderr, "missing id and/or src range fields in stash command\n"); + LOG(ERROR) << "missing id and/or src range fields in stash command"; return -1; } const std::string& id = params.tokens[params.cpos++]; @@ -804,7 +801,7 @@ static int SaveStash(CommandParameters& params, const std::string& base, // data later, this is an unrecoverable error. However, the command // that uses the data may have already completed previously, so the // possible failure will occur during source block verification. - fprintf(stderr, "failed to load source blocks for stash %s\n", id.c_str()); + LOG(ERROR) << "failed to load source blocks for stash " << id; return 0; } @@ -814,7 +811,7 @@ static int SaveStash(CommandParameters& params, const std::string& base, return 0; } - fprintf(stderr, "stashing %zu blocks to %s\n", blocks, id.c_str()); + LOG(INFO) << "stashing " << blocks << " blocks to " << id; params.stashed += blocks; return WriteStash(base, id, blocks, buffer, false, nullptr); } @@ -870,7 +867,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& // At least it needs to provide three parameters: <tgt_range>, // <src_block_count> and "-"/<src_range>. if (params.cpos + 2 >= params.tokens.size()) { - fprintf(stderr, "invalid parameters\n"); + LOG(ERROR) << "invalid parameters"; return -1; } @@ -880,7 +877,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& // <src_block_count> const std::string& token = params.tokens[params.cpos++]; if (!android::base::ParseUint(token.c_str(), &src_blocks)) { - fprintf(stderr, "invalid src_block_count \"%s\"\n", token.c_str()); + LOG(ERROR) << "invalid src_block_count \"" << token << "\""; return -1; } @@ -920,7 +917,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& // stashed data should go. std::vector<std::string> tokens = android::base::Split(params.tokens[params.cpos++], ":"); if (tokens.size() != 2) { - fprintf(stderr, "invalid parameter\n"); + LOG(ERROR) << "invalid parameter"; return -1; } @@ -930,7 +927,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& if (res == -1) { // These source blocks will fail verification if used later, but we // will let the caller decide if this is a fatal failure - fprintf(stderr, "failed to load stash %s\n", tokens[0].c_str()); + LOG(ERROR) << "failed to load stash " << tokens[0]; continue; } @@ -964,7 +961,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& bool onehash, bool& overlap) { if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing source hash\n"); + LOG(ERROR) << "missing source hash"; return -1; } @@ -975,7 +972,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& tgthash = srchash; } else { if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing target hash\n"); + LOG(ERROR) << "missing target hash"; return -1; } tgthash = params.tokens[params.cpos++]; @@ -1002,13 +999,12 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& // resume from possible write errors. In verify mode, we can skip stashing // because the source blocks won't be overwritten. if (overlap && params.canwrite) { - fprintf(stderr, "stashing %zu overlapping blocks to %s\n", src_blocks, - srchash.c_str()); + LOG(INFO) << "stashing " << src_blocks << " overlapping blocks to " << srchash; bool stash_exists = false; if (WriteStash(params.stashbase, srchash, src_blocks, params.buffer, true, &stash_exists) != 0) { - fprintf(stderr, "failed to stash overlapping source blocks\n"); + LOG(ERROR) << "failed to stash overlapping source blocks"; return -1; } @@ -1032,7 +1028,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& } // Valid source data not available, update cannot be resumed - fprintf(stderr, "partition has unexpected contents\n"); + LOG(ERROR) << "partition has unexpected contents"; params.isunresumable = true; return -1; @@ -1054,25 +1050,25 @@ static int PerformCommandMove(CommandParameters& params) { } if (status == -1) { - fprintf(stderr, "failed to read blocks for move\n"); + LOG(ERROR) << "failed to read blocks for move"; return -1; } if (status == 0) { params.foundwrites = true; } else if (params.foundwrites) { - fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname); + LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]"; } if (params.canwrite) { if (status == 0) { - fprintf(stderr, " moving %zu blocks\n", blocks); + LOG(INFO) << " moving " << blocks << " blocks"; if (WriteBlocks(tgt, params.buffer, params.fd) == -1) { return -1; } } else { - fprintf(stderr, "skipping %zu already moved blocks\n", blocks); + LOG(INFO) << "skipping " << blocks << " already moved blocks"; } } @@ -1095,7 +1091,7 @@ static int PerformCommandStash(CommandParameters& params) { static int PerformCommandFree(CommandParameters& params) { // <stash_id> if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing stash id in free command\n"); + LOG(ERROR) << "missing stash id in free command"; return -1; } @@ -1116,14 +1112,14 @@ static int PerformCommandFree(CommandParameters& params) { static int PerformCommandZero(CommandParameters& params) { if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing target blocks for zero\n"); + LOG(ERROR) << "missing target blocks for zero"; return -1; } RangeSet tgt; parse_range(params.tokens[params.cpos++], tgt); - fprintf(stderr, " zeroing %zu blocks\n", tgt.size); + LOG(INFO) << " zeroing " << tgt.size << " blocks"; allocate(BLOCKSIZE, params.buffer); memset(params.buffer.data(), 0, BLOCKSIZE); @@ -1160,7 +1156,7 @@ static int PerformCommandZero(CommandParameters& params) { static int PerformCommandNew(CommandParameters& params) { if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing target blocks for new\n"); + LOG(ERROR) << "missing target blocks for new"; return -1; } @@ -1168,7 +1164,7 @@ static int PerformCommandNew(CommandParameters& params) { parse_range(params.tokens[params.cpos++], tgt); if (params.canwrite) { - fprintf(stderr, " writing %zu blocks of new data\n", tgt.size); + LOG(INFO) << " writing " << tgt.size << " blocks of new data"; RangeSinkState rss(tgt); rss.fd = params.fd; @@ -1204,19 +1200,19 @@ static int PerformCommandDiff(CommandParameters& params) { // <offset> <length> if (params.cpos + 1 >= params.tokens.size()) { - fprintf(stderr, "missing patch offset or length for %s\n", params.cmdname); + LOG(ERROR) << "missing patch offset or length for " << params.cmdname; return -1; } size_t offset; if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &offset)) { - fprintf(stderr, "invalid patch offset\n"); + LOG(ERROR) << "invalid patch offset"; return -1; } size_t len; if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &len)) { - fprintf(stderr, "invalid patch len\n"); + LOG(ERROR) << "invalid patch len"; return -1; } @@ -1234,19 +1230,19 @@ static int PerformCommandDiff(CommandParameters& params) { } if (status == -1) { - fprintf(stderr, "failed to read blocks for diff\n"); + LOG(ERROR) << "failed to read blocks for diff"; return -1; } if (status == 0) { params.foundwrites = true; } else if (params.foundwrites) { - fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname); + LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]"; } if (params.canwrite) { if (status == 0) { - fprintf(stderr, "patching %zu blocks to %zu\n", blocks, tgt.size); + LOG(INFO) << "patching " << blocks << " blocks to " << tgt.size; Value patch_value(VAL_BLOB, std::string(reinterpret_cast<const char*>(params.patch_start + offset), len)); @@ -1268,24 +1264,24 @@ static int PerformCommandDiff(CommandParameters& params) { if (params.cmdname[0] == 'i') { // imgdiff if (ApplyImagePatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value, &RangeSinkWrite, &rss, nullptr, nullptr) != 0) { - fprintf(stderr, "Failed to apply image patch.\n"); + LOG(ERROR) << "Failed to apply image patch."; return -1; } } else { if (ApplyBSDiffPatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value, 0, &RangeSinkWrite, &rss, nullptr) != 0) { - fprintf(stderr, "Failed to apply bsdiff patch.\n"); + LOG(ERROR) << "Failed to apply bsdiff patch."; return -1; } } // We expect the output of the patcher to fill the tgt ranges exactly. if (rss.p_block != tgt.count || rss.p_remain != 0) { - fprintf(stderr, "range sink underrun?\n"); + LOG(ERROR) << "range sink underrun?"; } } else { - fprintf(stderr, "skipping %zu blocks already patched to %zu [%s]\n", - blocks, tgt.size, params.cmdline); + LOG(INFO) << "skipping " << blocks << " blocks already patched to " << tgt.size + << " [" << params.cmdline << "]"; } } @@ -1306,17 +1302,17 @@ static int PerformCommandErase(CommandParameters& params) { struct stat sb; if (fstat(params.fd, &sb) == -1) { - fprintf(stderr, "failed to fstat device to erase: %s\n", strerror(errno)); + PLOG(ERROR) << "failed to fstat device to erase"; return -1; } if (!S_ISBLK(sb.st_mode)) { - fprintf(stderr, "not a block device; skipping erase\n"); + LOG(ERROR) << "not a block device; skipping erase"; return -1; } if (params.cpos >= params.tokens.size()) { - fprintf(stderr, "missing target blocks for erase\n"); + LOG(ERROR) << "missing target blocks for erase"; return -1; } @@ -1324,7 +1320,7 @@ static int PerformCommandErase(CommandParameters& params) { parse_range(params.tokens[params.cpos++], tgt); if (params.canwrite) { - fprintf(stderr, " erasing %zu blocks\n", tgt.size); + LOG(INFO) << " erasing " << tgt.size << " blocks"; for (size_t i = 0; i < tgt.count; ++i) { uint64_t blocks[2]; @@ -1334,7 +1330,7 @@ static int PerformCommandErase(CommandParameters& params) { blocks[1] = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * (uint64_t) BLOCKSIZE; if (ioctl(params.fd, BLKDISCARD, &blocks) == -1) { - fprintf(stderr, "BLKDISCARD ioctl failed: %s\n", strerror(errno)); + PLOG(ERROR) << "BLKDISCARD ioctl failed"; return -1; } } @@ -1362,10 +1358,10 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg CommandParameters params = {}; params.canwrite = !dryrun; - fprintf(stderr, "performing %s\n", dryrun ? "verification" : "update"); + LOG(INFO) << "performing " << dryrun ? "verification" : "update"; if (state->is_retry) { is_retry = true; - fprintf(stderr, "This update is a retry.\n"); + LOG(INFO) << "This update is a retry."; } std::vector<std::unique_ptr<Value>> args; @@ -1413,7 +1409,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg ZipString path_data(patch_data_fn->data.c_str()); ZipEntry patch_entry; if (FindEntry(za, path_data, &patch_entry) != 0) { - fprintf(stderr, "%s(): no file \"%s\" in package", name, patch_data_fn->data.c_str()); + LOG(ERROR) << name << "(): no file \"" << patch_data_fn->data << "\" in package"; return StringValue(""); } @@ -1421,13 +1417,13 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg ZipString new_data(new_data_fn->data.c_str()); ZipEntry new_entry; if (FindEntry(za, new_data, &new_entry) != 0) { - fprintf(stderr, "%s(): no file \"%s\" in package", name, new_data_fn->data.c_str()); + LOG(ERROR) << name << "(): no file \"" << new_data_fn->data << "\" in package"; return StringValue(""); } params.fd.reset(TEMP_FAILURE_RETRY(ota_open(blockdev_filename->data.c_str(), O_RDWR))); if (params.fd == -1) { - fprintf(stderr, "open \"%s\" failed: %s\n", blockdev_filename->data.c_str(), strerror(errno)); + PLOG(ERROR) << "open \"" << blockdev_filename->data << "\" failed"; return StringValue(""); } @@ -1443,7 +1439,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg int error = pthread_create(¶ms.thread, &attr, unzip_new_data, ¶ms.nti); if (error != 0) { - fprintf(stderr, "pthread_create failed: %s\n", strerror(error)); + PLOG(ERROR) << "pthread_create failed"; return StringValue(""); } } @@ -1457,11 +1453,11 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg // First line in transfer list is the version number if (!android::base::ParseInt(lines[0].c_str(), ¶ms.version, 1, 4)) { - fprintf(stderr, "unexpected transfer list version [%s]\n", lines[0].c_str()); + LOG(ERROR) << "unexpected transfer list version [" << lines[0] << "]"; return StringValue(""); } - fprintf(stderr, "blockimg version is %d\n", params.version); + LOG(INFO) << "blockimg version is " << params.version; // Second line in transfer list is the total number of blocks we expect to write int total_blocks; @@ -1483,7 +1479,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg } // Third line is how many stash entries are needed simultaneously - fprintf(stderr, "maximum stash entries %s\n", lines[2].c_str()); + LOG(INFO) << "maximum stash entries " << lines[2]; // Fourth line is the maximum number of blocks that will be stashed simultaneously int stash_max_blocks; @@ -1507,8 +1503,8 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg std::unordered_map<std::string, const Command*> cmd_map; for (size_t i = 0; i < cmdcount; ++i) { if (cmd_map.find(commands[i].name) != cmd_map.end()) { - fprintf(stderr, "Error: command [%s] already exists in the cmd map.\n", - commands[i].name); + LOG(ERROR) << "Error: command [" << commands[i].name + << "] already exists in the cmd map."; return StringValue(strdup("")); } cmd_map[commands[i].name] = &commands[i]; @@ -1529,21 +1525,21 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg params.cmdline = line_str.c_str(); if (cmd_map.find(params.cmdname) == cmd_map.end()) { - fprintf(stderr, "unexpected command [%s]\n", params.cmdname); + LOG(ERROR) << "unexpected command [" << params.cmdname << "]"; goto pbiudone; } const Command* cmd = cmd_map[params.cmdname]; if (cmd->f != nullptr && cmd->f(params) == -1) { - fprintf(stderr, "failed to execute command [%s]\n", line_str.c_str()); + LOG(ERROR) << "failed to execute command [" << line_str << "]"; goto pbiudone; } if (params.canwrite) { if (ota_fsync(params.fd) == -1) { failure_type = kFsyncFailure; - fprintf(stderr, "fsync failed: %s\n", strerror(errno)); + PLOG(ERROR) << "fsync failed"; goto pbiudone; } fprintf(cmd_pipe, "set_progress %.4f\n", (double) params.written / total_blocks); @@ -1554,9 +1550,9 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg if (params.canwrite) { pthread_join(params.thread, nullptr); - fprintf(stderr, "wrote %zu blocks; expected %d\n", params.written, total_blocks); - fprintf(stderr, "stashed %zu blocks\n", params.stashed); - fprintf(stderr, "max alloc needed was %zu\n", params.buffer.size()); + LOG(INFO) << "wrote " << params.written << " blocks; expected " << total_blocks; + LOG(INFO) << "stashed " << params.stashed << " blocks"; + LOG(INFO) << "max alloc needed was " << params.buffer.size(); const char* partition = strrchr(blockdev_filename->data.c_str(), '/'); if (partition != nullptr && *(partition+1) != 0) { @@ -1570,7 +1566,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg // may contain blocks needed to complete the update later. DeleteStash(params.stashbase); } else { - fprintf(stderr, "verified partition contents; update may be resumed\n"); + LOG(INFO) << "verified partition contents; update may be resumed"; } rc = 0; @@ -1578,7 +1574,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg pbiudone: if (ota_fsync(params.fd) == -1) { failure_type = kFsyncFailure; - fprintf(stderr, "fsync failed: %s\n", strerror(errno)); + PLOG(ERROR) << "fsync failed"; } // params.fd will be automatically closed because it's a unique_fd. @@ -1813,7 +1809,7 @@ Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[ } // Output notice to log when recover is attempted - fprintf(stderr, "%s image corrupted, attempting to recover...\n", filename->data.c_str()); + LOG(INFO) << filename->data << " image corrupted, attempting to recover..."; // When opened with O_RDWR, libfec rewrites corrupted blocks when they are read fec::io fh(filename->data.c_str(), O_RDWR); @@ -1866,7 +1862,7 @@ Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[ // read and check if the errors field value has increased. } } - fprintf(stderr, "...%s image recovered successfully.\n", filename->data.c_str()); + LOG(INFO) << "..." << filename->data << " image recovered successfully."; return StringValue("t"); } diff --git a/updater/install.cpp b/updater/install.cpp index 8db5c1fe0..3cf38774e 100644 --- a/updater/install.cpp +++ b/updater/install.cpp @@ -40,6 +40,7 @@ #include <vector> #include <android-base/file.h> +#include <android-base/logging.h> #include <android-base/parsedouble.h> #include <android-base/parseint.h> #include <android-base/properties.h> @@ -67,33 +68,33 @@ // Send over the buffer to recovery though the command pipe. static void uiPrint(State* state, const std::string& buffer) { - UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie); - - // "line1\nline2\n" will be split into 3 tokens: "line1", "line2" and "". - // So skip sending empty strings to UI. - std::vector<std::string> lines = android::base::Split(buffer, "\n"); - for (auto& line: lines) { - if (!line.empty()) { - fprintf(ui->cmd_pipe, "ui_print %s\n", line.c_str()); - fprintf(ui->cmd_pipe, "ui_print\n"); - } + UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie); + + // "line1\nline2\n" will be split into 3 tokens: "line1", "line2" and "". + // So skip sending empty strings to UI. + std::vector<std::string> lines = android::base::Split(buffer, "\n"); + for (auto& line : lines) { + if (!line.empty()) { + fprintf(ui->cmd_pipe, "ui_print %s\n", line.c_str()); + fprintf(ui->cmd_pipe, "ui_print\n"); } + } - // On the updater side, we need to dump the contents to stderr (which has - // been redirected to the log file). Because the recovery will only print - // the contents to screen when processing pipe command ui_print. - fprintf(stderr, "%s", buffer.c_str()); + // On the updater side, we need to dump the contents to stderr (which has + // been redirected to the log file). Because the recovery will only print + // the contents to screen when processing pipe command ui_print. + LOG(INFO) << buffer; } void uiPrintf(State* _Nonnull state, const char* _Nonnull format, ...) { - std::string error_msg; + std::string error_msg; - va_list ap; - va_start(ap, format); - android::base::StringAppendV(&error_msg, format, ap); - va_end(ap); + va_list ap; + va_start(ap, format); + android::base::StringAppendV(&error_msg, format, ap); + va_end(ap); - uiPrint(state, error_msg); + uiPrint(state, error_msg); } static bool is_dir(const std::string& dirpath) { @@ -103,26 +104,25 @@ static bool is_dir(const std::string& dirpath) { // Create all parent directories of name, if necessary. static bool make_parents(const std::string& name) { - size_t prev_end = 0; - while (prev_end < name.size()) { - size_t next_end = name.find('/', prev_end + 1); - if (next_end == std::string::npos) { - break; - } - std::string dir_path = name.substr(0, next_end); - if (!is_dir(dir_path)) { - int result = mkdir(dir_path.c_str(), 0700); - if (result != 0) { - printf("failed to mkdir %s when make parents for %s: %s\n", dir_path.c_str(), - name.c_str(), strerror(errno)); - return false; - } - - printf("created [%s]\n", dir_path.c_str()); - } - prev_end = next_end; - } - return true; + size_t prev_end = 0; + while (prev_end < name.size()) { + size_t next_end = name.find('/', prev_end + 1); + if (next_end == std::string::npos) { + break; + } + std::string dir_path = name.substr(0, next_end); + if (!is_dir(dir_path)) { + int result = mkdir(dir_path.c_str(), 0700); + if (result != 0) { + PLOG(ERROR) << "failed to mkdir " << dir_path << " when make parents for " << name; + return false; + } + + LOG(INFO) << "created [" << dir_path << "]"; + } + prev_end = next_end; + } + return true; } // mount(fs_type, partition_type, location, mount_point) @@ -130,249 +130,242 @@ static bool make_parents(const std::string& name) { // // fs_type="ext4" partition_type="EMMC" location=device Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 4 && argc != 5) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 4-5 args, got %d", name, argc); - } + if (argc != 4 && argc != 5) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 4-5 args, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& fs_type = args[0]; - const std::string& partition_type = args[1]; - const std::string& location = args[2]; - const std::string& mount_point = args[3]; - std::string mount_options; - - if (argc == 5) { - mount_options = args[4]; - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& fs_type = args[0]; + const std::string& partition_type = args[1]; + const std::string& location = args[2]; + const std::string& mount_point = args[3]; + std::string mount_options; + + if (argc == 5) { + mount_options = args[4]; + } - if (fs_type.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", - name); - } - if (partition_type.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty", - name); - } - if (location.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", - name); - } - if (mount_point.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty", - name); - } + if (fs_type.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", name); + } + if (partition_type.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty", + name); + } + if (location.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", name); + } + if (mount_point.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty", + name); + } - { - char *secontext = NULL; + { + char* secontext = nullptr; - if (sehandle) { - selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755); - setfscreatecon(secontext); - } + if (sehandle) { + selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755); + setfscreatecon(secontext); + } - mkdir(mount_point.c_str(), 0755); + mkdir(mount_point.c_str(), 0755); - if (secontext) { - freecon(secontext); - setfscreatecon(NULL); - } + if (secontext) { + freecon(secontext); + setfscreatecon(nullptr); } + } - if (mount(location.c_str(), mount_point.c_str(), fs_type.c_str(), - MS_NOATIME | MS_NODEV | MS_NODIRATIME, mount_options.c_str()) < 0) { - uiPrintf(state, "%s: failed to mount %s at %s: %s\n", - name, location.c_str(), mount_point.c_str(), strerror(errno)); - return StringValue(""); - } + if (mount(location.c_str(), mount_point.c_str(), fs_type.c_str(), + MS_NOATIME | MS_NODEV | MS_NODIRATIME, mount_options.c_str()) < 0) { + uiPrintf(state, "%s: failed to mount %s at %s: %s\n", name, location.c_str(), + mount_point.c_str(), strerror(errno)); + return StringValue(""); + } - return StringValue(mount_point); + return StringValue(mount_point); } // is_mounted(mount_point) Value* IsMountedFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); - } + if (argc != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& mount_point = args[0]; - if (mount_point.empty()) { - return ErrorAbort(state, kArgsParsingFailure, - "mount_point argument to unmount() can't be empty"); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& mount_point = args[0]; + if (mount_point.empty()) { + return ErrorAbort(state, kArgsParsingFailure, + "mount_point argument to unmount() can't be empty"); + } - scan_mounted_volumes(); - MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point.c_str()); - if (vol == nullptr) { - return StringValue(""); - } + scan_mounted_volumes(); + MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point.c_str()); + if (vol == nullptr) { + return StringValue(""); + } - return StringValue(mount_point); + return StringValue(mount_point); } - Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); - } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& mount_point = args[0]; - if (mount_point.empty()) { - return ErrorAbort(state, kArgsParsingFailure, - "mount_point argument to unmount() can't be empty"); - } + if (argc != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); + } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& mount_point = args[0]; + if (mount_point.empty()) { + return ErrorAbort(state, kArgsParsingFailure, + "mount_point argument to unmount() can't be empty"); + } - scan_mounted_volumes(); - MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point.c_str()); - if (vol == nullptr) { - uiPrintf(state, "unmount of %s failed; no such volume\n", mount_point.c_str()); - return nullptr; - } else { - int ret = unmount_mounted_volume(vol); - if (ret != 0) { - uiPrintf(state, "unmount of %s failed (%d): %s\n", - mount_point.c_str(), ret, strerror(errno)); - } + scan_mounted_volumes(); + MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point.c_str()); + if (vol == nullptr) { + uiPrintf(state, "unmount of %s failed; no such volume\n", mount_point.c_str()); + return nullptr; + } else { + int ret = unmount_mounted_volume(vol); + if (ret != 0) { + uiPrintf(state, "unmount of %s failed (%d): %s\n", mount_point.c_str(), ret, strerror(errno)); } + } - return StringValue(mount_point); + return StringValue(mount_point); } static int exec_cmd(const char* path, char* const argv[]) { - int status; - pid_t child; - if ((child = vfork()) == 0) { - execv(path, argv); - _exit(-1); - } - waitpid(child, &status, 0); - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { - printf("%s failed with status %d\n", path, WEXITSTATUS(status)); - } - return WEXITSTATUS(status); + pid_t child; + if ((child = vfork()) == 0) { + execv(path, argv); + _exit(-1); + } + + int status; + waitpid(child, &status, 0); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { + LOG(ERROR) << path << " failed with status " << WEXITSTATUS(status); + } + return WEXITSTATUS(status); } // format(fs_type, partition_type, location, fs_size, mount_point) // -// fs_type="ext4" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location> -// fs_type="f2fs" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location> +// fs_type="ext4" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location> +// fs_type="f2fs" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location> // if fs_size == 0, then make fs uses the entire partition. // if fs_size > 0, that is the size to use // if fs_size < 0, then reserve that many bytes at the end of the partition (not for "f2fs") Value* FormatFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 5) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 5 args, got %d", name, argc); - } + if (argc != 5) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 5 args, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& fs_type = args[0]; - const std::string& partition_type = args[1]; - const std::string& location = args[2]; - const std::string& fs_size = args[3]; - const std::string& mount_point = args[4]; - - if (fs_type.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", - name); - } - if (partition_type.empty()) { - return ErrorAbort(state, kArgsParsingFailure, - "partition_type argument to %s() can't be empty", name); - } - if (location.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", - name); - } - if (mount_point.empty()) { - return ErrorAbort(state, kArgsParsingFailure, - "mount_point argument to %s() can't be empty", name); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& fs_type = args[0]; + const std::string& partition_type = args[1]; + const std::string& location = args[2]; + const std::string& fs_size = args[3]; + const std::string& mount_point = args[4]; + + if (fs_type.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", name); + } + if (partition_type.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty", + name); + } + if (location.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", name); + } + if (mount_point.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty", + name); + } - int64_t size; - if (!android::base::ParseInt(fs_size, &size)) { - return ErrorAbort(state, kArgsParsingFailure, - "%s: failed to parse int in %s\n", name, fs_size.c_str()); + int64_t size; + if (!android::base::ParseInt(fs_size, &size)) { + return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse int in %s\n", name, + fs_size.c_str()); + } + + if (fs_type == "ext4") { + int status = make_ext4fs(location.c_str(), size, mount_point.c_str(), sehandle); + if (status != 0) { + LOG(ERROR) << name << ": make_ext4fs failed (" << status << ") on " << location; + return StringValue(""); } + return StringValue(location); + } else if (fs_type == "f2fs") { + if (size < 0) { + LOG(ERROR) << name << ": fs_size can't be negative for f2fs: " << fs_size; + return StringValue(""); + } + std::string num_sectors = std::to_string(size / 512); - if (fs_type == "ext4") { - int status = make_ext4fs(location.c_str(), size, mount_point.c_str(), sehandle); - if (status != 0) { - printf("%s: make_ext4fs failed (%d) on %s", name, status, location.c_str()); - return StringValue(""); - } - return StringValue(location); - } else if (fs_type == "f2fs") { - if (size < 0) { - printf("%s: fs_size can't be negative for f2fs: %s", name, fs_size.c_str()); - return StringValue(""); - } - std::string num_sectors = std::to_string(size / 512); - - const char *f2fs_path = "/sbin/mkfs.f2fs"; - const char* const f2fs_argv[] = {"mkfs.f2fs", "-t", "-d1", location.c_str(), - num_sectors.c_str(), nullptr}; - int status = exec_cmd(f2fs_path, (char* const*)f2fs_argv); - if (status != 0) { - printf("%s: mkfs.f2fs failed (%d) on %s", name, status, location.c_str()); - return StringValue(""); - } - return StringValue(location); - } else { - printf("%s: unsupported fs_type \"%s\" partition_type \"%s\"", - name, fs_type.c_str(), partition_type.c_str()); + const char* f2fs_path = "/sbin/mkfs.f2fs"; + const char* const f2fs_argv[] = { "mkfs.f2fs", "-t", "-d1", location.c_str(), + num_sectors.c_str(), nullptr }; + int status = exec_cmd(f2fs_path, const_cast<char* const*>(f2fs_argv)); + if (status != 0) { + LOG(ERROR) << name << ": mkfs.f2fs failed (" << status << ") on " << location; + return StringValue(""); } + return StringValue(location); + } else { + LOG(ERROR) << name << ": unsupported fs_type \"" << fs_type << "\" partition_type \"" + << partition_type << "\""; + } - return nullptr; + return nullptr; } // rename(src_name, dst_name) // Renames src_name to dst_name. It automatically creates the necessary directories for dst_name. // Example: rename("system/app/Hangouts/Hangouts.apk", "system/priv-app/Hangouts/Hangouts.apk") Value* RenameFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 2) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 2 args, got %d", name, argc); - } - - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& src_name = args[0]; - const std::string& dst_name = args[1]; + if (argc != 2) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 2 args, got %d", name, argc); + } - if (src_name.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "src_name argument to %s() can't be empty", - name); - } - if (dst_name.empty()) { - return ErrorAbort(state, kArgsParsingFailure, "dst_name argument to %s() can't be empty", - name); - } - if (!make_parents(dst_name)) { - return ErrorAbort(state, kFileRenameFailure, "Creating parent of %s failed, error %s", - dst_name.c_str(), strerror(errno)); - } else if (access(dst_name.c_str(), F_OK) == 0 && access(src_name.c_str(), F_OK) != 0) { - // File was already moved - return StringValue(dst_name); - } else if (rename(src_name.c_str(), dst_name.c_str()) != 0) { - return ErrorAbort(state, kFileRenameFailure, "Rename of %s to %s failed, error %s", - src_name.c_str(), dst_name.c_str(), strerror(errno)); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& src_name = args[0]; + const std::string& dst_name = args[1]; + if (src_name.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "src_name argument to %s() can't be empty", name); + } + if (dst_name.empty()) { + return ErrorAbort(state, kArgsParsingFailure, "dst_name argument to %s() can't be empty", name); + } + if (!make_parents(dst_name)) { + return ErrorAbort(state, kFileRenameFailure, "Creating parent of %s failed, error %s", + dst_name.c_str(), strerror(errno)); + } else if (access(dst_name.c_str(), F_OK) == 0 && access(src_name.c_str(), F_OK) != 0) { + // File was already moved return StringValue(dst_name); + } else if (rename(src_name.c_str(), dst_name.c_str()) != 0) { + return ErrorAbort(state, kFileRenameFailure, "Rename of %s to %s failed, error %s", + src_name.c_str(), dst_name.c_str(), strerror(errno)); + } + + return StringValue(dst_name); } // delete([filename, ...]) @@ -382,76 +375,76 @@ Value* RenameFn(const char* name, State* state, int argc, Expr* argv[]) { // Recursively deletes dirnames and all their contents. Returns the number of directories // successfully deleted. Value* DeleteFn(const char* name, State* state, int argc, Expr* argv[]) { - std::vector<std::string> paths(argc); - for (int i = 0; i < argc; ++i) { - if (!Evaluate(state, argv[i], &paths[i])) { - return nullptr; - } + std::vector<std::string> paths(argc); + for (int i = 0; i < argc; ++i) { + if (!Evaluate(state, argv[i], &paths[i])) { + return nullptr; } + } - bool recursive = (strcmp(name, "delete_recursive") == 0); + bool recursive = (strcmp(name, "delete_recursive") == 0); - int success = 0; - for (int i = 0; i < argc; ++i) { - if ((recursive ? dirUnlinkHierarchy(paths[i].c_str()) : unlink(paths[i].c_str())) == 0) { - ++success; - } + int success = 0; + for (int i = 0; i < argc; ++i) { + if ((recursive ? dirUnlinkHierarchy(paths[i].c_str()) : unlink(paths[i].c_str())) == 0) { + ++success; } + } - return StringValue(std::to_string(success)); + return StringValue(std::to_string(success)); } Value* ShowProgressFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 2) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 2 args, got %d", name, argc); - } + if (argc != 2) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 2 args, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& frac_str = args[0]; - const std::string& sec_str = args[1]; + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& frac_str = args[0]; + const std::string& sec_str = args[1]; - double frac; - if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { - return ErrorAbort(state, kArgsParsingFailure, - "%s: failed to parse double in %s\n", name, frac_str.c_str()); - } - int sec; - if (!android::base::ParseInt(sec_str.c_str(), &sec)) { - return ErrorAbort(state, kArgsParsingFailure, - "%s: failed to parse int in %s\n", name, sec_str.c_str()); - } + double frac; + if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { + return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse double in %s\n", name, + frac_str.c_str()); + } + int sec; + if (!android::base::ParseInt(sec_str.c_str(), &sec)) { + return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse int in %s\n", name, + sec_str.c_str()); + } - UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); - fprintf(ui->cmd_pipe, "progress %f %d\n", frac, sec); + UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie); + fprintf(ui->cmd_pipe, "progress %f %d\n", frac, sec); - return StringValue(frac_str); + return StringValue(frac_str); } Value* SetProgressFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); - } + if (argc != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, 1, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& frac_str = args[0]; + std::vector<std::string> args; + if (!ReadArgs(state, 1, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& frac_str = args[0]; - double frac; - if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { - return ErrorAbort(state, kArgsParsingFailure, - "%s: failed to parse double in %s\n", name, frac_str.c_str()); - } + double frac; + if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { + return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse double in %s\n", name, + frac_str.c_str()); + } - UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); - fprintf(ui->cmd_pipe, "set_progress %f\n", frac); + UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie); + fprintf(ui->cmd_pipe, "set_progress %f\n", frac); - return StringValue(frac_str); + return StringValue(frac_str); } // package_extract_dir(package_dir, dest_dir) @@ -505,30 +498,31 @@ Value* PackageExtractFileFn(const char* name, State* state, int argc, Expr* argv ZipString zip_string_path(zip_path.c_str()); ZipEntry entry; if (FindEntry(za, zip_string_path, &entry) != 0) { - printf("%s: no %s in package\n", name, zip_path.c_str()); + LOG(ERROR) << name << ": no " << zip_path << " in package"; return StringValue(""); } unique_fd fd(TEMP_FAILURE_RETRY( ota_open(dest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR))); if (fd == -1) { - printf("%s: can't open %s for write: %s\n", name, dest_path.c_str(), strerror(errno)); + PLOG(ERROR) << name << ": can't open " << dest_path << " for write"; return StringValue(""); } bool success = true; int32_t ret = ExtractEntryToFile(za, &entry, fd); if (ret != 0) { - printf("%s: Failed to extract entry \"%s\" (%u bytes) to \"%s\": %s\n", name, - zip_path.c_str(), entry.uncompressed_length, dest_path.c_str(), ErrorCodeString(ret)); + LOG(ERROR) << name << ": Failed to extract entry \"" << zip_path << "\" (" + << entry.uncompressed_length << " bytes) to \"" << dest_path + << "\": " << ErrorCodeString(ret); success = false; } if (ota_fsync(fd) == -1) { - printf("fsync of \"%s\" failed: %s\n", dest_path.c_str(), strerror(errno)); + PLOG(ERROR) << "fsync of \"" << dest_path << "\" failed"; success = false; } if (ota_close(fd) == -1) { - printf("close of \"%s\" failed: %s\n", dest_path.c_str(), strerror(errno)); + PLOG(ERROR) << "close of \"" << dest_path << "\" failed"; success = false; } @@ -568,241 +562,234 @@ Value* PackageExtractFileFn(const char* name, State* state, int argc, Expr* argv // Creates all sources as symlinks to target. It unlinks any previously existing src1, src2, etc // before creating symlinks. Value* SymlinkFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc == 0) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1+ args, got %d", name, argc); - } - std::string target; - if (!Evaluate(state, argv[0], &target)) { - return nullptr; - } + if (argc == 0) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1+ args, got %d", name, argc); + } + std::string target; + if (!Evaluate(state, argv[0], &target)) { + return nullptr; + } - std::vector<std::string> srcs; - if (!ReadArgs(state, argc-1, argv+1, &srcs)) { - return ErrorAbort(state, kArgsParsingFailure, "%s(): Failed to parse the argument(s)", - name); - } + std::vector<std::string> srcs; + if (!ReadArgs(state, argc - 1, argv + 1, &srcs)) { + return ErrorAbort(state, kArgsParsingFailure, "%s(): Failed to parse the argument(s)", name); + } - size_t bad = 0; - for (const auto& src : srcs) { - if (unlink(src.c_str()) == -1 && errno != ENOENT) { - printf("%s: failed to remove %s: %s\n", name, src.c_str(), strerror(errno)); - ++bad; - } else if (!make_parents(src)) { - printf("%s: failed to symlink %s to %s: making parents failed\n", - name, src.c_str(), target.c_str()); - ++bad; - } else if (symlink(target.c_str(), src.c_str()) == -1) { - printf("%s: failed to symlink %s to %s: %s\n", - name, src.c_str(), target.c_str(), strerror(errno)); - ++bad; - } - } - if (bad != 0) { - return ErrorAbort(state, kSymlinkFailure, "%s: Failed to create %zu symlink(s)", name, bad); + size_t bad = 0; + for (const auto& src : srcs) { + if (unlink(src.c_str()) == -1 && errno != ENOENT) { + PLOG(ERROR) << name << ": failed to remove " << src; + ++bad; + } else if (!make_parents(src)) { + LOG(ERROR) << name << ": failed to symlink " << src << " to " << target + << ": making parents failed"; + ++bad; + } else if (symlink(target.c_str(), src.c_str()) == -1) { + PLOG(ERROR) << name << ": failed to symlink " << src << " to " << target; + ++bad; } - return StringValue("t"); + } + if (bad != 0) { + return ErrorAbort(state, kSymlinkFailure, "%s: Failed to create %zu symlink(s)", name, bad); + } + return StringValue("t"); } struct perm_parsed_args { - bool has_uid; - uid_t uid; - bool has_gid; - gid_t gid; - bool has_mode; - mode_t mode; - bool has_fmode; - mode_t fmode; - bool has_dmode; - mode_t dmode; - bool has_selabel; - const char* selabel; - bool has_capabilities; - uint64_t capabilities; + bool has_uid; + uid_t uid; + bool has_gid; + gid_t gid; + bool has_mode; + mode_t mode; + bool has_fmode; + mode_t fmode; + bool has_dmode; + mode_t dmode; + bool has_selabel; + const char* selabel; + bool has_capabilities; + uint64_t capabilities; }; static struct perm_parsed_args ParsePermArgs(State * state, int argc, const std::vector<std::string>& args) { - int i; - struct perm_parsed_args parsed; - int bad = 0; - static int max_warnings = 20; - - memset(&parsed, 0, sizeof(parsed)); - - for (i = 1; i < argc; i += 2) { - if (args[i] == "uid") { - int64_t uid; - if (sscanf(args[i+1].c_str(), "%" SCNd64, &uid) == 1) { - parsed.uid = uid; - parsed.has_uid = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid UID \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "gid") { - int64_t gid; - if (sscanf(args[i+1].c_str(), "%" SCNd64, &gid) == 1) { - parsed.gid = gid; - parsed.has_gid = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid GID \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "mode") { - int32_t mode; - if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { - parsed.mode = mode; - parsed.has_mode = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid mode \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "dmode") { - int32_t mode; - if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { - parsed.dmode = mode; - parsed.has_dmode = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid dmode \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "fmode") { - int32_t mode; - if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { - parsed.fmode = mode; - parsed.has_fmode = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid fmode \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "capabilities") { - int64_t capabilities; - if (sscanf(args[i+1].c_str(), "%" SCNi64, &capabilities) == 1) { - parsed.capabilities = capabilities; - parsed.has_capabilities = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid capabilities \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (args[i] == "selabel") { - if (!args[i+1].empty()) { - parsed.selabel = args[i+1].c_str(); - parsed.has_selabel = true; - } else { - uiPrintf(state, "ParsePermArgs: invalid selabel \"%s\"\n", args[i + 1].c_str()); - bad++; - } - continue; - } - if (max_warnings != 0) { - printf("ParsedPermArgs: unknown key \"%s\", ignoring\n", args[i].c_str()); - max_warnings--; - if (max_warnings == 0) { - printf("ParsedPermArgs: suppressing further warnings\n"); - } - } + struct perm_parsed_args parsed; + int bad = 0; + static int max_warnings = 20; + + memset(&parsed, 0, sizeof(parsed)); + + for (int i = 1; i < argc; i += 2) { + if (args[i] == "uid") { + int64_t uid; + if (sscanf(args[i + 1].c_str(), "%" SCNd64, &uid) == 1) { + parsed.uid = uid; + parsed.has_uid = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid UID \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (args[i] == "gid") { + int64_t gid; + if (sscanf(args[i + 1].c_str(), "%" SCNd64, &gid) == 1) { + parsed.gid = gid; + parsed.has_gid = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid GID \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (args[i] == "mode") { + int32_t mode; + if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) { + parsed.mode = mode; + parsed.has_mode = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid mode \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; } - return parsed; + if (args[i] == "dmode") { + int32_t mode; + if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) { + parsed.dmode = mode; + parsed.has_dmode = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid dmode \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (args[i] == "fmode") { + int32_t mode; + if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) { + parsed.fmode = mode; + parsed.has_fmode = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid fmode \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (args[i] == "capabilities") { + int64_t capabilities; + if (sscanf(args[i + 1].c_str(), "%" SCNi64, &capabilities) == 1) { + parsed.capabilities = capabilities; + parsed.has_capabilities = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid capabilities \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (args[i] == "selabel") { + if (!args[i + 1].empty()) { + parsed.selabel = args[i + 1].c_str(); + parsed.has_selabel = true; + } else { + uiPrintf(state, "ParsePermArgs: invalid selabel \"%s\"\n", args[i + 1].c_str()); + bad++; + } + continue; + } + if (max_warnings != 0) { + printf("ParsedPermArgs: unknown key \"%s\", ignoring\n", args[i].c_str()); + max_warnings--; + if (max_warnings == 0) { + LOG(INFO) << "ParsedPermArgs: suppressing further warnings"; + } + } + } + return parsed; } -static int ApplyParsedPerms( - State * state, - const char* filename, - const struct stat *statptr, - struct perm_parsed_args parsed) -{ - int bad = 0; - - if (parsed.has_selabel) { - if (lsetfilecon(filename, parsed.selabel) != 0) { - uiPrintf(state, "ApplyParsedPerms: lsetfilecon of %s to %s failed: %s\n", - filename, parsed.selabel, strerror(errno)); - bad++; - } - } +static int ApplyParsedPerms(State* state, const char* filename, const struct stat* statptr, + struct perm_parsed_args parsed) { + int bad = 0; - /* ignore symlinks */ - if (S_ISLNK(statptr->st_mode)) { - return bad; + if (parsed.has_selabel) { + if (lsetfilecon(filename, parsed.selabel) != 0) { + uiPrintf(state, "ApplyParsedPerms: lsetfilecon of %s to %s failed: %s\n", filename, + parsed.selabel, strerror(errno)); + bad++; } + } - if (parsed.has_uid) { - if (chown(filename, parsed.uid, -1) < 0) { - uiPrintf(state, "ApplyParsedPerms: chown of %s to %d failed: %s\n", - filename, parsed.uid, strerror(errno)); - bad++; - } + /* ignore symlinks */ + if (S_ISLNK(statptr->st_mode)) { + return bad; + } + + if (parsed.has_uid) { + if (chown(filename, parsed.uid, -1) < 0) { + uiPrintf(state, "ApplyParsedPerms: chown of %s to %d failed: %s\n", filename, parsed.uid, + strerror(errno)); + bad++; } + } - if (parsed.has_gid) { - if (chown(filename, -1, parsed.gid) < 0) { - uiPrintf(state, "ApplyParsedPerms: chgrp of %s to %d failed: %s\n", - filename, parsed.gid, strerror(errno)); - bad++; - } + if (parsed.has_gid) { + if (chown(filename, -1, parsed.gid) < 0) { + uiPrintf(state, "ApplyParsedPerms: chgrp of %s to %d failed: %s\n", filename, parsed.gid, + strerror(errno)); + bad++; } + } - if (parsed.has_mode) { - if (chmod(filename, parsed.mode) < 0) { - uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", - filename, parsed.mode, strerror(errno)); - bad++; - } + if (parsed.has_mode) { + if (chmod(filename, parsed.mode) < 0) { + uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.mode, + strerror(errno)); + bad++; } + } - if (parsed.has_dmode && S_ISDIR(statptr->st_mode)) { - if (chmod(filename, parsed.dmode) < 0) { - uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", - filename, parsed.dmode, strerror(errno)); - bad++; - } + if (parsed.has_dmode && S_ISDIR(statptr->st_mode)) { + if (chmod(filename, parsed.dmode) < 0) { + uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.dmode, + strerror(errno)); + bad++; } + } - if (parsed.has_fmode && S_ISREG(statptr->st_mode)) { - if (chmod(filename, parsed.fmode) < 0) { - uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", - filename, parsed.fmode, strerror(errno)); - bad++; - } + if (parsed.has_fmode && S_ISREG(statptr->st_mode)) { + if (chmod(filename, parsed.fmode) < 0) { + uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.fmode, + strerror(errno)); + bad++; } + } - if (parsed.has_capabilities && S_ISREG(statptr->st_mode)) { - if (parsed.capabilities == 0) { - if ((removexattr(filename, XATTR_NAME_CAPS) == -1) && (errno != ENODATA)) { - // Report failure unless it's ENODATA (attribute not set) - uiPrintf(state, "ApplyParsedPerms: removexattr of %s to %" PRIx64 " failed: %s\n", - filename, parsed.capabilities, strerror(errno)); - bad++; - } - } else { - struct vfs_cap_data cap_data; - memset(&cap_data, 0, sizeof(cap_data)); - cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE; - cap_data.data[0].permitted = (uint32_t) (parsed.capabilities & 0xffffffff); - cap_data.data[0].inheritable = 0; - cap_data.data[1].permitted = (uint32_t) (parsed.capabilities >> 32); - cap_data.data[1].inheritable = 0; - if (setxattr(filename, XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) { - uiPrintf(state, "ApplyParsedPerms: setcap of %s to %" PRIx64 " failed: %s\n", - filename, parsed.capabilities, strerror(errno)); - bad++; - } - } + if (parsed.has_capabilities && S_ISREG(statptr->st_mode)) { + if (parsed.capabilities == 0) { + if ((removexattr(filename, XATTR_NAME_CAPS) == -1) && (errno != ENODATA)) { + // Report failure unless it's ENODATA (attribute not set) + uiPrintf(state, "ApplyParsedPerms: removexattr of %s to %" PRIx64 " failed: %s\n", filename, + parsed.capabilities, strerror(errno)); + bad++; + } + } else { + struct vfs_cap_data cap_data; + memset(&cap_data, 0, sizeof(cap_data)); + cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE; + cap_data.data[0].permitted = (uint32_t)(parsed.capabilities & 0xffffffff); + cap_data.data[0].inheritable = 0; + cap_data.data[1].permitted = (uint32_t)(parsed.capabilities >> 32); + cap_data.data[1].inheritable = 0; + if (setxattr(filename, XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) { + uiPrintf(state, "ApplyParsedPerms: setcap of %s to %" PRIx64 " failed: %s\n", filename, + parsed.capabilities, strerror(errno)); + bad++; + } } + } - return bad; + return bad; } // nftw doesn't allow us to pass along context, so we need to use @@ -810,60 +797,60 @@ static int ApplyParsedPerms( static struct perm_parsed_args recursive_parsed_args; static State* recursive_state; -static int do_SetMetadataRecursive(const char* filename, const struct stat *statptr, - int fileflags, struct FTW *pfwt) { - return ApplyParsedPerms(recursive_state, filename, statptr, recursive_parsed_args); +static int do_SetMetadataRecursive(const char* filename, const struct stat* statptr, int fileflags, + struct FTW* pfwt) { + return ApplyParsedPerms(recursive_state, filename, statptr, recursive_parsed_args); } static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv[]) { - if ((argc % 2) != 1) { - return ErrorAbort(state, kArgsParsingFailure, - "%s() expects an odd number of arguments, got %d", name, argc); - } + if ((argc % 2) != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects an odd number of arguments, got %d", + name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } - struct stat sb; - if (lstat(args[0].c_str(), &sb) == -1) { - return ErrorAbort(state, kSetMetadataFailure, "%s: Error on lstat of \"%s\": %s", - name, args[0].c_str(), strerror(errno)); - } + struct stat sb; + if (lstat(args[0].c_str(), &sb) == -1) { + return ErrorAbort(state, kSetMetadataFailure, "%s: Error on lstat of \"%s\": %s", name, + args[0].c_str(), strerror(errno)); + } - struct perm_parsed_args parsed = ParsePermArgs(state, argc, args); - int bad = 0; - bool recursive = (strcmp(name, "set_metadata_recursive") == 0); + struct perm_parsed_args parsed = ParsePermArgs(state, argc, args); + int bad = 0; + bool recursive = (strcmp(name, "set_metadata_recursive") == 0); - if (recursive) { - recursive_parsed_args = parsed; - recursive_state = state; - bad += nftw(args[0].c_str(), do_SetMetadataRecursive, 30, FTW_CHDIR | FTW_DEPTH | FTW_PHYS); - memset(&recursive_parsed_args, 0, sizeof(recursive_parsed_args)); - recursive_state = NULL; - } else { - bad += ApplyParsedPerms(state, args[0].c_str(), &sb, parsed); - } + if (recursive) { + recursive_parsed_args = parsed; + recursive_state = state; + bad += nftw(args[0].c_str(), do_SetMetadataRecursive, 30, FTW_CHDIR | FTW_DEPTH | FTW_PHYS); + memset(&recursive_parsed_args, 0, sizeof(recursive_parsed_args)); + recursive_state = NULL; + } else { + bad += ApplyParsedPerms(state, args[0].c_str(), &sb, parsed); + } - if (bad > 0) { - return ErrorAbort(state, kSetMetadataFailure, "%s: some changes failed", name); - } + if (bad > 0) { + return ErrorAbort(state, kSetMetadataFailure, "%s: some changes failed", name); + } - return StringValue(""); + return StringValue(""); } Value* GetPropFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); - } - std::string key; - if (!Evaluate(state, argv[0], &key)) { - return nullptr; - } - std::string value = android::base::GetProperty(key, ""); + if (argc != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); + } + std::string key; + if (!Evaluate(state, argv[0], &key)) { + return nullptr; + } + std::string value = android::base::GetProperty(key, ""); - return StringValue(value); + return StringValue(value); } // file_getprop(file, key) @@ -936,25 +923,34 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) { } // apply_patch_space(bytes) -Value* ApplyPatchSpaceFn(const char* name, State* state, - int argc, Expr* argv[]) { - std::vector<std::string> args; - if (!ReadArgs(state, 1, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& bytes_str = args[0]; +Value* ApplyPatchSpaceFn(const char* name, State* state, int argc, Expr* argv[]) { + std::vector<std::string> args; + if (!ReadArgs(state, 1, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& bytes_str = args[0]; - size_t bytes; - if (!android::base::ParseUint(bytes_str.c_str(), &bytes)) { - return ErrorAbort(state, kArgsParsingFailure, "%s(): can't parse \"%s\" as byte count\n\n", - name, bytes_str.c_str()); - } + size_t bytes; + if (!android::base::ParseUint(bytes_str.c_str(), &bytes)) { + return ErrorAbort(state, kArgsParsingFailure, "%s(): can't parse \"%s\" as byte count\n\n", + name, bytes_str.c_str()); + } - return StringValue(CacheSizeCheck(bytes) ? "" : "t"); + return StringValue(CacheSizeCheck(bytes) ? "" : "t"); } -// apply_patch(file, size, init_sha1, tgt_sha1, patch) - +// apply_patch(src_file, tgt_file, tgt_sha1, tgt_size, patch1_sha1, patch1_blob, [...]) +// Applies a binary patch to the src_file to produce the tgt_file. If the desired target is the +// same as the source, pass "-" for tgt_file. tgt_sha1 and tgt_size are the expected final SHA1 +// hash and size of the target file. The remaining arguments must come in pairs: a SHA1 hash (a +// 40-character hex string) and a blob. The blob is the patch to be applied when the source +// file's current contents have the given SHA1. +// +// The patching is done in a safe manner that guarantees the target file either has the desired +// SHA1 hash and size, or it is untouched -- it will not be left in an unrecoverable intermediate +// state. If the process is interrupted during patching, the target file may be in an intermediate +// state; a copy exists in the cache partition so restarting the update can successfully update +// the file. Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) { if (argc < 6 || (argc % 2) == 1) { return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 6 args and an " @@ -1007,87 +1003,90 @@ Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) { return StringValue(result == 0 ? "t" : ""); } -// apply_patch_check(file, [sha1_1, ...]) -Value* ApplyPatchCheckFn(const char* name, State* state, - int argc, Expr* argv[]) { - if (argc < 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 1 arg, got %d", - name, argc); - } +// apply_patch_check(filename, [sha1, ...]) +// Returns true if the contents of filename or the temporary copy in the cache partition (if +// present) have a SHA-1 checksum equal to one of the given sha1 values. sha1 values are +// specified as 40 hex digits. This function differs from sha1_check(read_file(filename), +// sha1 [, ...]) in that it knows to check the cache partition copy, so apply_patch_check() will +// succeed even if the file was corrupted by an interrupted apply_patch() update. +Value* ApplyPatchCheckFn(const char* name, State* state, int argc, Expr* argv[]) { + if (argc < 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 1 arg, got %d", name, + argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, 1, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& filename = args[0]; + std::vector<std::string> args; + if (!ReadArgs(state, 1, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& filename = args[0]; - std::vector<std::string> sha1s; - if (!ReadArgs(state, argc - 1, argv + 1, &sha1s)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - int result = applypatch_check(filename.c_str(), sha1s); + std::vector<std::string> sha1s; + if (!ReadArgs(state, argc - 1, argv + 1, &sha1s)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + int result = applypatch_check(filename.c_str(), sha1s); - return StringValue(result == 0 ? "t" : ""); + return StringValue(result == 0 ? "t" : ""); } // This is the updater side handler for ui_print() in edify script. Contents // will be sent over to the recovery side for on-screen display. Value* UIPrintFn(const char* name, State* state, int argc, Expr* argv[]) { - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } - std::string buffer = android::base::Join(args, "") + "\n"; - uiPrint(state, buffer); - return StringValue(buffer); + std::string buffer = android::base::Join(args, "") + "\n"; + uiPrint(state, buffer); + return StringValue(buffer); } Value* WipeCacheFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 0) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); - } - fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe, "wipe_cache\n"); - return StringValue("t"); + if (argc != 0) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); + } + fprintf(static_cast<UpdaterInfo*>(state->cookie)->cmd_pipe, "wipe_cache\n"); + return StringValue("t"); } Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc < 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects at least 1 arg", name); - } + if (argc < 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects at least 1 arg", name); + } - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } - char* args2[argc+1]; - for (int i = 0; i < argc; i++) { - args2[i] = &args[i][0]; - } - args2[argc] = nullptr; + char* args2[argc + 1]; + for (int i = 0; i < argc; i++) { + args2[i] = &args[i][0]; + } + args2[argc] = nullptr; - printf("about to run program [%s] with %d args\n", args2[0], argc); + LOG(INFO) << "about to run program [" << args2[0] << "] with " << argc << " args"; - pid_t child = fork(); - if (child == 0) { - execv(args2[0], args2); - printf("run_program: execv failed: %s\n", strerror(errno)); - _exit(1); - } - int status; - waitpid(child, &status, 0); - if (WIFEXITED(status)) { - if (WEXITSTATUS(status) != 0) { - printf("run_program: child exited with status %d\n", - WEXITSTATUS(status)); - } - } else if (WIFSIGNALED(status)) { - printf("run_program: child terminated by signal %d\n", - WTERMSIG(status)); + pid_t child = fork(); + if (child == 0) { + execv(args2[0], args2); + PLOG(ERROR) << "run_program: execv failed"; + _exit(1); + } + + int status; + waitpid(child, &status, 0); + if (WIFEXITED(status)) { + if (WEXITSTATUS(status) != 0) { + LOG(ERROR) << "run_program: child exited with status " << WEXITSTATUS(status); } + } else if (WIFSIGNALED(status)) { + LOG(ERROR) << "run_program: child terminated by signal " << WTERMSIG(status); + } - return StringValue(android::base::StringPrintf("%d", status)); + return StringValue(std::to_string(status)); } // sha1_check(data) @@ -1099,63 +1098,63 @@ Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) { // strings passed, or "" if it does not equal any of them. // Value* Sha1CheckFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc < 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects at least 1 arg", name); - } + if (argc < 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects at least 1 arg", name); + } - std::vector<std::unique_ptr<Value>> args; - if (!ReadValueArgs(state, argc, argv, &args)) { - return nullptr; - } + std::vector<std::unique_ptr<Value>> args; + if (!ReadValueArgs(state, argc, argv, &args)) { + return nullptr; + } - if (args[0]->type == VAL_INVALID) { - return StringValue(""); - } - uint8_t digest[SHA_DIGEST_LENGTH]; - SHA1(reinterpret_cast<const uint8_t*>(args[0]->data.c_str()), args[0]->data.size(), digest); + if (args[0]->type == VAL_INVALID) { + return StringValue(""); + } + uint8_t digest[SHA_DIGEST_LENGTH]; + SHA1(reinterpret_cast<const uint8_t*>(args[0]->data.c_str()), args[0]->data.size(), digest); - if (argc == 1) { - return StringValue(print_sha1(digest)); - } + if (argc == 1) { + return StringValue(print_sha1(digest)); + } - for (int i = 1; i < argc; ++i) { - uint8_t arg_digest[SHA_DIGEST_LENGTH]; - if (args[i]->type != VAL_STRING) { - printf("%s(): arg %d is not a string; skipping", name, i); - } else if (ParseSha1(args[i]->data.c_str(), arg_digest) != 0) { - // Warn about bad args and skip them. - printf("%s(): error parsing \"%s\" as sha-1; skipping", name, args[i]->data.c_str()); - } else if (memcmp(digest, arg_digest, SHA_DIGEST_LENGTH) == 0) { - // Found a match. - return args[i].release(); - } + for (int i = 1; i < argc; ++i) { + uint8_t arg_digest[SHA_DIGEST_LENGTH]; + if (args[i]->type != VAL_STRING) { + LOG(ERROR) << name << "(): arg " << i << " is not a string; skipping"; + } else if (ParseSha1(args[i]->data.c_str(), arg_digest) != 0) { + // Warn about bad args and skip them. + LOG(ERROR) << name << "(): error parsing \"" << args[i]->data << "\" as sha-1; skipping"; + } else if (memcmp(digest, arg_digest, SHA_DIGEST_LENGTH) == 0) { + // Found a match. + return args[i].release(); } + } - // Didn't match any of the hex strings; return false. - return StringValue(""); + // Didn't match any of the hex strings; return false. + return StringValue(""); } // Read a local file and return its contents (the Value* returned // is actually a FileContents*). Value* ReadFileFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 1) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); - } + if (argc != 1) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); + } - std::vector<std::string> args; - if (!ReadArgs(state, 1, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); - } - const std::string& filename = args[0]; + std::vector<std::string> args; + if (!ReadArgs(state, 1, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); + } + const std::string& filename = args[0]; - Value* v = new Value(VAL_INVALID, ""); + Value* v = new Value(VAL_INVALID, ""); - FileContents fc; - if (LoadFileContents(filename.c_str(), &fc) == 0) { - v->type = VAL_BLOB; - v->data = std::string(fc.data.begin(), fc.data.end()); - } - return v; + FileContents fc; + if (LoadFileContents(filename.c_str(), &fc) == 0) { + v->type = VAL_BLOB; + v->data = std::string(fc.data.begin(), fc.data.end()); + } + return v; } // write_value(value, filename) @@ -1178,7 +1177,7 @@ Value* WriteValueFn(const char* name, State* state, int argc, Expr* argv[]) { const std::string& value = args[0]; if (!android::base::WriteStringToFile(value, filename)) { - printf("%s: Failed to write to \"%s\": %s\n", name, filename.c_str(), strerror(errno)); + PLOG(ERROR) << name << ": Failed to write to \"" << filename << "\""; return StringValue(""); } else { return StringValue("t"); @@ -1210,12 +1209,12 @@ Value* RebootNowFn(const char* name, State* state, int argc, Expr* argv[]) { bootloader_message boot; std::string err; if (!read_bootloader_message_from(&boot, filename, &err)) { - printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); + LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err; return StringValue(""); } memset(boot.command, 0, sizeof(boot.command)); if (!write_bootloader_message_to(boot, filename, &err)) { - printf("%s(): Failed to write to \"%s\": %s", name, filename.c_str(), err.c_str()); + LOG(ERROR) << name << "(): Failed to write to \"" << filename << "\": " << err; return StringValue(""); } @@ -1255,12 +1254,12 @@ Value* SetStageFn(const char* name, State* state, int argc, Expr* argv[]) { bootloader_message boot; std::string err; if (!read_bootloader_message_from(&boot, filename, &err)) { - printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); + LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err; return StringValue(""); } strlcpy(boot.stage, stagestr.c_str(), sizeof(boot.stage)); if (!write_bootloader_message_to(boot, filename, &err)) { - printf("%s(): Failed to write to \"%s\": %s", name, filename.c_str(), err.c_str()); + LOG(ERROR) << name << "(): Failed to write to \"" << filename << "\": " << err; return StringValue(""); } @@ -1283,7 +1282,7 @@ Value* GetStageFn(const char* name, State* state, int argc, Expr* argv[]) { bootloader_message boot; std::string err; if (!read_bootloader_message_from(&boot, filename, &err)) { - printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); + LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err; return StringValue(""); } @@ -1314,93 +1313,94 @@ Value* WipeBlockDeviceFn(const char* name, State* state, int argc, Expr* argv[]) } Value* EnableRebootFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc != 0) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); - } - UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); - fprintf(ui->cmd_pipe, "enable_reboot\n"); - return StringValue("t"); + if (argc != 0) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); + } + UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie); + fprintf(ui->cmd_pipe, "enable_reboot\n"); + return StringValue("t"); } Value* Tune2FsFn(const char* name, State* state, int argc, Expr* argv[]) { - if (argc == 0) { - return ErrorAbort(state, kArgsParsingFailure, "%s() expects args, got %d", name, argc); - } - - std::vector<std::string> args; - if (!ReadArgs(state, argc, argv, &args)) { - return ErrorAbort(state, kArgsParsingFailure, "%s() could not read args", name); - } + if (argc == 0) { + return ErrorAbort(state, kArgsParsingFailure, "%s() expects args, got %d", name, argc); + } - char* args2[argc+1]; - // Tune2fs expects the program name as its args[0] - args2[0] = const_cast<char*>(name); - if (args2[0] == nullptr) { - return nullptr; - } - for (int i = 0; i < argc; ++i) { - args2[i + 1] = &args[i][0]; - } + std::vector<std::string> args; + if (!ReadArgs(state, argc, argv, &args)) { + return ErrorAbort(state, kArgsParsingFailure, "%s() could not read args", name); + } - // tune2fs changes the file system parameters on an ext2 file system; it - // returns 0 on success. - int result = tune2fs_main(argc + 1, args2); + char* args2[argc + 1]; + // Tune2fs expects the program name as its args[0] + args2[0] = const_cast<char*>(name); + if (args2[0] == nullptr) { + return nullptr; + } + for (int i = 0; i < argc; ++i) { + args2[i + 1] = &args[i][0]; + } - if (result != 0) { - return ErrorAbort(state, kTune2FsFailure, "%s() returned error code %d", name, result); - } - return StringValue("t"); + // tune2fs changes the file system parameters on an ext2 file system; it + // returns 0 on success. + int result = tune2fs_main(argc + 1, args2); + if (result != 0) { + return ErrorAbort(state, kTune2FsFailure, "%s() returned error code %d", name, result); + } + return StringValue("t"); } void RegisterInstallFunctions() { - RegisterFunction("mount", MountFn); - RegisterFunction("is_mounted", IsMountedFn); - RegisterFunction("unmount", UnmountFn); - RegisterFunction("format", FormatFn); - RegisterFunction("show_progress", ShowProgressFn); - RegisterFunction("set_progress", SetProgressFn); - RegisterFunction("delete", DeleteFn); - RegisterFunction("delete_recursive", DeleteFn); - RegisterFunction("package_extract_dir", PackageExtractDirFn); - RegisterFunction("package_extract_file", PackageExtractFileFn); - RegisterFunction("symlink", SymlinkFn); - - // Usage: - // set_metadata("filename", "key1", "value1", "key2", "value2", ...) - // Example: - // set_metadata("/system/bin/netcfg", "uid", 0, "gid", 3003, "mode", 02750, "selabel", "u:object_r:system_file:s0", "capabilities", 0x0); - RegisterFunction("set_metadata", SetMetadataFn); - - // Usage: - // set_metadata_recursive("dirname", "key1", "value1", "key2", "value2", ...) - // Example: - // set_metadata_recursive("/system", "uid", 0, "gid", 0, "fmode", 0644, "dmode", 0755, "selabel", "u:object_r:system_file:s0", "capabilities", 0x0); - RegisterFunction("set_metadata_recursive", SetMetadataFn); - - RegisterFunction("getprop", GetPropFn); - RegisterFunction("file_getprop", FileGetPropFn); - - RegisterFunction("apply_patch", ApplyPatchFn); - RegisterFunction("apply_patch_check", ApplyPatchCheckFn); - RegisterFunction("apply_patch_space", ApplyPatchSpaceFn); - - RegisterFunction("wipe_block_device", WipeBlockDeviceFn); - - RegisterFunction("read_file", ReadFileFn); - RegisterFunction("sha1_check", Sha1CheckFn); - RegisterFunction("rename", RenameFn); - RegisterFunction("write_value", WriteValueFn); - - RegisterFunction("wipe_cache", WipeCacheFn); - - RegisterFunction("ui_print", UIPrintFn); - - RegisterFunction("run_program", RunProgramFn); - - RegisterFunction("reboot_now", RebootNowFn); - RegisterFunction("get_stage", GetStageFn); - RegisterFunction("set_stage", SetStageFn); - - RegisterFunction("enable_reboot", EnableRebootFn); - RegisterFunction("tune2fs", Tune2FsFn); + RegisterFunction("mount", MountFn); + RegisterFunction("is_mounted", IsMountedFn); + RegisterFunction("unmount", UnmountFn); + RegisterFunction("format", FormatFn); + RegisterFunction("show_progress", ShowProgressFn); + RegisterFunction("set_progress", SetProgressFn); + RegisterFunction("delete", DeleteFn); + RegisterFunction("delete_recursive", DeleteFn); + RegisterFunction("package_extract_dir", PackageExtractDirFn); + RegisterFunction("package_extract_file", PackageExtractFileFn); + RegisterFunction("symlink", SymlinkFn); + + // Usage: + // set_metadata("filename", "key1", "value1", "key2", "value2", ...) + // Example: + // set_metadata("/system/bin/netcfg", "uid", 0, "gid", 3003, "mode", 02750, "selabel", + // "u:object_r:system_file:s0", "capabilities", 0x0); + RegisterFunction("set_metadata", SetMetadataFn); + + // Usage: + // set_metadata_recursive("dirname", "key1", "value1", "key2", "value2", ...) + // Example: + // set_metadata_recursive("/system", "uid", 0, "gid", 0, "fmode", 0644, "dmode", 0755, + // "selabel", "u:object_r:system_file:s0", "capabilities", 0x0); + RegisterFunction("set_metadata_recursive", SetMetadataFn); + + RegisterFunction("getprop", GetPropFn); + RegisterFunction("file_getprop", FileGetPropFn); + + RegisterFunction("apply_patch", ApplyPatchFn); + RegisterFunction("apply_patch_check", ApplyPatchCheckFn); + RegisterFunction("apply_patch_space", ApplyPatchSpaceFn); + + RegisterFunction("wipe_block_device", WipeBlockDeviceFn); + + RegisterFunction("read_file", ReadFileFn); + RegisterFunction("sha1_check", Sha1CheckFn); + RegisterFunction("rename", RenameFn); + RegisterFunction("write_value", WriteValueFn); + + RegisterFunction("wipe_cache", WipeCacheFn); + + RegisterFunction("ui_print", UIPrintFn); + + RegisterFunction("run_program", RunProgramFn); + + RegisterFunction("reboot_now", RebootNowFn); + RegisterFunction("get_stage", GetStageFn); + RegisterFunction("set_stage", SetStageFn); + + RegisterFunction("enable_reboot", EnableRebootFn); + RegisterFunction("tune2fs", Tune2FsFn); } diff --git a/updater/updater.cpp b/updater/updater.cpp index 7327c52e3..3e624dae7 100644 --- a/updater/updater.cpp +++ b/updater/updater.cpp @@ -23,6 +23,7 @@ #include <string> +#include <android-base/logging.h> #include <android-base/strings.h> #include <selinux/label.h> #include <selinux/selinux.h> @@ -42,174 +43,178 @@ // Where in the package we expect to find the edify script to execute. // (Note it's "updateR-script", not the older "update-script".) -#define SCRIPT_NAME "META-INF/com/google/android/updater-script" +static constexpr const char* SCRIPT_NAME = "META-INF/com/google/android/updater-script"; extern bool have_eio_error; struct selabel_handle *sehandle; -int main(int argc, char** argv) { - // Various things log information to stdout or stderr more or less - // at random (though we've tried to standardize on stdout). The - // log file makes more sense if buffering is turned off so things - // appear in the right order. - setbuf(stdout, NULL); - setbuf(stderr, NULL); - - if (argc != 4 && argc != 5) { - printf("unexpected number of arguments (%d)\n", argc); - return 1; - } - - char* version = argv[1]; - if ((version[0] != '1' && version[0] != '2' && version[0] != '3') || - version[1] != '\0') { - // We support version 1, 2, or 3. - printf("wrong updater binary API; expected 1, 2, or 3; " - "got %s\n", - argv[1]); - return 2; - } - - // Set up the pipe for sending commands back to the parent process. - - int fd = atoi(argv[2]); - FILE* cmd_pipe = fdopen(fd, "wb"); - setlinebuf(cmd_pipe); - - // Extract the script from the package. - - const char* package_filename = argv[3]; - MemMapping map; - if (sysMapFile(package_filename, &map) != 0) { - printf("failed to map package %s\n", argv[3]); - return 3; - } - ZipArchiveHandle za; - int open_err = OpenArchiveFromMemory(map.addr, map.length, argv[3], &za); - if (open_err != 0) { - printf("failed to open package %s: %s\n", - argv[3], ErrorCodeString(open_err)); - CloseArchive(za); - return 3; - } - ota_io_init(za); - - ZipString script_name(SCRIPT_NAME); - ZipEntry script_entry; - int find_err = FindEntry(za, script_name, &script_entry); - if (find_err != 0) { - printf("failed to find %s in %s: %s\n", SCRIPT_NAME, package_filename, - ErrorCodeString(find_err)); - CloseArchive(za); - return 4; - } - - std::string script; - script.resize(script_entry.uncompressed_length); - int extract_err = ExtractToMemory(za, &script_entry, reinterpret_cast<uint8_t*>(&script[0]), - script_entry.uncompressed_length); - if (extract_err != 0) { - printf("failed to read script from package: %s\n", ErrorCodeString(extract_err)); - CloseArchive(za); - return 5; - } - - // Configure edify's functions. - - RegisterBuiltins(); - RegisterInstallFunctions(); - RegisterBlockImageFunctions(); - RegisterDeviceExtensions(); - - // Parse the script. - - Expr* root; - int error_count = 0; - int error = parse_string(script.c_str(), &root, &error_count); - if (error != 0 || error_count > 0) { - printf("%d parse errors\n", error_count); - CloseArchive(za); - return 6; - } - - struct selinux_opt seopts[] = { - { SELABEL_OPT_PATH, "/file_contexts" } - }; - - sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1); +static void UpdaterLogger(android::base::LogId /* id */, android::base::LogSeverity /* severity */, + const char* /* tag */, const char* /* file */, unsigned int /* line */, + const char* message) { + fprintf(stdout, "%s\n", message); +} - if (!sehandle) { - fprintf(cmd_pipe, "ui_print Warning: No file_contexts\n"); +int main(int argc, char** argv) { + // Various things log information to stdout or stderr more or less + // at random (though we've tried to standardize on stdout). The + // log file makes more sense if buffering is turned off so things + // appear in the right order. + setbuf(stdout, nullptr); + setbuf(stderr, nullptr); + + // We don't have logcat yet under recovery. Update logs will always be written to stdout + // (which is redirected to recovery.log). + android::base::InitLogging(argv, &UpdaterLogger); + + if (argc != 4 && argc != 5) { + LOG(ERROR) << "unexpected number of arguments: " << argc; + return 1; + } + + char* version = argv[1]; + if ((version[0] != '1' && version[0] != '2' && version[0] != '3') || version[1] != '\0') { + // We support version 1, 2, or 3. + LOG(ERROR) << "wrong updater binary API; expected 1, 2, or 3; got " << argv[1]; + return 2; + } + + // Set up the pipe for sending commands back to the parent process. + + int fd = atoi(argv[2]); + FILE* cmd_pipe = fdopen(fd, "wb"); + setlinebuf(cmd_pipe); + + // Extract the script from the package. + + const char* package_filename = argv[3]; + MemMapping map; + if (sysMapFile(package_filename, &map) != 0) { + LOG(ERROR) << "failed to map package " << argv[3]; + return 3; + } + ZipArchiveHandle za; + int open_err = OpenArchiveFromMemory(map.addr, map.length, argv[3], &za); + if (open_err != 0) { + LOG(ERROR) << "failed to open package " << argv[3] << ": " << ErrorCodeString(open_err); + CloseArchive(za); + return 3; + } + ota_io_init(za); + + ZipString script_name(SCRIPT_NAME); + ZipEntry script_entry; + int find_err = FindEntry(za, script_name, &script_entry); + if (find_err != 0) { + LOG(ERROR) << "failed to find " << SCRIPT_NAME << " in " << package_filename << ": " + << ErrorCodeString(find_err); + CloseArchive(za); + return 4; + } + + std::string script; + script.resize(script_entry.uncompressed_length); + int extract_err = ExtractToMemory(za, &script_entry, reinterpret_cast<uint8_t*>(&script[0]), + script_entry.uncompressed_length); + if (extract_err != 0) { + LOG(ERROR) << "failed to read script from package: " << ErrorCodeString(extract_err); + CloseArchive(za); + return 5; + } + + // Configure edify's functions. + + RegisterBuiltins(); + RegisterInstallFunctions(); + RegisterBlockImageFunctions(); + RegisterDeviceExtensions(); + + // Parse the script. + + Expr* root; + int error_count = 0; + int error = parse_string(script.c_str(), &root, &error_count); + if (error != 0 || error_count > 0) { + LOG(ERROR) << error_count << " parse errors"; + CloseArchive(za); + return 6; + } + + struct selinux_opt seopts[] = { { SELABEL_OPT_PATH, "/file_contexts" } }; + + sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1); + + if (!sehandle) { + fprintf(cmd_pipe, "ui_print Warning: No file_contexts\n"); + } + + // Evaluate the parsed script. + + UpdaterInfo updater_info; + updater_info.cmd_pipe = cmd_pipe; + updater_info.package_zip = za; + updater_info.version = atoi(version); + updater_info.package_zip_addr = map.addr; + updater_info.package_zip_len = map.length; + + State state(script, &updater_info); + + if (argc == 5) { + if (strcmp(argv[4], "retry") == 0) { + state.is_retry = true; + } else { + printf("unexpected argument: %s", argv[4]); } + } - // Evaluate the parsed script. + std::string result; + bool status = Evaluate(&state, root, &result); - UpdaterInfo updater_info; - updater_info.cmd_pipe = cmd_pipe; - updater_info.package_zip = za; - updater_info.version = atoi(version); - updater_info.package_zip_addr = map.addr; - updater_info.package_zip_len = map.length; + if (have_eio_error) { + fprintf(cmd_pipe, "retry_update\n"); + } - State state(script, &updater_info); - - if (argc == 5) { - if (strcmp(argv[4], "retry") == 0) { - state.is_retry = true; - } else { - printf("unexpected argument: %s", argv[4]); + if (!status) { + if (state.errmsg.empty()) { + LOG(ERROR) << "script aborted (no error message)"; + fprintf(cmd_pipe, "ui_print script aborted (no error message)\n"); + } else { + LOG(ERROR) << "script aborted: " << state.errmsg; + const std::vector<std::string> lines = android::base::Split(state.errmsg, "\n"); + for (const std::string& line : lines) { + // Parse the error code in abort message. + // Example: "E30: This package is for bullhead devices." + if (!line.empty() && line[0] == 'E') { + if (sscanf(line.c_str(), "E%u: ", &state.error_code) != 1) { + LOG(ERROR) << "Failed to parse error code: [" << line << "]"; + } } + fprintf(cmd_pipe, "ui_print %s\n", line.c_str()); + } + fprintf(cmd_pipe, "ui_print\n"); } - std::string result; - bool status = Evaluate(&state, root, &result); - - if (have_eio_error) { - fprintf(cmd_pipe, "retry_update\n"); - } - - if (!status) { - if (state.errmsg.empty()) { - printf("script aborted (no error message)\n"); - fprintf(cmd_pipe, "ui_print script aborted (no error message)\n"); - } else { - printf("script aborted: %s\n", state.errmsg.c_str()); - const std::vector<std::string> lines = android::base::Split(state.errmsg, "\n"); - for (const std::string& line : lines) { - // Parse the error code in abort message. - // Example: "E30: This package is for bullhead devices." - if (!line.empty() && line[0] == 'E') { - if (sscanf(line.c_str(), "E%u: ", &state.error_code) != 1) { - printf("Failed to parse error code: [%s]\n", line.c_str()); - } - } - fprintf(cmd_pipe, "ui_print %s\n", line.c_str()); - } - fprintf(cmd_pipe, "ui_print\n"); - } - - if (state.error_code != kNoError) { - fprintf(cmd_pipe, "log error: %d\n", state.error_code); - // Cause code should provide additional information about the abort; - // report only when an error exists. - if (state.cause_code != kNoCause) { - fprintf(cmd_pipe, "log cause: %d\n", state.cause_code); - } - } - - if (updater_info.package_zip) { - CloseArchive(updater_info.package_zip); - } - return 7; - } else { - fprintf(cmd_pipe, "ui_print script succeeded: result was [%s]\n", result.c_str()); + if (state.error_code != kNoError) { + fprintf(cmd_pipe, "log error: %d\n", state.error_code); + // Cause code should provide additional information about the abort; + // report only when an error exists. + if (state.cause_code != kNoCause) { + fprintf(cmd_pipe, "log cause: %d\n", state.cause_code); + } } if (updater_info.package_zip) { - CloseArchive(updater_info.package_zip); + CloseArchive(updater_info.package_zip); } - sysReleaseMap(&map); + return 7; + } else { + fprintf(cmd_pipe, "ui_print script succeeded: result was [%s]\n", result.c_str()); + } + + if (updater_info.package_zip) { + CloseArchive(updater_info.package_zip); + } + sysReleaseMap(&map); - return 0; + return 0; } |