Merge "updater: Switch to libbase logging." am: d2c56629ab am: 1d9779b57b am: 997ccbc5a4
am: dd570b59ad
Change-Id: Idd86b944b6ce8577f992435853259badd90d5101
diff --git a/updater/blockimg.cpp b/updater/blockimg.cpp
index c939cf8..7257e23 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
*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 @@
}
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 @@
// 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 @@
*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 @@
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 @@
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 @@
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 @@
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 @@
// <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 @@
// 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 @@
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 @@
// 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 @@
// <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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
}
// 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 @@
}
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 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 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 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 @@
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 @@
// <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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
}
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
}
// 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 @@
// 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 8db5c1f..3cf3877 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);
+ 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");
- }
+ // "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 @@
// 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;
+ 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;
}
- return true;
+ 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 @@
//
// 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];
+ }
+
+ 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 = nullptr;
+
+ if (sehandle) {
+ selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755);
+ setfscreatecon(secontext);
}
- 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;
+ mkdir(mount_point.c_str(), 0755);
- if (argc == 5) {
- mount_options = args[4];
+ if (secontext) {
+ freecon(secontext);
+ setfscreatecon(nullptr);
}
+ }
- 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 (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("");
+ }
- {
- char *secontext = NULL;
-
- if (sehandle) {
- selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755);
- setfscreatecon(secontext);
- }
-
- mkdir(mount_point.c_str(), 0755);
-
- if (secontext) {
- freecon(secontext);
- setfscreatecon(NULL);
- }
- }
-
- 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];
+ 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);
- }
+ 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("");
}
-
- 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());
+ 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);
- return nullptr;
+ 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;
}
// 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);
- }
+ 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];
+ 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));
- }
-
+ 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 @@
// 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 @@
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 @@
// 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;
- }
+ 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;
}
- if (bad != 0) {
- return ErrorAbort(state, kSymlinkFailure, "%s: Failed to create %zu symlink(s)", name, 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;
+ struct perm_parsed_args parsed;
+ int bad = 0;
+ static int max_warnings = 20;
- memset(&parsed, 0, sizeof(parsed));
+ 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");
- }
- }
+ 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;
}
- return parsed;
+ 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) {
+ 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;
+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++;
- }
+ 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++;
}
+ }
- /* 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_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_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++;
- }
- }
- }
-
+ /* 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_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_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++;
+ }
+ }
+ }
+
+ return bad;
}
// nftw doesn't allow us to pass along context, so we need to use
@@ -810,60 +797,60 @@
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 @@
}
// 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 @@
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);
+ }
- return StringValue(android::base::StringPrintf("%d", status));
+ 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(std::to_string(status));
}
// sha1_check(data)
@@ -1099,63 +1098,63 @@
// 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 (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();
- }
- }
-
- // Didn't match any of the hex strings; return false.
+ 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));
+ }
+
+ 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("");
}
// 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 @@
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 @@
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 @@
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 @@
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* 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);
- }
+ 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);
- }
+ std::vector<std::string> args;
+ if (!ReadArgs(state, argc, argv, &args)) {
+ return ErrorAbort(state, kArgsParsingFailure, "%s() could not read args", name);
+ }
- 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];
- }
+ 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];
+ }
- // 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");
+ // 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);
+ 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("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);
+ // 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("getprop", GetPropFn);
+ RegisterFunction("file_getprop", FileGetPropFn);
- RegisterFunction("apply_patch", ApplyPatchFn);
- RegisterFunction("apply_patch_check", ApplyPatchCheckFn);
- RegisterFunction("apply_patch_space", ApplyPatchSpaceFn);
+ RegisterFunction("apply_patch", ApplyPatchFn);
+ RegisterFunction("apply_patch_check", ApplyPatchCheckFn);
+ RegisterFunction("apply_patch_space", ApplyPatchSpaceFn);
- RegisterFunction("wipe_block_device", WipeBlockDeviceFn);
+ RegisterFunction("wipe_block_device", WipeBlockDeviceFn);
- RegisterFunction("read_file", ReadFileFn);
- RegisterFunction("sha1_check", Sha1CheckFn);
- RegisterFunction("rename", RenameFn);
- RegisterFunction("write_value", WriteValueFn);
+ RegisterFunction("read_file", ReadFileFn);
+ RegisterFunction("sha1_check", Sha1CheckFn);
+ RegisterFunction("rename", RenameFn);
+ RegisterFunction("write_value", WriteValueFn);
- RegisterFunction("wipe_cache", WipeCacheFn);
+ RegisterFunction("wipe_cache", WipeCacheFn);
- RegisterFunction("ui_print", UIPrintFn);
+ RegisterFunction("ui_print", UIPrintFn);
- RegisterFunction("run_program", RunProgramFn);
+ RegisterFunction("run_program", RunProgramFn);
- RegisterFunction("reboot_now", RebootNowFn);
- RegisterFunction("get_stage", GetStageFn);
- RegisterFunction("set_stage", SetStageFn);
+ RegisterFunction("reboot_now", RebootNowFn);
+ RegisterFunction("get_stage", GetStageFn);
+ RegisterFunction("set_stage", SetStageFn);
- RegisterFunction("enable_reboot", EnableRebootFn);
- RegisterFunction("tune2fs", Tune2FsFn);
+ RegisterFunction("enable_reboot", EnableRebootFn);
+ RegisterFunction("tune2fs", Tune2FsFn);
}
diff --git a/updater/updater.cpp b/updater/updater.cpp
index 7327c52..3e624da 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;
+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);
+}
+
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);
+ // 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);
- if (argc != 4 && argc != 5) {
- printf("unexpected number of arguments (%d)\n", argc);
- return 1;
- }
+ // 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);
- 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;
- }
+ if (argc != 4 && argc != 5) {
+ LOG(ERROR) << "unexpected number of arguments: " << argc;
+ return 1;
+ }
- // Set up the pipe for sending commands back to the parent process.
+ 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;
+ }
- int fd = atoi(argv[2]);
- FILE* cmd_pipe = fdopen(fd, "wb");
- setlinebuf(cmd_pipe);
+ // Set up the pipe for sending commands back to the parent process.
- // Extract the script from the package.
+ int fd = atoi(argv[2]);
+ FILE* cmd_pipe = fdopen(fd, "wb");
+ setlinebuf(cmd_pipe);
- 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);
+ // Extract the script from the package.
- 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;
- }
+ 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);
- 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;
- }
+ 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;
+ }
- // Configure edify's functions.
+ 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;
+ }
- RegisterBuiltins();
- RegisterInstallFunctions();
- RegisterBlockImageFunctions();
- RegisterDeviceExtensions();
+ // Configure edify's functions.
- // Parse the script.
+ RegisterBuiltins();
+ RegisterInstallFunctions();
+ RegisterBlockImageFunctions();
+ RegisterDeviceExtensions();
- 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;
- }
+ // Parse the script.
- struct selinux_opt seopts[] = {
- { SELABEL_OPT_PATH, "/file_contexts" }
- };
+ 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;
+ }
- sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
+ struct selinux_opt seopts[] = { { SELABEL_OPT_PATH, "/file_contexts" } };
- if (!sehandle) {
- fprintf(cmd_pipe, "ui_print Warning: No file_contexts\n");
- }
+ sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
- // Evaluate the parsed script.
+ if (!sehandle) {
+ fprintf(cmd_pipe, "ui_print Warning: No file_contexts\n");
+ }
- 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;
+ // Evaluate the parsed script.
- State state(script, &updater_info);
+ 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 (argc == 5) {
- if (strcmp(argv[4], "retry") == 0) {
- state.is_retry = true;
- } else {
- printf("unexpected argument: %s", argv[4]);
- }
- }
+ State state(script, &updater_info);
- 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;
+ if (argc == 5) {
+ if (strcmp(argv[4], "retry") == 0) {
+ state.is_retry = true;
} else {
- fprintf(cmd_pipe, "ui_print script succeeded: result was [%s]\n", result.c_str());
+ printf("unexpected argument: %s", argv[4]);
+ }
+ }
+
+ 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()) {
+ 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");
+ }
+
+ 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());
+ }
- return 0;
+ if (updater_info.package_zip) {
+ CloseArchive(updater_info.package_zip);
+ }
+ sysReleaseMap(&map);
+
+ return 0;
}