tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Switch recovery to libbase logging

Browse source 
Clean up the recovery image and switch to libbase logging.

Bug: 28191554
Change-Id: Icd999c3cc832f0639f204b5c36cea8afe303ad35
(cherry picked from commit 747781433f)
This commit is contained in:
Tianjie Xu 2016-08-05 18:00:04 -07:00
parent 28f6c43db5
commit c21edd4654
20 changed files with 352 additions and 546 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Android.mk
View file

@ -149,7 +149,7 @@ LOCAL_SRC_FILES := \
asn1_decoder.cpp \
verifier.cpp \
ui.cpp
LOCAL_STATIC_LIBRARIES := libcrypto_utils libcrypto
LOCAL_STATIC_LIBRARIES := libcrypto_utils libcrypto libbase
include $(BUILD_STATIC_LIBRARY)
include \

2
applypatch/Android.mk
View file

@ -80,7 +80,7 @@ LOCAL_STATIC_LIBRARIES += \
libminzip \
libcrypto \
libbz
LOCAL_SHARED_LIBRARIES += libz libcutils libc
LOCAL_SHARED_LIBRARIES += libbase libz libcutils libc
include $(BUILD_EXECUTABLE)
# imgdiff (host static executable)

12
common.h
View file

@ -21,18 +21,6 @@
#include <stdio.h>
#include <stdarg.h>
#define LOGE(...) ui_print("E:" __VA_ARGS__)
#define LOGW(...) fprintf(stdout, "W:" __VA_ARGS__)
#define LOGI(...) fprintf(stdout, "I:" __VA_ARGS__)
#if 0
#define LOGV(...) fprintf(stdout, "V:" __VA_ARGS__)
#define LOGD(...) fprintf(stdout, "D:" __VA_ARGS__)
#else
#define LOGV(...) do {} while (0)
#define LOGD(...) do {} while (0)
#endif
#define STRINGIFY(x) #x
#define EXPAND(x) STRINGIFY(x)

63
install.cpp
View file

@ -34,6 +34,7 @@
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <cutils/properties.h>
#include <android-base/logging.h>
#include "common.h"
#include "error_code.h"
@ -70,20 +71,20 @@ static int parse_build_number(const std::string& str) {
}
}
LOGE("Failed to parse build number in %s.\n", str.c_str());
LOG(ERROR) << "Failed to parse build number in " << str;
return -1;
}
bool read_metadata_from_package(ZipArchive* zip, std::string* meta_data) {
const ZipEntry* meta_entry = mzFindZipEntry(zip, METADATA_PATH);
if (meta_entry == nullptr) {
LOGE("Failed to find %s in update package.\n", METADATA_PATH);
LOG(ERROR) << "Failed to find " << METADATA_PATH << " in update package";
return false;
}
meta_data->resize(meta_entry->uncompLen, '\0');
if (!mzReadZipEntry(zip, meta_entry, &(*meta_data)[0], meta_entry->uncompLen)) {
LOGE("Failed to read metadata in update package.\n");
LOG(ERROR) << "Failed to read metadata in update package";
return false;
}
return true;
@ -148,8 +149,7 @@ static int check_newer_ab_build(ZipArchive* zip)
property_get("ro.product.device", value, "");
const std::string& pkg_device = metadata["pre-device"];
if (pkg_device != value || pkg_device.empty()) {
LOGE("Package is for product %s but expected %s\n",
pkg_device.c_str(), value);
LOG(ERROR) << "Package is for product " << pkg_device << " but expected " << value;
return INSTALL_ERROR;
}
@ -158,12 +158,12 @@ static int check_newer_ab_build(ZipArchive* zip)
property_get("ro.serialno", value, "");
const std::string& pkg_serial_no = metadata["serialno"];
if (!pkg_serial_no.empty() && pkg_serial_no != value) {
LOGE("Package is for serial %s\n", pkg_serial_no.c_str());
LOG(ERROR) << "Package is for serial " << pkg_serial_no;
return INSTALL_ERROR;
}
if (metadata["ota-type"] != "AB") {
LOGE("Package is not A/B\n");
LOG(ERROR) << "Package is not A/B";
return INSTALL_ERROR;
}
@ -171,16 +171,15 @@ static int check_newer_ab_build(ZipArchive* zip)
property_get("ro.build.version.incremental", value, "");
const std::string& pkg_pre_build = metadata["pre-build-incremental"];
if (!pkg_pre_build.empty() && pkg_pre_build != value) {
LOGE("Package is for source build %s but expected %s\n",
pkg_pre_build.c_str(), value);
LOG(ERROR) << "Package is for source build " << pkg_pre_build << " but expected " << value;
return INSTALL_ERROR;
}
property_get("ro.build.fingerprint", value, "");
const std::string& pkg_pre_build_fingerprint = metadata["pre-build"];
if (!pkg_pre_build_fingerprint.empty() &&
pkg_pre_build_fingerprint != value) {
LOGE("Package is for source build %s but expected %s\n",
pkg_pre_build_fingerprint.c_str(), value);
LOG(ERROR) << "Package is for source build " << pkg_pre_build_fingerprint
<< " but expected " << value;
return INSTALL_ERROR;
}
@ -195,15 +194,13 @@ static int check_newer_ab_build(ZipArchive* zip)
&pkg_post_timespampt) ||
pkg_post_timespampt < build_timestampt) {
if (metadata["ota-downgrade"] != "yes") {
LOGE("Update package is older than the current build, expected a "
"build newer than timestamp %" PRIu64 " but package has "
"timestamp %" PRIu64 " and downgrade not allowed.\n",
build_timestampt, pkg_post_timespampt);
LOG(ERROR) << "Update package is older than the current build, expected a build "
"newer than timestamp " << build_timestampt << " but package has "
"timestamp " << pkg_post_timespampt << " and downgrade not allowed.";
return INSTALL_ERROR;
}
if (pkg_pre_build_fingerprint.empty()) {
LOGE("Downgrade package must have a pre-build version set, not "
"allowed.\n");
LOG(ERROR) << "Downgrade package must have a pre-build version set, not allowed.";
return INSTALL_ERROR;
}
}
@ -225,20 +222,20 @@ update_binary_command(const char* path, ZipArchive* zip, int retry_count,
const ZipEntry* properties_entry =
mzFindZipEntry(zip, AB_OTA_PAYLOAD_PROPERTIES);
if (!properties_entry) {
LOGE("Can't find %s\n", AB_OTA_PAYLOAD_PROPERTIES);
LOG(ERROR) << "Can't find " << AB_OTA_PAYLOAD_PROPERTIES;
return INSTALL_CORRUPT;
}
std::vector<unsigned char> payload_properties(
mzGetZipEntryUncompLen(properties_entry));
if (!mzExtractZipEntryToBuffer(zip, properties_entry,
payload_properties.data())) {
LOGE("Can't extract %s\n", AB_OTA_PAYLOAD_PROPERTIES);
LOG(ERROR) << "Can't extract " << AB_OTA_PAYLOAD_PROPERTIES;
return INSTALL_CORRUPT;
}
const ZipEntry* payload_entry = mzFindZipEntry(zip, AB_OTA_PAYLOAD);
if (!payload_entry) {
LOGE("Can't find %s\n", AB_OTA_PAYLOAD);
LOG(ERROR) << "Can't find " << AB_OTA_PAYLOAD;
return INSTALL_CORRUPT;
}
long payload_offset = mzGetZipEntryOffset(payload_entry);
@ -270,14 +267,14 @@ update_binary_command(const char* path, ZipArchive* zip, int retry_count,
unlink(binary);
int fd = creat(binary, 0755);
if (fd < 0) {
LOGE("Can't make %s\n", binary);
PLOG(ERROR) << "Can't make " << binary;
return INSTALL_ERROR;
}
bool ok = mzExtractZipEntryToFile(zip, binary_entry, fd);
close(fd);
if (!ok) {
LOGE("Can't copy %s\n", ASSUMED_UPDATE_BINARY_NAME);
LOG(ERROR) << "Can't copy " << ASSUMED_UPDATE_BINARY_NAME;
return INSTALL_ERROR;
}
@ -423,7 +420,7 @@ try_update_binary(const char* path, ZipArchive* zip, bool* wipe_cache,
// last_install later.
log_buffer.push_back(std::string(strtok(NULL, "\n")));
} else {
LOGE("unknown command [%s]\n", command);
LOG(ERROR) << "unknown command [" << command << "]";
}
}
fclose(from_child);
@ -434,7 +431,7 @@ try_update_binary(const char* path, ZipArchive* zip, bool* wipe_cache,
return INSTALL_RETRY;
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOGE("Error in %s\n(Status %d)\n", path, WEXITSTATUS(status));
LOG(ERROR) << "Error in " << path << " (Status " << WEXITSTATUS(status) << ")";
return INSTALL_ERROR;
}
@ -450,7 +447,7 @@ really_install_package(const char *path, bool* wipe_cache, bool needs_mount,
// Give verification half the progress bar...
ui->SetProgressType(RecoveryUI::DETERMINATE);
ui->ShowProgress(VERIFICATION_PROGRESS_FRACTION, VERIFICATION_PROGRESS_TIME);
LOGI("Update location: %s\n", path);
LOG(INFO) << "Update location: " << path;
// Map the update package into memory.
ui->Print("Opening update package...\n");
@ -465,7 +462,7 @@ really_install_package(const char *path, bool* wipe_cache, bool needs_mount,
MemMapping map;
if (sysMapFile(path, &map) != 0) {
LOGE("failed to map file\n");
LOG(ERROR) << "failed to map file";
return INSTALL_CORRUPT;
}
@ -480,7 +477,7 @@ really_install_package(const char *path, bool* wipe_cache, bool needs_mount,
ZipArchive zip;
int err = mzOpenZipArchive(map.addr, map.length, &zip);
if (err != 0) {
LOGE("Can't open %s\n(%s)\n", path, err != -1 ? strerror(err) : "bad");
LOG(ERROR) << "Can't open " << path;
log_buffer.push_back(android::base::StringPrintf("error: %d", kZipOpenFailure));
sysReleaseMap(&map);
@ -514,12 +511,12 @@ install_package(const char* path, bool* wipe_cache, const char* install_file,
fputs(path, install_log);
fputc('\n', install_log);
} else {
LOGE("failed to open last_install: %s\n", strerror(errno));
PLOG(ERROR) << "failed to open last_install";
}
int result;
std::vector<std::string> log_buffer;
if (setup_install_mounts() != 0) {
LOGE("failed to set up expected mounts for install; aborting\n");
LOG(ERROR) << "failed to set up expected mounts for install; aborting";
result = INSTALL_ERROR;
} else {
result = really_install_package(path, wipe_cache, needs_mount, log_buffer, retry_count);
@ -545,10 +542,10 @@ install_package(const char* path, bool* wipe_cache, const char* install_file,
bool verify_package(const unsigned char* package_data, size_t package_size) {
std::vector<Certificate> loadedKeys;
if (!load_keys(PUBLIC_KEYS_FILE, loadedKeys)) {
LOGE("Failed to load keys\n");
LOG(ERROR) << "Failed to load keys";
return false;
}
LOGI("%zu key(s) loaded from %s\n", loadedKeys.size(), PUBLIC_KEYS_FILE);
LOG(INFO) << loadedKeys.size() << " key(s) loaded from " << PUBLIC_KEYS_FILE;
// Verify package.
ui->Print("Verifying update package...\n");
@ -557,8 +554,8 @@ bool verify_package(const unsigned char* package_data, size_t package_size) {
std::chrono::duration<double> duration = std::chrono::system_clock::now() - t0;
ui->Print("Update package verification took %.1f s (result %d).\n", duration.count(), err);
if (err != VERIFY_SUCCESS) {
LOGE("Signature verification failed\n");
LOGE("error: %d\n", kZipVerificationFailure);
LOG(ERROR) << "Signature verification failed";
LOG(ERROR) << "error: " << kZipVerificationFailure;
return false;
}
return true;

8
minzip/Android.mk
View file

@ -2,17 +2,17 @@ LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
Hash.c \
SysUtil.c \
Hash.cpp \
SysUtil.cpp \
DirUtil.cpp \
Inlines.c \
Zip.c
Zip.cpp
LOCAL_C_INCLUDES := \
external/zlib \
external/safe-iop/include
LOCAL_STATIC_LIBRARIES := libselinux
LOCAL_STATIC_LIBRARIES := libselinux libbase
LOCAL_MODULE := libminzip

13
minzip/Hash.c → minzip/Hash.cpp
View file

@ -8,8 +8,8 @@
#include <stdlib.h>
#include <assert.h>
#define LOG_TAG "minzip"
#include "Log.h"
#include <android-base/logging.h>
#include "Hash.h"
/* table load factor, i.e. how full can it get before we resize */
@ -220,8 +220,7 @@ void* mzHashTableLookup(HashTable* pHashTable, unsigned int itemHash, void* item
{
if (!resizeHash(pHashTable, pHashTable->tableSize * 2)) {
/* don't really have a way to indicate failure */
LOGE("Dalvik hash resize failure\n");
abort();
LOG(FATAL) << "Hash resize failure";
}
/* note "pEntry" is now invalid */
}
@ -373,7 +372,7 @@ void mzHashTableProbeCount(HashTable* pHashTable, HashCalcFunc calcFunc,
totalProbe += count;
}
LOGV("Probe: min=%d max=%d, total=%d in %d (%d), avg=%.3f\n",
minProbe, maxProbe, totalProbe, numEntries, pHashTable->tableSize,
(float) totalProbe / (float) numEntries);
LOG(VERBOSE) << "Probe: min=" << minProbe << ", max=" << maxProbe << ", total="
<< totalProbe <<" in " << numEntries << " (" << pHashTable->tableSize
<< "), avg=" << (float) totalProbe / (float) numEntries;
}

207
minzip/Log.h
View file

@ -1,207 +0,0 @@
//
// Copyright 2005 The Android Open Source Project
//
// C/C++ logging functions. See the logging documentation for API details.
//
// We'd like these to be available from C code (in case we import some from
// somewhere), so this has a C interface.
//
// The output will be correct when the log file is shared between multiple
// threads and/or multiple processes so long as the operating system
// supports O_APPEND. These calls have mutex-protected data structures
// and so are NOT reentrant. Do not use LOG in a signal handler.
//
#ifndef _MINZIP_LOG_H
#define _MINZIP_LOG_H
#include <stdio.h>
// ---------------------------------------------------------------------
/*
* Normally we strip LOGV (VERBOSE messages) from release builds.
* You can modify this (for example with "#define LOG_NDEBUG 0"
* at the top of your source file) to change that behavior.
*/
#ifndef LOG_NDEBUG
#ifdef NDEBUG
#define LOG_NDEBUG 1
#else
#define LOG_NDEBUG 0
#endif
#endif
/*
* This is the local tag used for the following simplified
* logging macros. You can change this preprocessor definition
* before using the other macros to change the tag.
*/
#ifndef LOG_TAG
#define LOG_TAG NULL
#endif
// ---------------------------------------------------------------------
/*
* Simplified macro to send a verbose log message using the current LOG_TAG.
*/
#ifndef LOGV
#if LOG_NDEBUG
#define LOGV(...) ((void)0)
#else
#define LOGV(...) ((void)LOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
#endif
#endif
#define CONDITION(cond) (__builtin_expect((cond)!=0, 0))
#ifndef LOGV_IF
#if LOG_NDEBUG
#define LOGV_IF(cond, ...) ((void)0)
#else
#define LOGV_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)LOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
: (void)0 )
#endif
#endif
#define LOGVV LOGV
#define LOGVV_IF LOGV_IF
/*
* Simplified macro to send a debug log message using the current LOG_TAG.
*/
#ifndef LOGD
#define LOGD(...) ((void)LOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
#endif
#ifndef LOGD_IF
#define LOGD_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)LOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
: (void)0 )
#endif
/*
* Simplified macro to send an info log message using the current LOG_TAG.
*/
#ifndef LOGI
#define LOGI(...) ((void)LOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
#endif
#ifndef LOGI_IF
#define LOGI_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)LOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \
: (void)0 )
#endif
/*
* Simplified macro to send a warning log message using the current LOG_TAG.
*/
#ifndef LOGW
#define LOGW(...) ((void)LOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
#endif
#ifndef LOGW_IF
#define LOGW_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)LOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \
: (void)0 )
#endif
/*
* Simplified macro to send an error log message using the current LOG_TAG.
*/
#ifndef LOGE
#define LOGE(...) ((void)LOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
#endif
#ifndef LOGE_IF
#define LOGE_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)LOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
: (void)0 )
#endif
/*
* Conditional based on whether the current LOG_TAG is enabled at
* verbose priority.
*/
#ifndef IF_LOGV
#if LOG_NDEBUG
#define IF_LOGV() if (false)
#else
#define IF_LOGV() IF_LOG(LOG_VERBOSE, LOG_TAG)
#endif
#endif
/*
* Conditional based on whether the current LOG_TAG is enabled at
* debug priority.
*/
#ifndef IF_LOGD
#define IF_LOGD() IF_LOG(LOG_DEBUG, LOG_TAG)
#endif
/*
* Conditional based on whether the current LOG_TAG is enabled at
* info priority.
*/
#ifndef IF_LOGI
#define IF_LOGI() IF_LOG(LOG_INFO, LOG_TAG)
#endif
/*
* Conditional based on whether the current LOG_TAG is enabled at
* warn priority.
*/
#ifndef IF_LOGW
#define IF_LOGW() IF_LOG(LOG_WARN, LOG_TAG)
#endif
/*
* Conditional based on whether the current LOG_TAG is enabled at
* error priority.
*/
#ifndef IF_LOGE
#define IF_LOGE() IF_LOG(LOG_ERROR, LOG_TAG)
#endif
// ---------------------------------------------------------------------
/*
* Basic log message macro.
*
* Example:
* LOG(LOG_WARN, NULL, "Failed with error %d", errno);
*
* The second argument may be NULL or "" to indicate the "global" tag.
*
* Non-gcc probably won't have __FUNCTION__. It's not vital. gcc also
* offers __PRETTY_FUNCTION__, which is rather more than we need.
*/
#ifndef LOG
#define LOG(priority, tag, ...) \
LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
#endif
/*
* Log macro that allows you to specify a number for the priority.
*/
#ifndef LOG_PRI
#define LOG_PRI(priority, tag, ...) \
printf(tag ": " __VA_ARGS__)
#endif
/*
* Conditional given a desired logging priority and tag.
*/
#ifndef IF_LOG
#define IF_LOG(priority, tag) \
if (1)
#endif
#endif // _MINZIP_LOG_H

64
minzip/SysUtil.c → minzip/SysUtil.cpp
View file

@ -16,8 +16,8 @@
#include <sys/types.h>
#include <unistd.h>
#define LOG_TAG "sysutil"
#include "Log.h"
#include <android-base/logging.h>
#include "SysUtil.h"
static bool sysMapFD(int fd, MemMapping* pMap) {
@ -25,22 +25,22 @@ static bool sysMapFD(int fd, MemMapping* pMap) {
struct stat sb;
if (fstat(fd, &sb) == -1) {
LOGE("fstat(%d) failed: %s\n", fd, strerror(errno));
PLOG(ERROR) << "fstat(" << fd << ") failed";
return false;
}
void* memPtr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (memPtr == MAP_FAILED) {
LOGE("mmap(%d, R, PRIVATE, %d, 0) failed: %s\n", (int) sb.st_size, fd, strerror(errno));
PLOG(ERROR) << "mmap(" << sb.st_size << ", R, PRIVATE, " << fd << ", 0) failed";
return false;
}
pMap->addr = memPtr;
pMap->addr = reinterpret_cast<unsigned char*>(memPtr);
pMap->length = sb.st_size;
pMap->range_count = 1;
pMap->ranges = malloc(sizeof(MappedRange));
pMap->ranges = reinterpret_cast<MappedRange*>(malloc(sizeof(MappedRange)));
if (pMap->ranges == NULL) {
LOGE("malloc failed: %s\n", strerror(errno));
PLOG(ERROR) << "malloc failed";
munmap(memPtr, sb.st_size);
return false;
}
@ -60,7 +60,7 @@ static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
unsigned int i;
if (fgets(block_dev, sizeof(block_dev), mapf) == NULL) {
LOGE("failed to read block device from header\n");
PLOG(ERROR) << "failed to read block device from header";
return -1;
}
for (i = 0; i < sizeof(block_dev); ++i) {
@ -71,37 +71,37 @@ static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
}
if (fscanf(mapf, "%zu %u\n%u\n", &size, &blksize, &range_count) != 3) {
LOGE("failed to parse block map header\n");
LOG(ERROR) << "failed to parse block map header";
return -1;
}
if (blksize != 0) {
blocks = ((size-1) / blksize) + 1;
}
if (size == 0 || blksize == 0 || blocks > SIZE_MAX / blksize || range_count == 0) {
LOGE("invalid data in block map file: size %zu, blksize %u, range_count %u\n",
size, blksize, range_count);
LOG(ERROR) << "invalid data in block map file: size " << size << ", blksize " << blksize
<< ", range_count " << range_count;
return -1;
}
pMap->range_count = range_count;
pMap->ranges = calloc(range_count, sizeof(MappedRange));
pMap->ranges = reinterpret_cast<MappedRange*>(calloc(range_count, sizeof(MappedRange)));
if (pMap->ranges == NULL) {
LOGE("calloc(%u, %zu) failed: %s\n", range_count, sizeof(MappedRange), strerror(errno));
PLOG(ERROR) << "calloc(" << range_count << ", " << sizeof(MappedRange) << ") failed";
return -1;
}
// Reserve enough contiguous address space for the whole file.
unsigned char* reserve;
reserve = mmap64(NULL, blocks * blksize, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
unsigned char* reserve = reinterpret_cast<unsigned char*>(mmap64(NULL, blocks * blksize,
PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0));
if (reserve == MAP_FAILED) {
LOGE("failed to reserve address space: %s\n", strerror(errno));
PLOG(ERROR) << "failed to reserve address space";
free(pMap->ranges);
return -1;
}
int fd = open(block_dev, O_RDONLY);
if (fd < 0) {
LOGE("failed to open block device %s: %s\n", block_dev, strerror(errno));
PLOG(ERROR) << "failed to open block device " << block_dev;
munmap(reserve, blocks * blksize);
free(pMap->ranges);
return -1;
@ -113,20 +113,20 @@ static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
for (i = 0; i < range_count; ++i) {
size_t start, end;
if (fscanf(mapf, "%zu %zu\n", &start, &end) != 2) {
LOGE("failed to parse range %d in block map\n", i);
LOG(ERROR) << "failed to parse range " << i << " in block map";
success = false;
break;
}
size_t length = (end - start) * blksize;
if (end <= start || (end - start) > SIZE_MAX / blksize || length > remaining_size) {
LOGE("unexpected range in block map: %zu %zu\n", start, end);
success = false;
break;
if (end <= start || ((end - start) > SIZE_MAX / blksize) || length > remaining_size) {
LOG(ERROR) << "unexpected range in block map: " << start << " " << end;
success = false;
break;
}
void* addr = mmap64(next, length, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, ((off64_t)start)*blksize);
if (addr == MAP_FAILED) {
LOGE("failed to map block %d: %s\n", i, strerror(errno));
PLOG(ERROR) << "failed to map block " << i;
success = false;
break;
}
@ -137,8 +137,8 @@ static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
remaining_size -= length;
}
if (success && remaining_size != 0) {
LOGE("ranges in block map are invalid: remaining_size = %zu\n", remaining_size);
success = false;
LOG(ERROR) << "ranges in block map are invalid: remaining_size = " << remaining_size;
success = false;
}
if (!success) {
close(fd);
@ -151,7 +151,7 @@ static int sysMapBlockFile(FILE* mapf, MemMapping* pMap)
pMap->addr = reserve;
pMap->length = size;
LOGI("mmapped %d ranges\n", range_count);
LOG(INFO) << "mmapped " << range_count << " ranges";
return 0;
}
@ -164,12 +164,12 @@ int sysMapFile(const char* fn, MemMapping* pMap)
// A map of blocks
FILE* mapf = fopen(fn+1, "r");
if (mapf == NULL) {
LOGE("Unable to open '%s': %s\n", fn+1, strerror(errno));
PLOG(ERROR) << "Unable to open '" << (fn+1) << "'";
return -1;
}
if (sysMapBlockFile(mapf, pMap) != 0) {
LOGE("Map of '%s' failed\n", fn);
LOG(ERROR) << "Map of '" << fn << "' failed";
fclose(mapf);
return -1;
}
@ -179,12 +179,12 @@ int sysMapFile(const char* fn, MemMapping* pMap)
// This is a regular file.
int fd = open(fn, O_RDONLY);
if (fd == -1) {
LOGE("Unable to open '%s': %s\n", fn, strerror(errno));
PLOG(ERROR) << "Unable to open '" << fn << "'";
return -1;
}
if (!sysMapFD(fd, pMap)) {
LOGE("Map of '%s' failed\n", fn);
LOG(ERROR) << "Map of '" << fn << "' failed";
close(fd);
return -1;
}
@ -202,8 +202,8 @@ void sysReleaseMap(MemMapping* pMap)
int i;
for (i = 0; i < pMap->range_count; ++i) {
if (munmap(pMap->ranges[i].addr, pMap->ranges[i].length) < 0) {
LOGE("munmap(%p, %d) failed: %s\n",
pMap->ranges[i].addr, (int)pMap->ranges[i].length, strerror(errno));
PLOG(ERROR) << "munmap(" << pMap->ranges[i].addr << ", " << pMap->ranges[i].length
<< ") failed";
}
}
free(pMap->ranges);

126
minzip/Zip.c → minzip/Zip.cpp
View file

@ -14,18 +14,18 @@
#include <sys/stat.h> // for S_ISLNK()
#include <unistd.h>
#define LOG_TAG "minzip"
#include "Zip.h"
#include "Bits.h"
#include "Log.h"
#include "DirUtil.h"
#include <string>
#undef NDEBUG // do this after including Log.h
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <assert.h>
#include <selinux/label.h>
#include <selinux/selinux.h>
#include "Zip.h"
#include "Bits.h"
#include "DirUtil.h"
#define SORT_ENTRIES 1
/*
@ -154,8 +154,9 @@ static void addEntryToHashTable(HashTable* pHash, ZipEntry* pEntry)
found = (const ZipEntry*)mzHashTableLookup(pHash,
itemHash, pEntry, hashcmpZipEntry, true);
if (found != pEntry) {
LOGW("WARNING: duplicate entry '%.*s' in Zip\n",
found->fileNameLen, found->fileName);
LOG(WARNING) << "WARNING: duplicate entry '" << std::string(found->fileName,
found->fileNameLen) << "' in Zip";
/* keep going */
}
}
@ -164,7 +165,7 @@ static int validFilename(const char *fileName, unsigned int fileNameLen)
{
// Forbid super long filenames.
if (fileNameLen >= PATH_MAX) {
LOGW("Filename too long (%d chatacters)\n", fileNameLen);
LOG(WARNING) << "Filename too long (" << fileNameLen << " chatacters)";
return 0;
}
@ -172,7 +173,8 @@ static int validFilename(const char *fileName, unsigned int fileNameLen)
unsigned int i;
for (i = 0; i < fileNameLen; ++i) {
if (fileName[i] < 32 || fileName[i] >= 127) {
LOGW("Filename contains invalid character '\%03o'\n", fileName[i]);
LOG(WARNING) << android::base::StringPrintf(
"Filename contains invalid character '\%02x'\n", fileName[i]);
return 0;
}
}
@ -201,10 +203,10 @@ static bool parseZipArchive(ZipArchive* pArchive)
*/
val = get4LE(pArchive->addr);
if (val == ENDSIG) {
LOGW("Found Zip archive, but it looks empty\n");
LOG(WARNING) << "Found Zip archive, but it looks empty";
goto bail;
} else if (val != LOCSIG) {
LOGW("Not a Zip archive (found 0x%08x)\n", val);
LOG(WARNING) << android::base::StringPrintf("Not a Zip archive (found 0x%08x)\n", val);
goto bail;
}
@ -220,7 +222,7 @@ static bool parseZipArchive(ZipArchive* pArchive)
ptr--;
}
if (ptr < (const unsigned char*) pArchive->addr) {
LOGW("Could not find end-of-central-directory in Zip\n");
LOG(WARNING) << "Could not find end-of-central-directory in Zip";
goto bail;
}
@ -232,10 +234,10 @@ static bool parseZipArchive(ZipArchive* pArchive)
numEntries = get2LE(ptr + ENDSUB);
cdOffset = get4LE(ptr + ENDOFF);
LOGVV("numEntries=%d cdOffset=%d\n", numEntries, cdOffset);
LOG(VERBOSE) << "numEntries=" << numEntries << " cdOffset=" << cdOffset;
if (numEntries == 0 || cdOffset >= pArchive->length) {
LOGW("Invalid entries=%d offset=%d (len=%zd)\n",
numEntries, cdOffset, pArchive->length);
LOG(WARNING) << "Invalid entries=" << numEntries << " offset=" << cdOffset
<< " (len=" << pArchive->length << ")";
goto bail;
}
@ -256,11 +258,11 @@ static bool parseZipArchive(ZipArchive* pArchive)
const char *fileName;
if (ptr + CENHDR > (const unsigned char*)pArchive->addr + pArchive->length) {
LOGW("Ran off the end (at %d)\n", i);
LOG(WARNING) << "Ran off the end (at " << i << ")";
goto bail;
}
if (get4LE(ptr) != CENSIG) {
LOGW("Missed a central dir sig (at %d)\n", i);
LOG(WARNING) << "Missed a central dir sig (at " << i << ")";
goto bail;
}
@ -270,11 +272,11 @@ static bool parseZipArchive(ZipArchive* pArchive)
commentLen = get2LE(ptr + CENCOM);
fileName = (const char*)ptr + CENHDR;
if (fileName + fileNameLen > (const char*)pArchive->addr + pArchive->length) {
LOGW("Filename ran off the end (at %d)\n", i);
LOG(WARNING) << "Filename ran off the end (at " << i << ")";
goto bail;
}
if (!validFilename(fileName, fileNameLen)) {
LOGW("Invalid filename (at %d)\n", i);
LOG(WARNING) << "Invalid filename (at " << i << ")";
goto bail;
}
@ -345,7 +347,8 @@ static bool parseZipArchive(ZipArchive* pArchive)
if ((pEntry->versionMadeBy & 0xff00) != 0 &&
(pEntry->versionMadeBy & 0xff00) != CENVEM_UNIX)
{
LOGW("Incompatible \"version made by\": 0x%02x (at %d)\n",
LOG(WARNING) << android::base::StringPrintf(
"Incompatible \"version made by\": 0x%02x (at %d)\n",
pEntry->versionMadeBy >> 8, i);
goto bail;
}
@ -355,26 +358,27 @@ static bool parseZipArchive(ZipArchive* pArchive)
// overflow. This is needed because localHdrOffset is untrusted.
if (!safe_add((uintptr_t *)&localHdr, (uintptr_t)pArchive->addr,
(uintptr_t)localHdrOffset)) {
LOGW("Integer overflow adding in parseZipArchive\n");
LOG(WARNING) << "Integer overflow adding in parseZipArchive";
goto bail;
}
if ((uintptr_t)localHdr + LOCHDR >
(uintptr_t)pArchive->addr + pArchive->length) {
LOGW("Bad offset to local header: %d (at %d)\n", localHdrOffset, i);
LOG(WARNING) << "Bad offset to local header: " << localHdrOffset
<< " (at " << i << ")";
goto bail;
}
if (get4LE(localHdr) != LOCSIG) {
LOGW("Missed a local header sig (at %d)\n", i);
LOG(WARNING) << "Missed a local header sig (at " << i << ")";
goto bail;
}
pEntry->offset = localHdrOffset + LOCHDR
+ get2LE(localHdr + LOCNAM) + get2LE(localHdr + LOCEXT);
if (!safe_add(NULL, pEntry->offset, pEntry->compLen)) {
LOGW("Integer overflow adding in parseZipArchive\n");
LOG(WARNING) << "Integer overflow adding in parseZipArchive";
goto bail;
}
if ((size_t)pEntry->offset + pEntry->compLen > pArchive->length) {
LOGW("Data ran off the end (at %d)\n", i);
LOG(WARNING) << "Data ran off the end (at " << i << ")";
goto bail;
}
@ -432,7 +436,8 @@ int mzOpenZipArchive(unsigned char* addr, size_t length, ZipArchive* pArchive)
if (length < ENDHDR) {
err = -1;
LOGW("Archive %p is too small to be zip (%zd)\n", pArchive, length);
LOG(WARNING) << "Archive " << pArchive << " is too small to be zip ("
<< length << ")";
goto bail;
}
@ -441,7 +446,7 @@ int mzOpenZipArchive(unsigned char* addr, size_t length, ZipArchive* pArchive)
if (!parseZipArchive(pArchive)) {
err = -1;
LOGW("Parsing archive %p failed\n", pArchive);
LOG(WARNING) << "Parsing archive " << pArchive << " failed";
goto bail;
}
@ -460,7 +465,7 @@ bail:
*/
void mzCloseZipArchive(ZipArchive* pArchive)
{
LOGV("Closing archive %p\n", pArchive);
LOG(VERBOSE) << "Closing archive " << pArchive;
free(pArchive->pEntries);
@ -534,10 +539,10 @@ static bool processDeflatedEntry(const ZipArchive *pArchive,
zerr = inflateInit2(&zstream, -MAX_WBITS);
if (zerr != Z_OK) {
if (zerr == Z_VERSION_ERROR) {
LOGE("Installed zlib is not compatible with linked version (%s)\n",
ZLIB_VERSION);
LOG(ERROR) << "Installed zlib is not compatible with linked version ("
<< ZLIB_VERSION << ")";
} else {
LOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
LOG(ERROR) << "Call to inflateInit2 failed (zerr=" << zerr << ")";
}
goto bail;
}
@ -549,7 +554,7 @@ static bool processDeflatedEntry(const ZipArchive *pArchive,
/* uncompress the data */
zerr = inflate(&zstream, Z_NO_FLUSH);
if (zerr != Z_OK && zerr != Z_STREAM_END) {
LOGW("zlib inflate call failed (zerr=%d)\n", zerr);
LOG(WARNING) << "zlib inflate call failed (zerr=" << zerr << ")";
goto z_bail;
}
@ -558,10 +563,10 @@ static bool processDeflatedEntry(const ZipArchive *pArchive,
(zerr == Z_STREAM_END && zstream.avail_out != sizeof(procBuf)))
{
long procSize = zstream.next_out - procBuf;
LOGVV("+++ processing %d bytes\n", (int) procSize);
LOG(VERBOSE) << "+++ processing " << procSize << " bytes";
bool ret = processFunction(procBuf, procSize, cookie);
if (!ret) {
LOGW("Process function elected to fail (in inflate)\n");
LOG(WARNING) << "Process function elected to fail (in inflate)";
goto z_bail;
}
@ -582,7 +587,8 @@ z_bail:
bail:
if (totalOut != pEntry->uncompLen) {
if (success) { // error already shown?
LOGW("Size mismatch on inflated file (%lu vs %u)\n", totalOut, pEntry->uncompLen);
LOG(WARNING) << "Size mismatch on inflated file (" << totalOut << " vs "
<< pEntry->uncompLen << ")";
}
return false;
}
@ -613,8 +619,8 @@ bool mzProcessZipEntryContents(const ZipArchive *pArchive,
ret = processDeflatedEntry(pArchive, pEntry, processFunction, cookie);
break;
default:
LOGE("Unsupported compression type %d for entry '%s'\n",
pEntry->compression, pEntry->fileName);
LOG(ERROR) << "Unsupported compression type " << pEntry->compression
<< " for entry '" << pEntry->fileName << "'";
break;
}
@ -653,7 +659,7 @@ bool mzReadZipEntry(const ZipArchive* pArchive, const ZipEntry* pEntry,
ret = mzProcessZipEntryContents(pArchive, pEntry, copyProcessFunction,
(void *)&args);
if (!ret) {
LOGE("Can't extract entry to buffer.\n");
LOG(ERROR) << "Can't extract entry to buffer";
return false;
}
return true;
@ -670,15 +676,15 @@ static bool writeProcessFunction(const unsigned char *data, int dataLen,
while (true) {
ssize_t n = TEMP_FAILURE_RETRY(write(fd, data+soFar, dataLen-soFar));
if (n <= 0) {
LOGE("Error writing %zd bytes from zip file from %p: %s\n",
dataLen-soFar, data+soFar, strerror(errno));
PLOG(ERROR) << "Error writing " << dataLen-soFar << " bytes from zip file from "
<< data+soFar;
return false;
} else if (n > 0) {
soFar += n;
if (soFar == dataLen) return true;
if (soFar > dataLen) {
LOGE("write overrun? (%zd bytes instead of %d)\n",
soFar, dataLen);
LOG(ERROR) << "write overrun? (" << soFar << " bytes instead of "
<< dataLen << ")";
return false;
}
}
@ -694,7 +700,7 @@ bool mzExtractZipEntryToFile(const ZipArchive *pArchive,
bool ret = mzProcessZipEntryContents(pArchive, pEntry, writeProcessFunction,
(void*)(intptr_t)fd);
if (!ret) {
LOGE("Can't extract entry to file.\n");
LOG(ERROR) << "Can't extract entry to file.";
return false;
}
return true;
@ -730,7 +736,7 @@ bool mzExtractZipEntryToBuffer(const ZipArchive *pArchive,
bool ret = mzProcessZipEntryContents(pArchive, pEntry,
bufferProcessFunction, (void*)&bec);
if (!ret || bec.len != 0) {
LOGE("Can't extract entry to memory buffer.\n");
LOG(ERROR) << "Can't extract entry to memory buffer.";
return false;
}
return true;
@ -824,11 +830,11 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
struct selabel_handle *sehnd)
{
if (zipDir[0] == '/') {
LOGE("mzExtractRecursive(): zipDir must be a relative path.\n");
LOG(ERROR) << "mzExtractRecursive(): zipDir must be a relative path.";
return false;
}
if (targetDir[0] != '/') {
LOGE("mzExtractRecursive(): targetDir must be an absolute path.\n");
LOG(ERROR) << "mzExtractRecursive(): targetDir must be an absolute path.\n";
return false;
}
@ -838,7 +844,7 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
zipDirLen = strlen(zipDir);
zpath = (char *)malloc(zipDirLen + 2);
if (zpath == NULL) {
LOGE("Can't allocate %d bytes for zip path\n", zipDirLen + 2);
LOG(ERROR) << "Can't allocate " << (zipDirLen + 2) << " bytes for zip path";
return false;
}
/* If zipDir is empty, we'll extract the entire zip file.
@ -917,8 +923,8 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
*/
const char *targetFile = targetEntryPath(&helper, pEntry);
if (targetFile == NULL) {
LOGE("Can't assemble target path for \"%.*s\"\n",
pEntry->fileNameLen, pEntry->fileName);
LOG(ERROR) << "Can't assemble target path for \"" << std::string(pEntry->fileName,
pEntry->fileNameLen) << "\"";
ok = false;
break;
}
@ -942,8 +948,7 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
int ret = dirCreateHierarchy(
targetFile, UNZIP_DIRMODE, timestamp, true, sehnd);
if (ret != 0) {
LOGE("Can't create containing directory for \"%s\": %s\n",
targetFile, strerror(errno));
PLOG(ERROR) << "Can't create containing directory for \"" << targetFile << "\"";
ok = false;
break;
}
@ -957,8 +962,8 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
* warn about this for now and preserve older behavior.
*/
if (mzIsZipEntrySymlink(pEntry)) {
LOGE("Symlink entry \"%.*s\" will be output as a regular file.",
pEntry->fileNameLen, pEntry->fileName);
LOG(ERROR) << "Symlink entry \"" << std::string(pEntry->fileName,
pEntry->fileNameLen) << "\" will be output as a regular file.";
}
char *secontext = NULL;
@ -977,8 +982,7 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
}
if (fd < 0) {
LOGE("Can't create target file \"%s\": %s\n",
targetFile, strerror(errno));
PLOG(ERROR) << "Can't create target file \"" << targetFile << "\"";
ok = false;
break;
}
@ -991,25 +995,25 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
ok = false;
}
if (!ok) {
LOGE("Error extracting \"%s\"\n", targetFile);
LOG(ERROR) << "Error extracting \"" << targetFile << "\"";
ok = false;
break;
}
if (timestamp != NULL && utime(targetFile, timestamp)) {
LOGE("Error touching \"%s\"\n", targetFile);
LOG(ERROR) << "Error touching \"" << targetFile << "\"";
ok = false;
break;
}
LOGV("Extracted file \"%s\"\n", targetFile);
LOG(VERBOSE) <<"Extracted file \"" << targetFile << "\"";
++extractCount;
}
if (callback != NULL) callback(targetFile, cookie);
}
LOGV("Extracted %d file(s)\n", extractCount);
LOG(VERBOSE) << "Extracted " << extractCount << " file(s)";
free(helper.buf);
free(zpath);

5
otafault/Android.mk
View file

@ -17,10 +17,11 @@ LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
otafault_static_libs := \
libbase \
libminzip \
libz \
libselinux
libselinux \
libbase \
liblog
LOCAL_SRC_FILES := config.cpp ota_io.cpp
LOCAL_MODULE_TAGS := eng

15
recovery-persist.cpp
View file

@ -14,8 +14,6 @@
* limitations under the License.
*/
#define LOG_TAG "recovery-persist"
//
// Strictly to deal with reboot into system after OTA after /data
// mounts to pull the last pmsg file data and place it
@ -40,10 +38,9 @@
#include <string>
#include <android/log.h> /* Android Log Priority Tags */
#include <android-base/file.h>
#include <log/log.h>
#include <log/logger.h> /* Android Log packet format */
#include <android-base/logging.h>
#include <private/android_logger.h> /* private pmsg functions */
static const char *LAST_LOG_FILE = "/data/misc/recovery/last_log";
@ -57,14 +54,16 @@ static const int KEEP_LOG_COUNT = 10;
// close a file, log an error if the error indicator is set
static void check_and_fclose(FILE *fp, const char *name) {
fflush(fp);
if (ferror(fp)) SLOGE("%s %s", name, strerror(errno));
if (ferror(fp)) {
PLOG(ERROR) << "Error in " << name;
}
fclose(fp);
}
static void copy_file(const char* source, const char* destination) {
FILE* dest_fp = fopen(destination, "w");
if (dest_fp == nullptr) {
SLOGE("%s %s", destination, strerror(errno));
PLOG(ERROR) << "Can't open " << destination;
} else {
FILE* source_fp = fopen(source, "r");
if (source_fp != nullptr) {
@ -157,7 +156,7 @@ int main(int argc, char **argv) {
static const char mounts_file[] = "/proc/mounts";
FILE *fp = fopen(mounts_file, "r");
if (!fp) {
SLOGV("%s %s", mounts_file, strerror(errno));
PLOG(ERROR) << "failed to open " << mounts_file;
} else {
char *line = NULL;
size_t len = 0;

99
recovery.cpp
View file

@ -41,6 +41,7 @@
#include <adb.h>
#include <android/log.h> /* Android Log Priority Tags */
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/parseint.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
@ -49,7 +50,6 @@
#include <cutils/android_reboot.h>
#include <cutils/properties.h>
#include <healthd/BatteryMonitor.h>
#include <log/logger.h> /* Android Log packet format */
#include <private/android_logger.h> /* private pmsg functions */
#include <selinux/label.h>
#include <selinux/selinux.h>
@ -191,7 +191,7 @@ static const int MAX_ARGS = 100;
// open a given path, mounting partitions as necessary
FILE* fopen_path(const char *path, const char *mode) {
if (ensure_path_mounted(path) != 0) {
LOGE("Can't mount %s\n", path);
LOG(ERROR) << "Can't mount " << path;
return NULL;
}
@ -206,7 +206,9 @@ FILE* fopen_path(const char *path, const char *mode) {
// close a file, log an error if the error indicator is set
static void check_and_fclose(FILE *fp, const char *name) {
fflush(fp);
if (ferror(fp)) LOGE("Error in %s\n(%s)\n", name, strerror(errno));
if (ferror(fp)) {
PLOG(ERROR) << "Error in " << name;
}
fclose(fp);
}
@ -218,7 +220,7 @@ bool is_ro_debuggable() {
static void redirect_stdio(const char* filename) {
int pipefd[2];
if (pipe(pipefd) == -1) {
LOGE("pipe failed: %s\n", strerror(errno));
PLOG(ERROR) << "pipe failed";
// Fall back to traditional logging mode without timestamps.
// If these fail, there's not really anywhere to complain...
@ -230,7 +232,7 @@ static void redirect_stdio(const char* filename) {
pid_t pid = fork();
if (pid == -1) {
LOGE("fork failed: %s\n", strerror(errno));
PLOG(ERROR) << "fork failed";
// Fall back to traditional logging mode without timestamps.
// If these fail, there's not really anywhere to complain...
@ -249,14 +251,14 @@ static void redirect_stdio(const char* filename) {
// Child logger to actually write to the log file.
FILE* log_fp = fopen(filename, "a");
if (log_fp == nullptr) {
LOGE("fopen \"%s\" failed: %s\n", filename, strerror(errno));
PLOG(ERROR) << "fopen \"" << filename << "\" failed";
close(pipefd[0]);
_exit(1);
}
FILE* pipe_fp = fdopen(pipefd[0], "r");
if (pipe_fp == nullptr) {
LOGE("fdopen failed: %s\n", strerror(errno));
PLOG(ERROR) << "fdopen failed";
check_and_fclose(log_fp, filename);
close(pipefd[0]);
_exit(1);
@ -276,7 +278,7 @@ static void redirect_stdio(const char* filename) {
fflush(log_fp);
}
LOGE("getline failed: %s\n", strerror(errno));
PLOG(ERROR) << "getline failed";
free(line);
check_and_fclose(log_fp, filename);
@ -291,10 +293,10 @@ static void redirect_stdio(const char* filename) {
setbuf(stderr, nullptr);
if (dup2(pipefd[1], STDOUT_FILENO) == -1) {
LOGE("dup2 stdout failed: %s\n", strerror(errno));
PLOG(ERROR) << "dup2 stdout failed";
}
if (dup2(pipefd[1], STDERR_FILENO) == -1) {
LOGE("dup2 stderr failed: %s\n", strerror(errno));
PLOG(ERROR) << "dup2 stderr failed";
}
close(pipefd[1]);
@ -310,18 +312,20 @@ get_args(int *argc, char ***argv) {
bootloader_message boot = {};
std::string err;
if (!read_bootloader_message(&boot, &err)) {
LOGE("%s\n", err.c_str());
LOG(ERROR) << err;
// If fails, leave a zeroed bootloader_message.
memset(&boot, 0, sizeof(boot));
}
stage = strndup(boot.stage, sizeof(boot.stage));
if (boot.command[0] != 0 && boot.command[0] != 255) {
LOGI("Boot command: %.*s\n", (int)sizeof(boot.command), boot.command);
std::string boot_command = std::string(boot.command, sizeof(boot.command));
LOG(INFO) << "Boot command: " << boot_command;
}
if (boot.status[0] != 0 && boot.status[0] != 255) {
LOGI("Boot status: %.*s\n", (int)sizeof(boot.status), boot.status);
std::string boot_status = std::string(boot.status, sizeof(boot.status));
LOG(INFO) << "Boot status: " << boot_status;
}
// --- if arguments weren't supplied, look in the bootloader control block
@ -335,9 +339,10 @@ get_args(int *argc, char ***argv) {
if ((arg = strtok(NULL, "\n")) == NULL) break;
(*argv)[*argc] = strdup(arg);
}
LOGI("Got arguments from boot message\n");
LOG(INFO) << "Got arguments from boot message";
} else if (boot.recovery[0] != 0 && boot.recovery[0] != 255) {
LOGE("Bad boot message\n\"%.20s\"\n", boot.recovery);
std::string boot_recovery = std::string(boot.recovery, 20);
LOG(ERROR) << "Bad boot message\n" << "\"" <<boot_recovery << "\"";
}
}
@ -362,7 +367,7 @@ get_args(int *argc, char ***argv) {
}
check_and_fclose(fp, COMMAND_FILE);
LOGI("Got arguments from %s\n", COMMAND_FILE);
LOG(INFO) << "Got arguments from " << COMMAND_FILE;
}
}
@ -376,7 +381,7 @@ get_args(int *argc, char ***argv) {
strlcat(boot.recovery, "\n", sizeof(boot.recovery));
}
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
LOG(ERROR) << err;
}
}
@ -387,7 +392,7 @@ set_sdcard_update_bootloader_message() {
strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
std::string err;
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
LOG(ERROR) << err;
}
}
@ -395,14 +400,14 @@ set_sdcard_update_bootloader_message() {
static void save_kernel_log(const char* destination) {
int klog_buf_len = klogctl(KLOG_SIZE_BUFFER, 0, 0);
if (klog_buf_len <= 0) {
LOGE("Error getting klog size: %s\n", strerror(errno));
PLOG(ERROR) << "Error getting klog size";
return;
}
std::string buffer(klog_buf_len, 0);
int n = klogctl(KLOG_READ_ALL, &buffer[0], klog_buf_len);
if (n == -1) {
LOGE("Error in reading klog: %s\n", strerror(errno));
PLOG(ERROR) << "Error in reading klog";
return;
}
buffer.resize(n);
@ -427,7 +432,7 @@ static off_t tmplog_offset = 0;
static void copy_log_file(const char* source, const char* destination, bool append) {
FILE* dest_fp = fopen_path(destination, append ? "a" : "w");
if (dest_fp == nullptr) {
LOGE("Can't open %s\n", destination);
PLOG(ERROR) << "Can't open " << destination;
} else {
FILE* source_fp = fopen(source, "r");
if (source_fp != nullptr) {
@ -525,7 +530,7 @@ finish_recovery() {
size_t len = strlen(locale);
__pmsg_write(LOCALE_FILE, locale, len);
if (has_cache) {
LOGI("Saving locale \"%s\"\n", locale);
LOG(INFO) << "Saving locale \"" << locale << "\"";
FILE* fp = fopen_path(LOCALE_FILE, "w");
if (fp != NULL) {
fwrite(locale, 1, len, fp);
@ -542,13 +547,13 @@ finish_recovery() {
bootloader_message boot = {};
std::string err;
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
LOG(ERROR) << err;
}
// Remove the command file, so recovery won't repeat indefinitely.
if (has_cache) {
if (ensure_path_mounted(COMMAND_FILE) != 0 || (unlink(COMMAND_FILE) && errno != ENOENT)) {
LOGW("Can't unlink %s\n", COMMAND_FILE);
LOG(WARNING) << "Can't unlink " << COMMAND_FILE;
}
ensure_path_unmounted(CACHE_ROOT);
}
@ -688,7 +693,7 @@ get_menu_selection(const char* const * headers, const char* const * items,
if (ui->WasTextEverVisible()) {
continue;
} else {
LOGI("timed out waiting for key input; rebooting.\n");
LOG(INFO) << "timed out waiting for key input; rebooting.";
ui->EndMenu();
return 0; // XXX fixme
}
@ -729,7 +734,7 @@ static char* browse_directory(const char* path, Device* device) {
DIR* d = opendir(path);
if (d == NULL) {
LOGE("error opening %s: %s\n", path, strerror(errno));
PLOG(ERROR) << "error opening " << path;
return NULL;
}
@ -874,13 +879,13 @@ static bool wipe_cache(bool should_confirm, Device* device) {
static bool secure_wipe_partition(const std::string& partition) {
android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(partition.c_str(), O_WRONLY)));
if (fd == -1) {
LOGE("failed to open \"%s\": %s\n", partition.c_str(), strerror(errno));
PLOG(ERROR) << "failed to open \"" << partition << "\"";
return false;
}
uint64_t range[2] = {0, 0};
if (ioctl(fd, BLKGETSIZE64, &range[1]) == -1 || range[1] == 0) {
LOGE("failed to get partition size: %s\n", strerror(errno));
PLOG(ERROR) << "failed to get partition size";
return false;
}
printf("Secure-wiping \"%s\" from %" PRIu64 " to %" PRIu64 ".\n",
@ -916,18 +921,18 @@ static bool secure_wipe_partition(const std::string& partition) {
// 2. check metadata (ota-type, pre-device and serial number if having one).
static bool check_wipe_package(size_t wipe_package_size) {
if (wipe_package_size == 0) {
LOGE("wipe_package_size is zero.\n");
LOG(ERROR) << "wipe_package_size is zero";
return false;
}
std::string wipe_package;
std::string err_str;
if (!read_wipe_package(&wipe_package, wipe_package_size, &err_str)) {
LOGE("Failed to read wipe package: %s\n", err_str.c_str());
PLOG(ERROR) << "Failed to read wipe package";
return false;
}
if (!verify_package(reinterpret_cast<const unsigned char*>(wipe_package.data()),
wipe_package.size())) {
LOGE("Failed to verify package.\n");
LOG(ERROR) << "Failed to verify package";
return false;
}
@ -936,7 +941,7 @@ static bool check_wipe_package(size_t wipe_package_size) {
int err = mzOpenZipArchive(reinterpret_cast<unsigned char*>(&wipe_package[0]),
wipe_package.size(), &zip);
if (err != 0) {
LOGE("Can't open wipe package: %s\n", err != -1 ? strerror(err) : "bad");
LOG(ERROR) << "Can't open wipe package";
return false;
}
std::string metadata;
@ -978,12 +983,12 @@ static bool wipe_ab_device(size_t wipe_package_size) {
ui->SetProgressType(RecoveryUI::INDETERMINATE);
if (!check_wipe_package(wipe_package_size)) {
LOGE("Failed to verify wipe package\n");
LOG(ERROR) << "Failed to verify wipe package";
return false;
}
std::string partition_list;
if (!android::base::ReadFileToString(RECOVERY_WIPE, &partition_list)) {
LOGE("failed to read \"%s\".\n", RECOVERY_WIPE);
LOG(ERROR) << "failed to read \"" << RECOVERY_WIPE << "\"";
return false;
}
@ -1146,7 +1151,7 @@ static int apply_from_sdcard(Device* device, bool* wipe_cache) {
sleep(1);
continue;
} else {
LOGE("Timed out waiting for the fuse-provided package.\n");
LOG(ERROR) << "Timed out waiting for the fuse-provided package.";
result = INSTALL_ERROR;
kill(child, SIGKILL);
break;
@ -1168,7 +1173,7 @@ static int apply_from_sdcard(Device* device, bool* wipe_cache) {
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOGE("Error exit from the fuse process: %d\n", WEXITSTATUS(status));
LOG(ERROR) << "Error exit from the fuse process: " << WEXITSTATUS(status);
}
ensure_path_unmounted(SDCARD_ROOT);
@ -1324,6 +1329,18 @@ ui_print(const char* format, ...) {
}
}
static constexpr char log_characters[] = "VDIWEF";
void UiLogger(android::base::LogId id, android::base::LogSeverity severity,
const char* tag, const char* file, unsigned int line,
const char* message) {
if (severity >= android::base::ERROR && gCurrentUI != NULL) {
gCurrentUI->Print("E:%s\n", message);
} else {
fprintf(stdout, "%c:%s\n", log_characters[severity], message);
}
}
static bool is_battery_ok() {
struct healthd_config healthd_config = {
.batteryStatusPath = android::String8(android::String8::kEmptyString),
@ -1400,7 +1417,7 @@ static void set_retry_bootloader_message(int retry_count, int argc, char** argv)
}
std::string err;
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
LOG(ERROR) << err;
}
}
@ -1424,7 +1441,7 @@ static void log_failure_code(ErrorCode code, const char *update_package) {
fprintf(install_log, "error: %d\n", code);
fclose(install_log);
} else {
LOGE("failed to open last_install: %s\n", strerror(errno));
PLOG(ERROR) << "failed to open last_install";
}
}
@ -1479,6 +1496,10 @@ static ssize_t logrotate(
}
int main(int argc, char **argv) {
// We don't have logcat yet under recovery; so we'll print error on screen and
// log to stdout (which is redirected to recovery.log) as we used to do.
android::base::InitLogging(argv, &UiLogger);
// Take last pmsg contents and rewrite it to the current pmsg session.
static const char filter[] = "recovery/";
// Do we need to rotate?
@ -1564,7 +1585,7 @@ int main(int argc, char **argv) {
break;
}
case '?':
LOGE("Invalid command argument\n");
LOG(ERROR) << "Invalid command argument";
continue;
}
}

57
roots.cpp
View file

@ -26,6 +26,8 @@
#include <ctype.h>
#include <fcntl.h>
#include <android-base/logging.h>
#include <fs_mgr.h>
#include "common.h"
#include "make_ext4fs.h"
@ -44,13 +46,13 @@ void load_volume_table()
fstab = fs_mgr_read_fstab("/etc/recovery.fstab");
if (!fstab) {
LOGE("failed to read /etc/recovery.fstab\n");
LOG(ERROR) << "failed to read /etc/recovery.fstab";
return;
}
ret = fs_mgr_add_entry(fstab, "/tmp", "ramdisk", "ramdisk");
if (ret < 0 ) {
LOGE("failed to add /tmp entry to fstab\n");
LOG(ERROR) << "failed to add /tmp entry to fstab";
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
@ -74,7 +76,7 @@ Volume* volume_for_path(const char* path) {
int ensure_path_mounted_at(const char* path, const char* mount_point) {
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
LOG(ERROR) << "unknown volume for path [" << path << "]";
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
@ -83,7 +85,7 @@ int ensure_path_mounted_at(const char* path, const char* mount_point) {
}
if (!scan_mounted_volumes()) {
LOGE("failed to scan mounted volumes\n");
LOG(ERROR) << "failed to scan mounted volumes";
return -1;
}
@ -104,25 +106,25 @@ int ensure_path_mounted_at(const char* path, const char* mount_point) {
strcmp(v->fs_type, "vfat") == 0) {
int result = mount(v->blk_device, mount_point, v->fs_type, v->flags, v->fs_options);
if (result == -1 && fs_mgr_is_formattable(v)) {
LOGE("failed to mount %s (%s), formatting ...\n",
mount_point, strerror(errno));
LOG(ERROR) << "failed to mount " << mount_point << " (" << strerror(errno)
<< ") , formatting.....";
bool crypt_footer = fs_mgr_is_encryptable(v) && !strcmp(v->key_loc, "footer");
if (fs_mgr_do_format(v, crypt_footer) == 0) {
result = mount(v->blk_device, mount_point, v->fs_type, v->flags, v->fs_options);
} else {
LOGE("failed to format %s (%s)\n", mount_point, strerror(errno));
PLOG(ERROR) << "failed to format " << mount_point;
return -1;
}
}
if (result == -1) {
LOGE("failed to mount %s (%s)\n", mount_point, strerror(errno));
PLOG(ERROR) << "failed to mount " << mount_point;
return -1;
}
return 0;
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, mount_point);
LOG(ERROR) << "unknown fs_type \"" << v->fs_type << "\" for " << mount_point;
return -1;
}
@ -134,7 +136,7 @@ int ensure_path_mounted(const char* path) {
int ensure_path_unmounted(const char* path) {
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
LOG(ERROR) << "unknown volume for path [" << path << "]";
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
@ -143,7 +145,7 @@ int ensure_path_unmounted(const char* path) {
}
if (!scan_mounted_volumes()) {
LOGE("failed to scan mounted volumes\n");
LOG(ERROR) << "failed to scan mounted volumes";
return -1;
}
@ -165,7 +167,7 @@ static int exec_cmd(const char* path, char* const argv[]) {
}
waitpid(child, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOGE("%s failed with status %d\n", path, WEXITSTATUS(status));
LOG(ERROR) << path << " failed with status " << WEXITSTATUS(status);
}
return WEXITSTATUS(status);
}
@ -173,21 +175,21 @@ static int exec_cmd(const char* path, char* const argv[]) {
int format_volume(const char* volume, const char* directory) {
Volume* v = volume_for_path(volume);
if (v == NULL) {
LOGE("unknown volume \"%s\"\n", volume);
LOG(ERROR) << "unknown volume \"" << volume << "\"";
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", volume);
LOG(ERROR) << "can't format_volume \"" << volume << "\"";
return -1;
}
if (strcmp(v->mount_point, volume) != 0) {
LOGE("can't give path \"%s\" to format_volume\n", volume);
LOG(ERROR) << "can't give path \"" << volume << "\" to format_volume";
return -1;
}
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
LOG(ERROR) << "format_volume failed to unmount \"" << v->mount_point << "\"";
return -1;
}
@ -195,10 +197,10 @@ int format_volume(const char* volume, const char* directory) {
// if there's a key_loc that looks like a path, it should be a
// block device for storing encryption metadata. wipe it too.
if (v->key_loc != NULL && v->key_loc[0] == '/') {
LOGI("wiping %s\n", v->key_loc);
LOG(INFO) << "wiping " << v->key_loc;
int fd = open(v->key_loc, O_WRONLY | O_CREAT, 0644);
if (fd < 0) {
LOGE("format_volume: failed to open %s\n", v->key_loc);
LOG(ERROR) << "format_volume: failed to open " << v->key_loc;
return -1;
}
wipe_block_device(fd, get_file_size(fd));
@ -216,16 +218,19 @@ int format_volume(const char* volume, const char* directory) {
result = make_ext4fs_directory(v->blk_device, length, volume, sehandle, directory);
} else { /* Has to be f2fs because we checked earlier. */
if (v->key_loc != NULL && strcmp(v->key_loc, "footer") == 0 && length < 0) {
LOGE("format_volume: crypt footer + negative length (%zd) not supported on %s\n", length, v->fs_type);
LOG(ERROR) << "format_volume: crypt footer + negative length (" << length
<< ") not supported on " << v->fs_type;
return -1;
}
if (length < 0) {
LOGE("format_volume: negative length (%zd) not supported on %s\n", length, v->fs_type);
LOG(ERROR) << "format_volume: negative length (" << length
<< ") not supported on " << v->fs_type;
return -1;
}
char *num_sectors;
if (asprintf(&num_sectors, "%zd", length / 512) <= 0) {
LOGE("format_volume: failed to create %s command for %s\n", v->fs_type, v->blk_device);
LOG(ERROR) << "format_volume: failed to create " << v->fs_type
<< " command for " << v->blk_device;
return -1;
}
const char *f2fs_path = "/sbin/mkfs.f2fs";
@ -235,13 +240,13 @@ int format_volume(const char* volume, const char* directory) {
free(num_sectors);
}
if (result != 0) {
LOGE("format_volume: make %s failed on %s with %d(%s)\n", v->fs_type, v->blk_device, result, strerror(errno));
PLOG(ERROR) << "format_volume: make " << v->fs_type << " failed on " << v->blk_device;
return -1;
}
return 0;
}
LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
LOG(ERROR) << "format_volume: fs_type \"" << v->fs_type << "\" unsupported";
return -1;
}
@ -251,7 +256,7 @@ int format_volume(const char* volume) {
int setup_install_mounts() {
if (fstab == NULL) {
LOGE("can't set up install mounts: no fstab loaded\n");
LOG(ERROR) << "can't set up install mounts: no fstab loaded";
return -1;
}
for (int i = 0; i < fstab->num_entries; ++i) {
@ -260,13 +265,13 @@ int setup_install_mounts() {
if (strcmp(v->mount_point, "/tmp") == 0 ||
strcmp(v->mount_point, "/cache") == 0) {
if (ensure_path_mounted(v->mount_point) != 0) {
LOGE("failed to mount %s\n", v->mount_point);
LOG(ERROR) << "failed to mount " << v->mount_point;
return -1;
}
} else {
if (ensure_path_unmounted(v->mount_point) != 0) {
LOGE("failed to unmount %s\n", v->mount_point);
LOG(ERROR) << "failed to unmount " << v->mount_point;
return -1;
}
}

5
screen_ui.cpp
View file

@ -31,6 +31,7 @@
#include <vector>
#include <android-base/logging.h>
#include <android-base/strings.h>
#include <android-base/stringprintf.h>
#include <cutils/properties.h>
@ -417,14 +418,14 @@ void ScreenRecoveryUI::ProgressThreadLoop() {
void ScreenRecoveryUI::LoadBitmap(const char* filename, GRSurface** surface) {
int result = res_create_display_surface(filename, surface);
if (result < 0) {
LOGE("couldn't load bitmap %s (error %d)\n", filename, result);
LOG(ERROR) << "couldn't load bitmap " << filename << " (error " << result << ")";
}
}
void ScreenRecoveryUI::LoadLocalizedBitmap(const char* filename, GRSurface** surface) {
int result = res_create_localized_alpha_surface(filename, locale, surface);
if (result < 0) {
LOGE("couldn't load bitmap %s (error %d)\n", filename, result);
LOG(ERROR) << "couldn't load bitmap " << filename << " (error " << result << ")";
}
}

5
tests/Android.mk
View file

@ -46,7 +46,6 @@ LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_STATIC_LIBRARIES := \
libapplypatch \
libotafault \
libbase \
libverifier \
libcrypto_utils \
libcrypto \
@ -55,7 +54,9 @@ LOCAL_STATIC_LIBRARIES := \
libcutils \
libbz \
libz \
libc
libc \
libbase \
liblog
testdata_out_path := $(TARGET_OUT_DATA_NATIVE_TESTS)/recovery
testdata_files := $(call find-subdir-files, testdata/*)

95
uncrypt/uncrypt.cpp
View file

@ -116,9 +116,6 @@
#include <cutils/sockets.h>
#include <fs_mgr.h>
#define LOG_TAG "uncrypt"
#include <log/log.h>
#define WINDOW_SIZE 5
// uncrypt provides three services: SETUP_BCB, CLEAR_BCB and UNCRYPT.
@ -139,11 +136,11 @@ static struct fstab* fstab = nullptr;
static int write_at_offset(unsigned char* buffer, size_t size, int wfd, off64_t offset) {
if (TEMP_FAILURE_RETRY(lseek64(wfd, offset, SEEK_SET)) == -1) {
ALOGE("error seeking to offset %" PRId64 ": %s", offset, strerror(errno));
PLOG(ERROR) << "error seeking to offset " << offset;
return -1;
}
if (!android::base::WriteFully(wfd, buffer, size)) {
ALOGE("error writing offset %" PRId64 ": %s", offset, strerror(errno));
PLOG(ERROR) << "error writing offset " << offset;
return -1;
}
return 0;
@ -167,13 +164,13 @@ static struct fstab* read_fstab() {
// The fstab path is always "/fstab.${ro.hardware}".
char fstab_path[PATH_MAX+1] = "/fstab.";
if (!property_get("ro.hardware", fstab_path+strlen(fstab_path), "")) {
ALOGE("failed to get ro.hardware");
LOG(ERROR) << "failed to get ro.hardware";
return NULL;
}
fstab = fs_mgr_read_fstab(fstab_path);
if (!fstab) {
ALOGE("failed to read %s", fstab_path);
LOG(ERROR) << "failed to read " << fstab_path;
return NULL;
}
@ -219,7 +216,7 @@ static bool find_uncrypt_package(const std::string& uncrypt_path_file, std::stri
CHECK(package_name != nullptr);
std::string uncrypt_path;
if (!android::base::ReadFileToString(uncrypt_path_file, &uncrypt_path)) {
ALOGE("failed to open \"%s\": %s", uncrypt_path_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to open \"" << uncrypt_path_file << "\"";
return false;
}
@ -232,33 +229,33 @@ static int produce_block_map(const char* path, const char* map_file, const char*
bool encrypted, int socket) {
std::string err;
if (!android::base::RemoveFileIfExists(map_file, &err)) {
ALOGE("failed to remove the existing map file %s: %s", map_file, err.c_str());
LOG(ERROR) << "failed to remove the existing map file " << map_file << ": " << err;
return -1;
}
std::string tmp_map_file = std::string(map_file) + ".tmp";
android::base::unique_fd mapfd(open(tmp_map_file.c_str(),
O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR));
if (mapfd == -1) {
ALOGE("failed to open %s: %s\n", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to open " << tmp_map_file;
return -1;
}
// Make sure we can write to the socket.
if (!write_status_to_socket(0, socket)) {
ALOGE("failed to write to socket %d\n", socket);
LOG(ERROR) << "failed to write to socket " << socket;
return -1;
}
struct stat sb;
if (stat(path, &sb) != 0) {
ALOGE("failed to stat %s", path);
LOG(ERROR) << "failed to stat " << path;
return -1;
}
ALOGI(" block size: %ld bytes", static_cast<long>(sb.st_blksize));
LOG(INFO) << " block size: " << sb.st_blksize << " bytes";
int blocks = ((sb.st_size-1) / sb.st_blksize) + 1;
ALOGI(" file size: %" PRId64 " bytes, %d blocks", sb.st_size, blocks);
LOG(INFO) << " file size: " << sb.st_size << " bytes, " << blocks << " blocks";
std::vector<int> ranges;
@ -266,7 +263,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
blk_dev, static_cast<int64_t>(sb.st_size),
static_cast<int64_t>(sb.st_blksize));
if (!android::base::WriteStringToFd(s, mapfd)) {
ALOGE("failed to write %s: %s", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to write " << tmp_map_file;
return -1;
}
@ -279,7 +276,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
android::base::unique_fd fd(open(path, O_RDONLY));
if (fd == -1) {
ALOGE("failed to open %s for reading: %s", path, strerror(errno));
PLOG(ERROR) << "failed to open " << path << " for reading";
return -1;
}
@ -287,7 +284,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
if (encrypted) {
wfd.reset(open(blk_dev, O_WRONLY));
if (wfd == -1) {
ALOGE("failed to open fd for writing: %s", strerror(errno));
PLOG(ERROR) << "failed to open " << blk_dev << " for writing";
return -1;
}
}
@ -306,7 +303,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
// write out head buffer
int block = head_block;
if (ioctl(fd, FIBMAP, &block) != 0) {
ALOGE("failed to find block %d", head_block);
LOG(ERROR) << "failed to find block " << head_block;
return -1;
}
add_block_to_ranges(ranges, block);
@ -325,7 +322,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
size_t to_read = static_cast<size_t>(
std::min(static_cast<off64_t>(sb.st_blksize), sb.st_size - pos));
if (!android::base::ReadFully(fd, buffers[tail].data(), to_read)) {
ALOGE("failed to read: %s", strerror(errno));
PLOG(ERROR) << "failed to read " << path;
return -1;
}
pos += to_read;
@ -342,7 +339,7 @@ static int produce_block_map(const char* path, const char* map_file, const char*
// write out head buffer
int block = head_block;
if (ioctl(fd, FIBMAP, &block) != 0) {
ALOGE("failed to find block %d", head_block);
LOG(ERROR) << "failed to find block " << head_block;
return -1;
}
add_block_to_ranges(ranges, block);
@ -358,39 +355,39 @@ static int produce_block_map(const char* path, const char* map_file, const char*
if (!android::base::WriteStringToFd(
android::base::StringPrintf("%zu\n", ranges.size() / 2), mapfd)) {
ALOGE("failed to write %s: %s", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to write " << tmp_map_file;
return -1;
}
for (size_t i = 0; i < ranges.size(); i += 2) {
if (!android::base::WriteStringToFd(
android::base::StringPrintf("%d %d\n", ranges[i], ranges[i+1]), mapfd)) {
ALOGE("failed to write %s: %s", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to write " << tmp_map_file;
return -1;
}
}
if (fsync(mapfd) == -1) {
ALOGE("failed to fsync \"%s\": %s", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to fsync \"" << tmp_map_file << "\"";
return -1;
}
if (close(mapfd.release()) == -1) {
ALOGE("failed to close %s: %s", tmp_map_file.c_str(), strerror(errno));
PLOG(ERROR) << "failed to close " << tmp_map_file;
return -1;
}
if (encrypted) {
if (fsync(wfd) == -1) {
ALOGE("failed to fsync \"%s\": %s", blk_dev, strerror(errno));
PLOG(ERROR) << "failed to fsync \"" << blk_dev << "\"";
return -1;
}
if (close(wfd.release()) == -1) {
ALOGE("failed to close %s: %s", blk_dev, strerror(errno));
PLOG(ERROR) << "failed to close " << blk_dev;
return -1;
}
}
if (rename(tmp_map_file.c_str(), map_file) == -1) {
ALOGE("failed to rename %s to %s: %s", tmp_map_file.c_str(), map_file, strerror(errno));
PLOG(ERROR) << "failed to rename " << tmp_map_file << " to " << map_file;
return -1;
}
// Sync dir to make rename() result written to disk.
@ -398,28 +395,28 @@ static int produce_block_map(const char* path, const char* map_file, const char*
std::string dir_name = dirname(&file_name[0]);
android::base::unique_fd dfd(open(dir_name.c_str(), O_RDONLY | O_DIRECTORY));
if (dfd == -1) {
ALOGE("failed to open dir %s: %s", dir_name.c_str(), strerror(errno));
PLOG(ERROR) << "failed to open dir " << dir_name;
return -1;
}
if (fsync(dfd) == -1) {
ALOGE("failed to fsync %s: %s", dir_name.c_str(), strerror(errno));
PLOG(ERROR) << "failed to fsync " << dir_name;
return -1;
}
if (close(dfd.release()) == -1) {
ALOGE("failed to close %s: %s", dir_name.c_str(), strerror(errno));
PLOG(ERROR) << "failed to close " << dir_name;
return -1;
}
return 0;
}
static int uncrypt(const char* input_path, const char* map_file, const int socket) {
ALOGI("update package is \"%s\"", input_path);
LOG(INFO) << "update package is \"" << input_path << "\"";
// Turn the name of the file we're supposed to convert into an
// absolute path, so we can find what filesystem it's on.
char path[PATH_MAX+1];
if (realpath(input_path, path) == NULL) {
ALOGE("failed to convert \"%s\" to absolute path: %s", input_path, strerror(errno));
PLOG(ERROR) << "failed to convert \"" << input_path << "\" to absolute path";
return 1;
}
@ -427,15 +424,15 @@ static int uncrypt(const char* input_path, const char* map_file, const int socke
bool encrypted;
const char* blk_dev = find_block_device(path, &encryptable, &encrypted);
if (blk_dev == NULL) {
ALOGE("failed to find block device for %s", path);
LOG(ERROR) << "failed to find block device for " << path;
return 1;
}
// If the filesystem it's on isn't encrypted, we only produce the
// block map, we don't rewrite the file contents (it would be
// pointless to do so).
ALOGI("encryptable: %s", encryptable ? "yes" : "no");
ALOGI(" encrypted: %s", encrypted ? "yes" : "no");
LOG(INFO) << "encryptable: " << (encryptable ? "yes" : "no");
LOG(INFO) << " encrypted: " << (encrypted ? "yes" : "no");
// Recovery supports installing packages from 3 paths: /cache,
// /data, and /sdcard. (On a particular device, other locations
@ -445,7 +442,7 @@ static int uncrypt(const char* input_path, const char* map_file, const int socke
// can read the package without mounting the partition. On /cache
// and /sdcard we leave the file alone.
if (strncmp(path, "/data/", 6) == 0) {
ALOGI("writing block map %s", map_file);
LOG(INFO) << "writing block map " << map_file;
if (produce_block_map(path, map_file, blk_dev, encrypted, socket) != 0) {
return 1;
}
@ -476,7 +473,7 @@ static bool uncrypt_wrapper(const char* input_path, const char* map_file, const
static bool clear_bcb(const int socket) {
std::string err;
if (!clear_bootloader_message(&err)) {
ALOGE("failed to clear bootloader message: %s", err.c_str());
LOG(ERROR) << "failed to clear bootloader message: " << err;
write_status_to_socket(-1, socket);
return false;
}
@ -488,7 +485,7 @@ static bool setup_bcb(const int socket) {
// c5. receive message length
int length;
if (!android::base::ReadFully(socket, &length, 4)) {
ALOGE("failed to read the length: %s", strerror(errno));
PLOG(ERROR) << "failed to read the length";
return false;
}
length = ntohl(length);
@ -497,17 +494,17 @@ static bool setup_bcb(const int socket) {
std::string content;
content.resize(length);
if (!android::base::ReadFully(socket, &content[0], length)) {
ALOGE("failed to read the length: %s", strerror(errno));
PLOG(ERROR) << "failed to read the length";
return false;
}
ALOGI(" received command: [%s] (%zu)", content.c_str(), content.size());
LOG(INFO) << " received command: [" << content << "] (" << content.size() << ")";
std::vector<std::string> options = android::base::Split(content, "\n");
std::string wipe_package;
for (auto& option : options) {
if (android::base::StartsWith(option, "--wipe_package=")) {
std::string path = option.substr(strlen("--wipe_package="));
if (!android::base::ReadFileToString(path, &wipe_package)) {
ALOGE("failed to read %s: %s", path.c_str(), strerror(errno));
PLOG(ERROR) << "failed to read " << path;
return false;
}
option = android::base::StringPrintf("--wipe_package_size=%zu", wipe_package.size());
@ -517,12 +514,12 @@ static bool setup_bcb(const int socket) {
// c8. setup the bcb command
std::string err;
if (!write_bootloader_message(options, &err)) {
ALOGE("failed to set bootloader message: %s", err.c_str());
LOG(ERROR) << "failed to set bootloader message: " << err;
write_status_to_socket(-1, socket);
return false;
}
if (!wipe_package.empty() && !write_wipe_package(wipe_package, &err)) {
ALOGE("failed to set wipe package: %s", err.c_str());
PLOG(ERROR) << "failed to set wipe package: " << err;
write_status_to_socket(-1, socket);
return false;
}
@ -566,19 +563,19 @@ int main(int argc, char** argv) {
// will use the socket to communicate with its caller.
android::base::unique_fd service_socket(android_get_control_socket(UNCRYPT_SOCKET.c_str()));
if (service_socket == -1) {
ALOGE("failed to open socket \"%s\": %s", UNCRYPT_SOCKET.c_str(), strerror(errno));
PLOG(ERROR) << "failed to open socket \"" << UNCRYPT_SOCKET << "\"";
return 1;
}
fcntl(service_socket, F_SETFD, FD_CLOEXEC);
if (listen(service_socket, 1) == -1) {
ALOGE("failed to listen on socket %d: %s", service_socket.get(), strerror(errno));
PLOG(ERROR) << "failed to listen on socket " << service_socket.get();
return 1;
}
android::base::unique_fd socket_fd(accept4(service_socket, nullptr, nullptr, SOCK_CLOEXEC));
if (socket_fd == -1) {
ALOGE("failed to accept on socket %d: %s", service_socket.get(), strerror(errno));
PLOG(ERROR) << "failed to accept on socket " << service_socket.get();
return 1;
}
@ -594,7 +591,7 @@ int main(int argc, char** argv) {
success = clear_bcb(socket_fd);
break;
default: // Should never happen.
ALOGE("Invalid uncrypt action code: %d", action);
LOG(ERROR) << "Invalid uncrypt action code: " << action;
return 1;
}
@ -603,9 +600,9 @@ int main(int argc, char** argv) {
// destroyed.
int code;
if (android::base::ReadFully(socket_fd, &code, 4)) {
ALOGI(" received %d, exiting now", code);
LOG(INFO) << " received " << code << ", exiting now";
} else {
ALOGE("failed to read the code: %s", strerror(errno));
PLOG(ERROR) << "failed to read the code";
}
return success ? 0 : 1;
}

45
update_verifier/update_verifier.cpp
View file

@ -40,13 +40,12 @@
#include <vector>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include <cutils/properties.h>
#include <hardware/boot_control.h>
#define LOG_TAG "update_verifier"
#include <log/log.h>
constexpr auto CARE_MAP_FILE = "/data/ota_package/care_map.txt";
constexpr int BLOCKSIZE = 4096;
@ -57,7 +56,7 @@ static bool read_blocks(const std::string& blk_device_prefix, const std::string&
std::string blk_device = blk_device_prefix + std::string(slot_suffix);
android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY)));
if (fd.get() == -1) {
SLOGE("Error reading partition %s: %s\n", blk_device.c_str(), strerror(errno));
PLOG(ERROR) << "Error reading partition " << blk_device;
return false;
}
@ -70,7 +69,7 @@ static bool read_blocks(const std::string& blk_device_prefix, const std::string&
bool status = android::base::ParseUint(ranges[0].c_str(), &range_count);
if (!status || (range_count == 0) || (range_count % 2 != 0) ||
(range_count != ranges.size()-1)) {
SLOGE("Error in parsing range string.\n");
LOG(ERROR) << "Error in parsing range string.";
return false;
}
@ -80,26 +79,25 @@ static bool read_blocks(const std::string& blk_device_prefix, const std::string&
bool parse_status = android::base::ParseUint(ranges[i].c_str(), &range_start);
parse_status = parse_status && android::base::ParseUint(ranges[i+1].c_str(), &range_end);
if (!parse_status || range_start >= range_end) {
SLOGE("Invalid range pair %s, %s.\n", ranges[i].c_str(), ranges[i+1].c_str());
LOG(ERROR) << "Invalid range pair " << ranges[i] << ", " << ranges[i+1];
return false;
}
if (lseek64(fd.get(), static_cast<off64_t>(range_start) * BLOCKSIZE, SEEK_SET) == -1) {
SLOGE("lseek to %u failed: %s.\n", range_start, strerror(errno));
PLOG(ERROR) << "lseek to " << range_start << " failed";
return false;
}
size_t size = (range_end - range_start) * BLOCKSIZE;
std::vector<uint8_t> buf(size);
if (!android::base::ReadFully(fd.get(), buf.data(), size)) {
SLOGE("Failed to read blocks %u to %u: %s.\n", range_start, range_end,
strerror(errno));
PLOG(ERROR) << "Failed to read blocks " << range_start << " to " << range_end;
return false;
}
blk_count += (range_end - range_start);
}
SLOGI("Finished reading %zu blocks on %s.\n", blk_count, blk_device.c_str());
LOG(INFO) << "Finished reading " << blk_count << " blocks on " << blk_device;
return true;
}
@ -109,7 +107,7 @@ static bool verify_image(const std::string& care_map_name) {
// in /data/ota_package. To allow the device to continue booting in this situation,
// we should print a warning and skip the block verification.
if (care_map_fd.get() == -1) {
SLOGI("Warning: care map %s not found.\n", care_map_name.c_str());
LOG(WARNING) << "Warning: care map " << care_map_name << " not found.";
return true;
}
// Care map file has four lines (two lines if vendor partition is not present):
@ -118,15 +116,15 @@ static bool verify_image(const std::string& care_map_name) {
// The next two lines have the same format but for vendor partition.
std::string file_content;
if (!android::base::ReadFdToString(care_map_fd.get(), &file_content)) {
SLOGE("Error reading care map contents to string.\n");
LOG(ERROR) << "Error reading care map contents to string.";
return false;
}
std::vector<std::string> lines;
lines = android::base::Split(android::base::Trim(file_content), "\n");
if (lines.size() != 2 && lines.size() != 4) {
SLOGE("Invalid lines in care_map: found %zu lines, expecting 2 or 4 lines.\n",
lines.size());
LOG(ERROR) << "Invalid lines in care_map: found " << lines.size()
<< " lines, expecting 2 or 4 lines.";
return false;
}
@ -141,12 +139,12 @@ static bool verify_image(const std::string& care_map_name) {
int main(int argc, char** argv) {
for (int i = 1; i < argc; i++) {
SLOGI("Started with arg %d: %s\n", i, argv[i]);
LOG(INFO) << "Started with arg " << i << ": " << argv[i];
}
const hw_module_t* hw_module;
if (hw_get_module("bootctrl", &hw_module) != 0) {
SLOGE("Error getting bootctrl module.\n");
LOG(ERROR) << "Error getting bootctrl module.";
return -1;
}
@ -156,34 +154,35 @@ int main(int argc, char** argv) {
unsigned current_slot = module->getCurrentSlot(module);
int is_successful= module->isSlotMarkedSuccessful(module, current_slot);
SLOGI("Booting slot %u: isSlotMarkedSuccessful=%d\n", current_slot, is_successful);
LOG(INFO) << "Booting slot " << current_slot << ": isSlotMarkedSuccessful=" << is_successful;
if (is_successful == 0) {
// The current slot has not booted successfully.
char verity_mode[PROPERTY_VALUE_MAX];
if (property_get("ro.boot.veritymode", verity_mode, "") == -1) {
SLOGE("Failed to get dm-verity mode");
LOG(ERROR) << "Failed to get dm-verity mode.";
return -1;
} else if (strcasecmp(verity_mode, "eio") == 0) {
// We shouldn't see verity in EIO mode if the current slot hasn't booted
// successfully before. Therefore, fail the verification when veritymode=eio.
SLOGE("Found dm-verity in EIO mode, skip verification.");
LOG(ERROR) << "Found dm-verity in EIO mode, skip verification.";
return -1;
} else if (strcmp(verity_mode, "enforcing") != 0) {
SLOGE("Unexpected dm-verity mode : %s, expecting enforcing.", verity_mode);
LOG(ERROR) << "Unexpected dm-verity mode : " << verity_mode << ", expecting enforcing.";
return -1;
} else if (!verify_image(CARE_MAP_FILE)) {
SLOGE("Failed to verify all blocks in care map file.\n");
LOG(ERROR) << "Failed to verify all blocks in care map file.";
return -1;
}
int ret = module->markBootSuccessful(module);
if (ret != 0) {
SLOGE("Error marking booted successfully: %s\n", strerror(-ret));
LOG(ERROR) << "Error marking booted successfully: " << strerror(-ret);
return -1;
}
SLOGI("Marked slot %u as booted successfully.\n", current_slot);
LOG(INFO) << "Marked slot " << current_slot << " as booted successfully.";
}
SLOGI("Leaving update_verifier.\n");
LOG(INFO) << "Leaving update_verifier.";
return 0;
}

5
updater/Android.mk
View file

@ -37,7 +37,6 @@ LOCAL_STATIC_LIBRARIES += \
libcrypto_utils \
libcrypto \
libapplypatch \
libbase \
libotafault \
libedify \
libminzip \
@ -46,7 +45,9 @@ LOCAL_STATIC_LIBRARIES += \
libbz \
libcutils \
liblog \
libselinux
libselinux \
libbase \
liblog
tune2fs_static_libraries := \
libext2_com_err \

50
verifier.cpp
View file

@ -22,6 +22,7 @@
#include <algorithm>
#include <memory>
#include <android-base/logging.h>
#include <openssl/bn.h>
#include <openssl/ecdsa.h>
#include <openssl/obj_mac.h>
@ -131,24 +132,24 @@ int verify_file(unsigned char* addr, size_t length,
#define FOOTER_SIZE 6
if (length < FOOTER_SIZE) {
LOGE("not big enough to contain footer\n");
LOG(ERROR) << "not big enough to contain footer";
return VERIFY_FAILURE;
}
unsigned char* footer = addr + length - FOOTER_SIZE;
if (footer[2] != 0xff || footer[3] != 0xff) {
LOGE("footer is wrong\n");
LOG(ERROR) << "footer is wrong";
return VERIFY_FAILURE;
}
size_t comment_size = footer[4] + (footer[5] << 8);
size_t signature_start = footer[0] + (footer[1] << 8);
LOGI("comment is %zu bytes; signature %zu bytes from end\n",
comment_size, signature_start);
LOG(INFO) << "comment is " << comment_size << " bytes; signature is " << signature_start
<< " bytes from end";
if (signature_start <= FOOTER_SIZE) {
LOGE("Signature start is in the footer");
LOG(ERROR) << "Signature start is in the footer";
return VERIFY_FAILURE;
}
@ -159,7 +160,7 @@ int verify_file(unsigned char* addr, size_t length,
size_t eocd_size = comment_size + EOCD_HEADER_SIZE;
if (length < eocd_size) {
LOGE("not big enough to contain EOCD\n");
LOG(ERROR) << "not big enough to contain EOCD";
return VERIFY_FAILURE;
}
@ -175,7 +176,7 @@ int verify_file(unsigned char* addr, size_t length,
// magic number $50 $4b $05 $06.
if (eocd[0] != 0x50 || eocd[1] != 0x4b ||
eocd[2] != 0x05 || eocd[3] != 0x06) {
LOGE("signature length doesn't match EOCD marker\n");
LOG(ERROR) << "signature length doesn't match EOCD marker";
return VERIFY_FAILURE;
}
@ -186,7 +187,7 @@ int verify_file(unsigned char* addr, size_t length,
// the real one, minzip will find the later (wrong) one,
// which could be exploitable. Fail verification if
// this sequence occurs anywhere after the real one.
LOGE("EOCD marker occurs after start of EOCD\n");
LOG(ERROR) << "EOCD marker occurs after start of EOCD";
return VERIFY_FAILURE;
}
}
@ -235,12 +236,11 @@ int verify_file(unsigned char* addr, size_t length,
uint8_t* signature = eocd + eocd_size - signature_start;
size_t signature_size = signature_start - FOOTER_SIZE;
LOGI("signature (offset: 0x%zx, length: %zu): %s\n",
length - signature_start, signature_size,
print_hex(signature, signature_size).c_str());
LOG(INFO) << "signature (offset: " << std::hex << (length - signature_start) << ", length: "
<< signature_size << "): " << print_hex(signature, signature_size);
if (!read_pkcs7(signature, signature_size, &sig_der, &sig_der_length)) {
LOGE("Could not find signature DER block\n");
LOG(ERROR) << "Could not find signature DER block";
return VERIFY_FAILURE;
}
@ -271,38 +271,38 @@ int verify_file(unsigned char* addr, size_t length,
if (key.key_type == Certificate::KEY_TYPE_RSA) {
if (!RSA_verify(hash_nid, hash, key.hash_len, sig_der,
sig_der_length, key.rsa.get())) {
LOGI("failed to verify against RSA key %zu\n", i);
LOG(INFO) << "failed to verify against RSA key " << i;
continue;
}
LOGI("whole-file signature verified against RSA key %zu\n", i);
LOG(INFO) << "whole-file signature verified against RSA key " << i;
free(sig_der);
return VERIFY_SUCCESS;
} else if (key.key_type == Certificate::KEY_TYPE_EC
&& key.hash_len == SHA256_DIGEST_LENGTH) {
if (!ECDSA_verify(0, hash, key.hash_len, sig_der,
sig_der_length, key.ec.get())) {
LOGI("failed to verify against EC key %zu\n", i);
LOG(INFO) << "failed to verify against EC key " << i;
continue;
}
LOGI("whole-file signature verified against EC key %zu\n", i);
LOG(INFO) << "whole-file signature verified against EC key " << i;
free(sig_der);
return VERIFY_SUCCESS;
} else {
LOGI("Unknown key type %d\n", key.key_type);
LOG(INFO) << "Unknown key type " << key.key_type;
}
i++;
}
if (need_sha1) {
LOGI("SHA-1 digest: %s\n", print_hex(sha1, SHA_DIGEST_LENGTH).c_str());
LOG(INFO) << "SHA-1 digest: " << print_hex(sha1, SHA_DIGEST_LENGTH);
}
if (need_sha256) {
LOGI("SHA-256 digest: %s\n", print_hex(sha256, SHA256_DIGEST_LENGTH).c_str());
LOG(INFO) << "SHA-256 digest: " << print_hex(sha256, SHA256_DIGEST_LENGTH);
}
free(sig_der);
LOGE("failed to verify whole-file signature\n");
LOG(ERROR) << "failed to verify whole-file signature";
return VERIFY_FAILURE;
}
@ -323,7 +323,7 @@ std::unique_ptr<RSA, RSADeleter> parse_rsa_key(FILE* file, uint32_t exponent) {
}
if (key_len_words > 8192 / 32) {
LOGE("key length (%d) too large\n", key_len_words);
LOG(ERROR) << "key length (" << key_len_words << ") too large";
return nullptr;
}
@ -479,7 +479,7 @@ std::unique_ptr<EC_KEY, ECKEYDeleter> parse_ec_key(FILE* file) {
bool load_keys(const char* filename, std::vector<Certificate>& certs) {
std::unique_ptr<FILE, decltype(&fclose)> f(fopen(filename, "r"), fclose);
if (!f) {
LOGE("opening %s: %s\n", filename, strerror(errno));
PLOG(ERROR) << "error opening " << filename;
return false;
}
@ -529,14 +529,14 @@ bool load_keys(const char* filename, std::vector<Certificate>& certs) {
return false;
}
LOGI("read key e=%d hash=%d\n", exponent, cert.hash_len);
LOG(INFO) << "read key e=" << exponent << " hash=" << cert.hash_len;
} else if (cert.key_type == Certificate::KEY_TYPE_EC) {
cert.ec = parse_ec_key(f.get());
if (!cert.ec) {
return false;
}
} else {
LOGE("Unknown key type %d\n", cert.key_type);
LOG(ERROR) << "Unknown key type " << cert.key_type;
return false;
}
@ -548,7 +548,7 @@ bool load_keys(const char* filename, std::vector<Certificate>& certs) {
} else if (ch == EOF) {
break;
} else {
LOGE("unexpected character between keys\n");
LOG(ERROR) << "unexpected character between keys";
return false;
}
}

20
wear_touch.cpp
View file

@ -14,9 +14,6 @@
* limitations under the License.
*/
#include "common.h"
#include "wear_touch.h"
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
@ -25,8 +22,11 @@
#include <errno.h>
#include <string.h>
#include <android-base/logging.h>
#include <linux/input.h>
#include "wear_touch.h"
#define DEVICE_PATH "/dev/input"
WearSwipeDetector::WearSwipeDetector(int low, int high, OnSwipeCallback callback, void* cookie):
@ -49,11 +49,11 @@ void WearSwipeDetector::detect(int dx, int dy) {
} else if (abs(dx) < mLowThreshold && abs(dy) > mHighThreshold) {
direction = dy < 0 ? UP : DOWN;
} else {
LOGD("Ignore %d %d\n", dx, dy);
LOG(DEBUG) << "Ignore " << dx << " " << dy;
return;
}
LOGD("Swipe direction=%d\n", direction);
LOG(DEBUG) << "Swipe direction=" << direction;
mCallback(mCookie, direction);
}
@ -105,7 +105,7 @@ void WearSwipeDetector::process(struct input_event *event) {
void WearSwipeDetector::run() {
int fd = findDevice(DEVICE_PATH);
if (fd < 0) {
LOGE("no input devices found\n");
LOG(ERROR) << "no input devices found";
return;
}
@ -127,14 +127,14 @@ void* WearSwipeDetector::touch_thread(void* cookie) {
int WearSwipeDetector::openDevice(const char *device) {
int fd = open(device, O_RDONLY);
if (fd < 0) {
LOGE("could not open %s, %s\n", device, strerror(errno));
PLOG(ERROR) << "could not open " << device;
return false;
}
char name[80];
name[sizeof(name) - 1] = '\0';
if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
LOGE("could not get device name for %s, %s\n", device, strerror(errno));
PLOG(ERROR) << "could not get device name for " << device;
name[0] = '\0';
}
@ -143,7 +143,7 @@ int WearSwipeDetector::openDevice(const char *device) {
int ret = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(bits)), bits);
if (ret > 0) {
if (test_bit(ABS_MT_POSITION_X, bits) && test_bit(ABS_MT_POSITION_Y, bits)) {
LOGD("Found %s %s\n", device, name);
LOG(DEBUG) << "Found " << device << " " << name;
return fd;
}
}
@ -155,7 +155,7 @@ int WearSwipeDetector::openDevice(const char *device) {
int WearSwipeDetector::findDevice(const char* path) {
DIR* dir = opendir(path);
if (dir == NULL) {
LOGE("Could not open directory %s", path);
PLOG(ERROR) << "Could not open directory " << path;
return false;
}