c679f93da3
When the command file contains "--sideload" (as a result of 'adb reboot sideload'), it goes into sideload mode directly. Text display will be turned on by default. It waits for user interaction upon finishing. When the command file contains "--sideload_auto_reboot", it enters sideload mode silently. And it will reboot after the installation regardless of its result, which is designed for automated testing purpose. Change-Id: Ifdf173351221c7bbf635cfd32463b48e1fff5740
1167 lines
38 KiB
C++
1167 lines
38 KiB
C++
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <getopt.h>
|
|
#include <limits.h>
|
|
#include <linux/input.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/klog.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#include "bootloader.h"
|
|
#include "common.h"
|
|
#include "cutils/properties.h"
|
|
#include "cutils/android_reboot.h"
|
|
#include "install.h"
|
|
#include "minui/minui.h"
|
|
#include "minzip/DirUtil.h"
|
|
#include "roots.h"
|
|
#include "ui.h"
|
|
#include "screen_ui.h"
|
|
#include "device.h"
|
|
#include "adb_install.h"
|
|
extern "C" {
|
|
#include "adb.h"
|
|
#include "fuse_sideload.h"
|
|
#include "fuse_sdcard_provider.h"
|
|
}
|
|
|
|
struct selabel_handle *sehandle;
|
|
|
|
static const struct option OPTIONS[] = {
|
|
{ "send_intent", required_argument, NULL, 'i' },
|
|
{ "update_package", required_argument, NULL, 'u' },
|
|
{ "wipe_data", no_argument, NULL, 'w' },
|
|
{ "wipe_cache", no_argument, NULL, 'c' },
|
|
{ "show_text", no_argument, NULL, 't' },
|
|
{ "sideload", no_argument, NULL, 's' },
|
|
{ "sideload_auto_reboot", no_argument, NULL, 'a' },
|
|
{ "just_exit", no_argument, NULL, 'x' },
|
|
{ "locale", required_argument, NULL, 'l' },
|
|
{ "stages", required_argument, NULL, 'g' },
|
|
{ "shutdown_after", no_argument, NULL, 'p' },
|
|
{ "reason", required_argument, NULL, 'r' },
|
|
{ NULL, 0, NULL, 0 },
|
|
};
|
|
|
|
#define LAST_LOG_FILE "/cache/recovery/last_log"
|
|
|
|
static const char *CACHE_LOG_DIR = "/cache/recovery";
|
|
static const char *COMMAND_FILE = "/cache/recovery/command";
|
|
static const char *INTENT_FILE = "/cache/recovery/intent";
|
|
static const char *LOG_FILE = "/cache/recovery/log";
|
|
static const char *LAST_INSTALL_FILE = "/cache/recovery/last_install";
|
|
static const char *LOCALE_FILE = "/cache/recovery/last_locale";
|
|
static const char *CACHE_ROOT = "/cache";
|
|
static const char *SDCARD_ROOT = "/sdcard";
|
|
static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";
|
|
static const char *TEMPORARY_INSTALL_FILE = "/tmp/last_install";
|
|
static const char *LAST_KMSG_FILE = "/cache/recovery/last_kmsg";
|
|
#define KLOG_DEFAULT_LEN (64 * 1024)
|
|
|
|
#define KEEP_LOG_COUNT 10
|
|
|
|
// Number of lines per page when displaying a file on screen
|
|
#define LINES_PER_PAGE 30
|
|
|
|
RecoveryUI* ui = NULL;
|
|
char* locale = NULL;
|
|
char recovery_version[PROPERTY_VALUE_MAX+1];
|
|
char* stage = NULL;
|
|
char* reason = NULL;
|
|
|
|
/*
|
|
* The recovery tool communicates with the main system through /cache files.
|
|
* /cache/recovery/command - INPUT - command line for tool, one arg per line
|
|
* /cache/recovery/log - OUTPUT - combined log file from recovery run(s)
|
|
* /cache/recovery/intent - OUTPUT - intent that was passed in
|
|
*
|
|
* The arguments which may be supplied in the recovery.command file:
|
|
* --send_intent=anystring - write the text out to recovery.intent
|
|
* --update_package=path - verify install an OTA package file
|
|
* --wipe_data - erase user data (and cache), then reboot
|
|
* --wipe_cache - wipe cache (but not user data), then reboot
|
|
* --set_encrypted_filesystem=on|off - enables / diasables encrypted fs
|
|
* --just_exit - do nothing; exit and reboot
|
|
*
|
|
* After completing, we remove /cache/recovery/command and reboot.
|
|
* Arguments may also be supplied in the bootloader control block (BCB).
|
|
* These important scenarios must be safely restartable at any point:
|
|
*
|
|
* FACTORY RESET
|
|
* 1. user selects "factory reset"
|
|
* 2. main system writes "--wipe_data" to /cache/recovery/command
|
|
* 3. main system reboots into recovery
|
|
* 4. get_args() writes BCB with "boot-recovery" and "--wipe_data"
|
|
* -- after this, rebooting will restart the erase --
|
|
* 5. erase_volume() reformats /data
|
|
* 6. erase_volume() reformats /cache
|
|
* 7. finish_recovery() erases BCB
|
|
* -- after this, rebooting will restart the main system --
|
|
* 8. main() calls reboot() to boot main system
|
|
*
|
|
* OTA INSTALL
|
|
* 1. main system downloads OTA package to /cache/some-filename.zip
|
|
* 2. main system writes "--update_package=/cache/some-filename.zip"
|
|
* 3. main system reboots into recovery
|
|
* 4. get_args() writes BCB with "boot-recovery" and "--update_package=..."
|
|
* -- after this, rebooting will attempt to reinstall the update --
|
|
* 5. install_package() attempts to install the update
|
|
* NOTE: the package install must itself be restartable from any point
|
|
* 6. finish_recovery() erases BCB
|
|
* -- after this, rebooting will (try to) restart the main system --
|
|
* 7. ** if install failed **
|
|
* 7a. prompt_and_wait() shows an error icon and waits for the user
|
|
* 7b; the user reboots (pulling the battery, etc) into the main system
|
|
* 8. main() calls maybe_install_firmware_update()
|
|
* ** if the update contained radio/hboot firmware **:
|
|
* 8a. m_i_f_u() writes BCB with "boot-recovery" and "--wipe_cache"
|
|
* -- after this, rebooting will reformat cache & restart main system --
|
|
* 8b. m_i_f_u() writes firmware image into raw cache partition
|
|
* 8c. m_i_f_u() writes BCB with "update-radio/hboot" and "--wipe_cache"
|
|
* -- after this, rebooting will attempt to reinstall firmware --
|
|
* 8d. bootloader tries to flash firmware
|
|
* 8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache")
|
|
* -- after this, rebooting will reformat cache & restart main system --
|
|
* 8f. erase_volume() reformats /cache
|
|
* 8g. finish_recovery() erases BCB
|
|
* -- after this, rebooting will (try to) restart the main system --
|
|
* 9. main() calls reboot() to boot main system
|
|
*/
|
|
|
|
static const int MAX_ARG_LENGTH = 4096;
|
|
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);
|
|
return NULL;
|
|
}
|
|
|
|
// When writing, try to create the containing directory, if necessary.
|
|
// Use generous permissions, the system (init.rc) will reset them.
|
|
if (strchr("wa", mode[0])) dirCreateHierarchy(path, 0777, NULL, 1, sehandle);
|
|
|
|
FILE *fp = fopen(path, mode);
|
|
return fp;
|
|
}
|
|
|
|
bool is_ro_debuggable() {
|
|
char value[PROPERTY_VALUE_MAX+1];
|
|
return (property_get("ro.debuggable", value, NULL) == 1 && value[0] == '1');
|
|
}
|
|
|
|
static void redirect_stdio(const char* filename) {
|
|
// If these fail, there's not really anywhere to complain...
|
|
freopen(filename, "a", stdout); setbuf(stdout, NULL);
|
|
freopen(filename, "a", stderr); setbuf(stderr, NULL);
|
|
}
|
|
|
|
// 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));
|
|
fclose(fp);
|
|
}
|
|
|
|
// command line args come from, in decreasing precedence:
|
|
// - the actual command line
|
|
// - the bootloader control block (one per line, after "recovery")
|
|
// - the contents of COMMAND_FILE (one per line)
|
|
static void
|
|
get_args(int *argc, char ***argv) {
|
|
struct bootloader_message boot;
|
|
memset(&boot, 0, sizeof(boot));
|
|
get_bootloader_message(&boot); // this may fail, leaving a zeroed structure
|
|
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);
|
|
}
|
|
|
|
if (boot.status[0] != 0 && boot.status[0] != 255) {
|
|
LOGI("Boot status: %.*s\n", (int)sizeof(boot.status), boot.status);
|
|
}
|
|
|
|
// --- if arguments weren't supplied, look in the bootloader control block
|
|
if (*argc <= 1) {
|
|
boot.recovery[sizeof(boot.recovery) - 1] = '\0'; // Ensure termination
|
|
const char *arg = strtok(boot.recovery, "\n");
|
|
if (arg != NULL && !strcmp(arg, "recovery")) {
|
|
*argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
|
|
(*argv)[0] = strdup(arg);
|
|
for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
|
|
if ((arg = strtok(NULL, "\n")) == NULL) break;
|
|
(*argv)[*argc] = strdup(arg);
|
|
}
|
|
LOGI("Got arguments from boot message\n");
|
|
} else if (boot.recovery[0] != 0 && boot.recovery[0] != 255) {
|
|
LOGE("Bad boot message\n\"%.20s\"\n", boot.recovery);
|
|
}
|
|
}
|
|
|
|
// --- if that doesn't work, try the command file
|
|
if (*argc <= 1) {
|
|
FILE *fp = fopen_path(COMMAND_FILE, "r");
|
|
if (fp != NULL) {
|
|
char *token;
|
|
char *argv0 = (*argv)[0];
|
|
*argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
|
|
(*argv)[0] = argv0; // use the same program name
|
|
|
|
char buf[MAX_ARG_LENGTH];
|
|
for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
|
|
if (!fgets(buf, sizeof(buf), fp)) break;
|
|
token = strtok(buf, "\r\n");
|
|
if (token != NULL) {
|
|
(*argv)[*argc] = strdup(token); // Strip newline.
|
|
} else {
|
|
--*argc;
|
|
}
|
|
}
|
|
|
|
check_and_fclose(fp, COMMAND_FILE);
|
|
LOGI("Got arguments from %s\n", COMMAND_FILE);
|
|
}
|
|
}
|
|
|
|
// --> write the arguments we have back into the bootloader control block
|
|
// always boot into recovery after this (until finish_recovery() is called)
|
|
strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
|
|
strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
|
|
int i;
|
|
for (i = 1; i < *argc; ++i) {
|
|
strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery));
|
|
strlcat(boot.recovery, "\n", sizeof(boot.recovery));
|
|
}
|
|
set_bootloader_message(&boot);
|
|
}
|
|
|
|
static void
|
|
set_sdcard_update_bootloader_message() {
|
|
struct bootloader_message boot;
|
|
memset(&boot, 0, sizeof(boot));
|
|
strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
|
|
strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
|
|
set_bootloader_message(&boot);
|
|
}
|
|
|
|
// read from kernel log into buffer and write out to file
|
|
static void
|
|
save_kernel_log(const char *destination) {
|
|
int n;
|
|
char *buffer;
|
|
int klog_buf_len;
|
|
FILE *log;
|
|
|
|
klog_buf_len = klogctl(KLOG_SIZE_BUFFER, 0, 0);
|
|
if (klog_buf_len <= 0) {
|
|
LOGE("Error getting klog size (%s), using default\n", strerror(errno));
|
|
klog_buf_len = KLOG_DEFAULT_LEN;
|
|
}
|
|
|
|
buffer = (char *)malloc(klog_buf_len);
|
|
if (!buffer) {
|
|
LOGE("Can't alloc %d bytes for klog buffer\n", klog_buf_len);
|
|
return;
|
|
}
|
|
|
|
n = klogctl(KLOG_READ_ALL, buffer, klog_buf_len);
|
|
if (n < 0) {
|
|
LOGE("Error in reading klog (%s)\n", strerror(errno));
|
|
free(buffer);
|
|
return;
|
|
}
|
|
|
|
log = fopen_path(destination, "w");
|
|
if (log == NULL) {
|
|
LOGE("Can't open %s\n", destination);
|
|
free(buffer);
|
|
return;
|
|
}
|
|
fwrite(buffer, n, 1, log);
|
|
check_and_fclose(log, destination);
|
|
free(buffer);
|
|
}
|
|
|
|
// How much of the temp log we have copied to the copy in cache.
|
|
static long tmplog_offset = 0;
|
|
|
|
static void
|
|
copy_log_file(const char* source, const char* destination, int append) {
|
|
FILE *log = fopen_path(destination, append ? "a" : "w");
|
|
if (log == NULL) {
|
|
LOGE("Can't open %s\n", destination);
|
|
} else {
|
|
FILE *tmplog = fopen(source, "r");
|
|
if (tmplog != NULL) {
|
|
if (append) {
|
|
fseek(tmplog, tmplog_offset, SEEK_SET); // Since last write
|
|
}
|
|
char buf[4096];
|
|
while (fgets(buf, sizeof(buf), tmplog)) fputs(buf, log);
|
|
if (append) {
|
|
tmplog_offset = ftell(tmplog);
|
|
}
|
|
check_and_fclose(tmplog, source);
|
|
}
|
|
check_and_fclose(log, destination);
|
|
}
|
|
}
|
|
|
|
// Rename last_log -> last_log.1 -> last_log.2 -> ... -> last_log.$max
|
|
// Overwrites any existing last_log.$max.
|
|
static void
|
|
rotate_last_logs(int max) {
|
|
char oldfn[256];
|
|
char newfn[256];
|
|
|
|
int i;
|
|
for (i = max-1; i >= 0; --i) {
|
|
snprintf(oldfn, sizeof(oldfn), (i==0) ? LAST_LOG_FILE : (LAST_LOG_FILE ".%d"), i);
|
|
snprintf(newfn, sizeof(newfn), LAST_LOG_FILE ".%d", i+1);
|
|
// ignore errors
|
|
rename(oldfn, newfn);
|
|
}
|
|
}
|
|
|
|
static void
|
|
copy_logs() {
|
|
// Copy logs to cache so the system can find out what happened.
|
|
copy_log_file(TEMPORARY_LOG_FILE, LOG_FILE, true);
|
|
copy_log_file(TEMPORARY_LOG_FILE, LAST_LOG_FILE, false);
|
|
copy_log_file(TEMPORARY_INSTALL_FILE, LAST_INSTALL_FILE, false);
|
|
save_kernel_log(LAST_KMSG_FILE);
|
|
chmod(LOG_FILE, 0600);
|
|
chown(LOG_FILE, 1000, 1000); // system user
|
|
chmod(LAST_KMSG_FILE, 0600);
|
|
chown(LAST_KMSG_FILE, 1000, 1000); // system user
|
|
chmod(LAST_LOG_FILE, 0640);
|
|
chmod(LAST_INSTALL_FILE, 0644);
|
|
sync();
|
|
}
|
|
|
|
// clear the recovery command and prepare to boot a (hopefully working) system,
|
|
// copy our log file to cache as well (for the system to read), and
|
|
// record any intent we were asked to communicate back to the system.
|
|
// this function is idempotent: call it as many times as you like.
|
|
static void
|
|
finish_recovery(const char *send_intent) {
|
|
// By this point, we're ready to return to the main system...
|
|
if (send_intent != NULL) {
|
|
FILE *fp = fopen_path(INTENT_FILE, "w");
|
|
if (fp == NULL) {
|
|
LOGE("Can't open %s\n", INTENT_FILE);
|
|
} else {
|
|
fputs(send_intent, fp);
|
|
check_and_fclose(fp, INTENT_FILE);
|
|
}
|
|
}
|
|
|
|
// Save the locale to cache, so if recovery is next started up
|
|
// without a --locale argument (eg, directly from the bootloader)
|
|
// it will use the last-known locale.
|
|
if (locale != NULL) {
|
|
LOGI("Saving locale \"%s\"\n", locale);
|
|
FILE* fp = fopen_path(LOCALE_FILE, "w");
|
|
fwrite(locale, 1, strlen(locale), fp);
|
|
fflush(fp);
|
|
fsync(fileno(fp));
|
|
check_and_fclose(fp, LOCALE_FILE);
|
|
}
|
|
|
|
copy_logs();
|
|
|
|
// Reset to normal system boot so recovery won't cycle indefinitely.
|
|
struct bootloader_message boot;
|
|
memset(&boot, 0, sizeof(boot));
|
|
set_bootloader_message(&boot);
|
|
|
|
// Remove the command file, so recovery won't repeat indefinitely.
|
|
if (ensure_path_mounted(COMMAND_FILE) != 0 ||
|
|
(unlink(COMMAND_FILE) && errno != ENOENT)) {
|
|
LOGW("Can't unlink %s\n", COMMAND_FILE);
|
|
}
|
|
|
|
ensure_path_unmounted(CACHE_ROOT);
|
|
sync(); // For good measure.
|
|
}
|
|
|
|
typedef struct _saved_log_file {
|
|
char* name;
|
|
struct stat st;
|
|
unsigned char* data;
|
|
struct _saved_log_file* next;
|
|
} saved_log_file;
|
|
|
|
static int
|
|
erase_volume(const char *volume) {
|
|
bool is_cache = (strcmp(volume, CACHE_ROOT) == 0);
|
|
|
|
ui->SetBackground(RecoveryUI::ERASING);
|
|
ui->SetProgressType(RecoveryUI::INDETERMINATE);
|
|
|
|
saved_log_file* head = NULL;
|
|
|
|
if (is_cache) {
|
|
// If we're reformatting /cache, we load any
|
|
// "/cache/recovery/last*" files into memory, so we can restore
|
|
// them after the reformat.
|
|
|
|
ensure_path_mounted(volume);
|
|
|
|
DIR* d;
|
|
struct dirent* de;
|
|
d = opendir(CACHE_LOG_DIR);
|
|
if (d) {
|
|
char path[PATH_MAX];
|
|
strcpy(path, CACHE_LOG_DIR);
|
|
strcat(path, "/");
|
|
int path_len = strlen(path);
|
|
while ((de = readdir(d)) != NULL) {
|
|
if (strncmp(de->d_name, "last", 4) == 0) {
|
|
saved_log_file* p = (saved_log_file*) malloc(sizeof(saved_log_file));
|
|
strcpy(path+path_len, de->d_name);
|
|
p->name = strdup(path);
|
|
if (stat(path, &(p->st)) == 0) {
|
|
// truncate files to 512kb
|
|
if (p->st.st_size > (1 << 19)) {
|
|
p->st.st_size = 1 << 19;
|
|
}
|
|
p->data = (unsigned char*) malloc(p->st.st_size);
|
|
FILE* f = fopen(path, "rb");
|
|
fread(p->data, 1, p->st.st_size, f);
|
|
fclose(f);
|
|
p->next = head;
|
|
head = p;
|
|
} else {
|
|
free(p);
|
|
}
|
|
}
|
|
}
|
|
closedir(d);
|
|
} else {
|
|
if (errno != ENOENT) {
|
|
printf("opendir failed: %s\n", strerror(errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
ui->Print("Formatting %s...\n", volume);
|
|
|
|
ensure_path_unmounted(volume);
|
|
int result = format_volume(volume);
|
|
|
|
if (is_cache) {
|
|
while (head) {
|
|
FILE* f = fopen_path(head->name, "wb");
|
|
if (f) {
|
|
fwrite(head->data, 1, head->st.st_size, f);
|
|
fclose(f);
|
|
chmod(head->name, head->st.st_mode);
|
|
chown(head->name, head->st.st_uid, head->st.st_gid);
|
|
}
|
|
free(head->name);
|
|
free(head->data);
|
|
saved_log_file* temp = head->next;
|
|
free(head);
|
|
head = temp;
|
|
}
|
|
|
|
// Any part of the log we'd copied to cache is now gone.
|
|
// Reset the pointer so we copy from the beginning of the temp
|
|
// log.
|
|
tmplog_offset = 0;
|
|
copy_logs();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static const char** prepend_title(const char* const* headers) {
|
|
// count the number of lines in our title, plus the
|
|
// caller-provided headers.
|
|
int count = 3; // our title has 3 lines
|
|
const char* const* p;
|
|
for (p = headers; *p; ++p, ++count);
|
|
|
|
const char** new_headers = (const char**)malloc((count+1) * sizeof(char*));
|
|
const char** h = new_headers;
|
|
*(h++) = "Android system recovery (API " EXPAND(RECOVERY_API_VERSION) ")";
|
|
*(h++) = recovery_version;
|
|
*(h++) = "";
|
|
for (p = headers; *p; ++p, ++h) *h = *p;
|
|
*h = NULL;
|
|
|
|
return new_headers;
|
|
}
|
|
|
|
static int
|
|
get_menu_selection(const char* const * headers, const char* const * items,
|
|
int menu_only, int initial_selection, Device* device) {
|
|
// throw away keys pressed previously, so user doesn't
|
|
// accidentally trigger menu items.
|
|
ui->FlushKeys();
|
|
|
|
ui->StartMenu(headers, items, initial_selection);
|
|
int selected = initial_selection;
|
|
int chosen_item = -1;
|
|
|
|
while (chosen_item < 0) {
|
|
int key = ui->WaitKey();
|
|
int visible = ui->IsTextVisible();
|
|
|
|
if (key == -1) { // ui_wait_key() timed out
|
|
if (ui->WasTextEverVisible()) {
|
|
continue;
|
|
} else {
|
|
LOGI("timed out waiting for key input; rebooting.\n");
|
|
ui->EndMenu();
|
|
return 0; // XXX fixme
|
|
}
|
|
}
|
|
|
|
int action = device->HandleMenuKey(key, visible);
|
|
|
|
if (action < 0) {
|
|
switch (action) {
|
|
case Device::kHighlightUp:
|
|
--selected;
|
|
selected = ui->SelectMenu(selected);
|
|
break;
|
|
case Device::kHighlightDown:
|
|
++selected;
|
|
selected = ui->SelectMenu(selected);
|
|
break;
|
|
case Device::kInvokeItem:
|
|
chosen_item = selected;
|
|
break;
|
|
case Device::kNoAction:
|
|
break;
|
|
}
|
|
} else if (!menu_only) {
|
|
chosen_item = action;
|
|
}
|
|
}
|
|
|
|
ui->EndMenu();
|
|
return chosen_item;
|
|
}
|
|
|
|
static int compare_string(const void* a, const void* b) {
|
|
return strcmp(*(const char**)a, *(const char**)b);
|
|
}
|
|
|
|
// Returns a malloc'd path, or NULL.
|
|
static char* browse_directory(const char* path, Device* device) {
|
|
ensure_path_mounted(path);
|
|
|
|
DIR* d = opendir(path);
|
|
if (d == NULL) {
|
|
LOGE("error opening %s: %s\n", path, strerror(errno));
|
|
return NULL;
|
|
}
|
|
|
|
int d_size = 0;
|
|
int d_alloc = 10;
|
|
char** dirs = (char**)malloc(d_alloc * sizeof(char*));
|
|
int z_size = 1;
|
|
int z_alloc = 10;
|
|
char** zips = (char**)malloc(z_alloc * sizeof(char*));
|
|
zips[0] = strdup("../");
|
|
|
|
struct dirent* de;
|
|
while ((de = readdir(d)) != NULL) {
|
|
int name_len = strlen(de->d_name);
|
|
|
|
if (de->d_type == DT_DIR) {
|
|
// skip "." and ".." entries
|
|
if (name_len == 1 && de->d_name[0] == '.') continue;
|
|
if (name_len == 2 && de->d_name[0] == '.' &&
|
|
de->d_name[1] == '.') continue;
|
|
|
|
if (d_size >= d_alloc) {
|
|
d_alloc *= 2;
|
|
dirs = (char**)realloc(dirs, d_alloc * sizeof(char*));
|
|
}
|
|
dirs[d_size] = (char*)malloc(name_len + 2);
|
|
strcpy(dirs[d_size], de->d_name);
|
|
dirs[d_size][name_len] = '/';
|
|
dirs[d_size][name_len+1] = '\0';
|
|
++d_size;
|
|
} else if (de->d_type == DT_REG &&
|
|
name_len >= 4 &&
|
|
strncasecmp(de->d_name + (name_len-4), ".zip", 4) == 0) {
|
|
if (z_size >= z_alloc) {
|
|
z_alloc *= 2;
|
|
zips = (char**)realloc(zips, z_alloc * sizeof(char*));
|
|
}
|
|
zips[z_size++] = strdup(de->d_name);
|
|
}
|
|
}
|
|
closedir(d);
|
|
|
|
qsort(dirs, d_size, sizeof(char*), compare_string);
|
|
qsort(zips, z_size, sizeof(char*), compare_string);
|
|
|
|
// append dirs to the zips list
|
|
if (d_size + z_size + 1 > z_alloc) {
|
|
z_alloc = d_size + z_size + 1;
|
|
zips = (char**)realloc(zips, z_alloc * sizeof(char*));
|
|
}
|
|
memcpy(zips + z_size, dirs, d_size * sizeof(char*));
|
|
free(dirs);
|
|
z_size += d_size;
|
|
zips[z_size] = NULL;
|
|
|
|
const char* headers[] = { "Choose a package to install:", path, "", NULL };
|
|
|
|
char* result;
|
|
int chosen_item = 0;
|
|
while (true) {
|
|
chosen_item = get_menu_selection(headers, zips, 1, chosen_item, device);
|
|
|
|
char* item = zips[chosen_item];
|
|
int item_len = strlen(item);
|
|
if (chosen_item == 0) { // item 0 is always "../"
|
|
// go up but continue browsing (if the caller is update_directory)
|
|
result = NULL;
|
|
break;
|
|
}
|
|
|
|
char new_path[PATH_MAX];
|
|
strlcpy(new_path, path, PATH_MAX);
|
|
strlcat(new_path, "/", PATH_MAX);
|
|
strlcat(new_path, item, PATH_MAX);
|
|
|
|
if (item[item_len-1] == '/') {
|
|
// recurse down into a subdirectory
|
|
new_path[strlen(new_path)-1] = '\0'; // truncate the trailing '/'
|
|
result = browse_directory(new_path, device);
|
|
if (result) break;
|
|
} else {
|
|
// selected a zip file: return the malloc'd path to the caller.
|
|
result = strdup(new_path);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < z_size; ++i) free(zips[i]);
|
|
free(zips);
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool yes_no(Device* device, const char* question1, const char* question2) {
|
|
const char* headers[] = { question1, question2, "", NULL };
|
|
const char* items[] = { " No", " Yes", NULL };
|
|
|
|
int chosen_item = get_menu_selection(headers, items, 1, 0, device);
|
|
return (chosen_item == 1);
|
|
}
|
|
|
|
static void wipe_data(int confirm, Device* device) {
|
|
if (confirm && !yes_no(device, "Wipe all user data?", " THIS CAN NOT BE UNDONE!")) {
|
|
return;
|
|
}
|
|
|
|
ui->Print("\n-- Wiping data...\n");
|
|
device->WipeData();
|
|
erase_volume("/data");
|
|
erase_volume("/cache");
|
|
erase_persistent_partition();
|
|
ui->Print("Data wipe complete.\n");
|
|
}
|
|
|
|
static void wipe_cache(bool should_confirm, Device* device) {
|
|
if (should_confirm && !yes_no(device, "Wipe cache?", " THIS CAN NOT BE UNDONE!")) {
|
|
return;
|
|
}
|
|
|
|
ui->Print("\n-- Wiping cache...\n");
|
|
erase_volume("/cache");
|
|
ui->Print("Cache wipe complete.\n");
|
|
}
|
|
|
|
static void file_to_ui(const char* fn) {
|
|
FILE *fp = fopen_path(fn, "re");
|
|
if (fp == NULL) {
|
|
ui->Print(" Unable to open %s: %s\n", fn, strerror(errno));
|
|
return;
|
|
}
|
|
char line[1024];
|
|
int ct = 0;
|
|
int key = 0;
|
|
redirect_stdio("/dev/null");
|
|
while(fgets(line, sizeof(line), fp) != NULL) {
|
|
ui->Print("%s", line);
|
|
ct++;
|
|
if (ct % LINES_PER_PAGE == 0) {
|
|
// give the user time to glance at the entries
|
|
key = ui->WaitKey();
|
|
|
|
if (key == KEY_POWER) {
|
|
break;
|
|
}
|
|
|
|
if (key == KEY_VOLUMEUP) {
|
|
// Go back by seeking to the beginning and dumping ct - n
|
|
// lines. It's ugly, but this way we don't need to store
|
|
// the previous offsets. The files we're dumping here aren't
|
|
// expected to be very large.
|
|
int i;
|
|
|
|
ct -= 2 * LINES_PER_PAGE;
|
|
if (ct < 0) {
|
|
ct = 0;
|
|
}
|
|
fseek(fp, 0, SEEK_SET);
|
|
for (i = 0; i < ct; i++) {
|
|
fgets(line, sizeof(line), fp);
|
|
}
|
|
ui->Print("^^^^^^^^^^\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the user didn't abort, then give the user time to glance at
|
|
// the end of the log, sorry, no rewind here
|
|
if (key != KEY_POWER) {
|
|
ui->Print("\n--END-- (press any key)\n");
|
|
ui->WaitKey();
|
|
}
|
|
|
|
redirect_stdio(TEMPORARY_LOG_FILE);
|
|
fclose(fp);
|
|
}
|
|
|
|
static void choose_recovery_file(Device* device) {
|
|
unsigned int i;
|
|
unsigned int n;
|
|
static const char** title_headers = NULL;
|
|
char *filename;
|
|
// "Go back" + LAST_KMSG_FILE + KEEP_LOG_COUNT + terminating NULL entry
|
|
char* entries[KEEP_LOG_COUNT + 3];
|
|
memset(entries, 0, sizeof(entries));
|
|
|
|
n = 0;
|
|
entries[n++] = strdup("Go back");
|
|
|
|
// Add kernel kmsg file if available
|
|
if ((ensure_path_mounted(LAST_KMSG_FILE) == 0) && (access(LAST_KMSG_FILE, R_OK) == 0)) {
|
|
entries[n++] = strdup(LAST_KMSG_FILE);
|
|
}
|
|
|
|
// Add LAST_LOG_FILE + LAST_LOG_FILE.x
|
|
for (i = 0; i < KEEP_LOG_COUNT; i++) {
|
|
char *filename;
|
|
if (asprintf(&filename, (i==0) ? LAST_LOG_FILE : (LAST_LOG_FILE ".%d"), i) == -1) {
|
|
// memory allocation failure - return early. Should never happen.
|
|
return;
|
|
}
|
|
if ((ensure_path_mounted(filename) != 0) || (access(filename, R_OK) == -1)) {
|
|
free(filename);
|
|
entries[n++] = NULL;
|
|
break;
|
|
}
|
|
entries[n++] = filename;
|
|
}
|
|
|
|
const char* headers[] = { "Select file to view", "", NULL };
|
|
|
|
while(1) {
|
|
int chosen_item = get_menu_selection(headers, entries, 1, 0, device);
|
|
if (chosen_item == 0) break;
|
|
file_to_ui(entries[chosen_item]);
|
|
}
|
|
|
|
for (i = 0; i < (sizeof(entries) / sizeof(*entries)); i++) {
|
|
free(entries[i]);
|
|
}
|
|
}
|
|
|
|
static int apply_from_sdcard(Device* device, bool* wipe_cache) {
|
|
if (ensure_path_mounted(SDCARD_ROOT) != 0) {
|
|
ui->Print("\n-- Couldn't mount %s.\n", SDCARD_ROOT);
|
|
return INSTALL_ERROR;
|
|
}
|
|
|
|
char* path = browse_directory(SDCARD_ROOT, device);
|
|
if (path == NULL) {
|
|
ui->Print("\n-- No package file selected.\n", path);
|
|
return INSTALL_ERROR;
|
|
}
|
|
|
|
ui->Print("\n-- Install %s ...\n", path);
|
|
set_sdcard_update_bootloader_message();
|
|
void* token = start_sdcard_fuse(path);
|
|
|
|
int status = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache,
|
|
TEMPORARY_INSTALL_FILE, false);
|
|
|
|
finish_sdcard_fuse(token);
|
|
ensure_path_unmounted(SDCARD_ROOT);
|
|
return status;
|
|
}
|
|
|
|
// Return REBOOT, SHUTDOWN, or REBOOT_BOOTLOADER. Returning NO_ACTION
|
|
// means to take the default, which is to reboot or shutdown depending
|
|
// on if the --shutdown_after flag was passed to recovery.
|
|
static Device::BuiltinAction
|
|
prompt_and_wait(Device* device, int status) {
|
|
const char* const* headers = prepend_title(device->GetMenuHeaders());
|
|
|
|
for (;;) {
|
|
finish_recovery(NULL);
|
|
switch (status) {
|
|
case INSTALL_SUCCESS:
|
|
case INSTALL_NONE:
|
|
ui->SetBackground(RecoveryUI::NO_COMMAND);
|
|
break;
|
|
|
|
case INSTALL_ERROR:
|
|
case INSTALL_CORRUPT:
|
|
ui->SetBackground(RecoveryUI::ERROR);
|
|
break;
|
|
}
|
|
ui->SetProgressType(RecoveryUI::EMPTY);
|
|
|
|
int chosen_item = get_menu_selection(headers, device->GetMenuItems(), 0, 0, device);
|
|
|
|
// device-specific code may take some action here. It may
|
|
// return one of the core actions handled in the switch
|
|
// statement below.
|
|
Device::BuiltinAction chosen_action = device->InvokeMenuItem(chosen_item);
|
|
|
|
bool should_wipe_cache = false;
|
|
switch (chosen_action) {
|
|
case Device::NO_ACTION:
|
|
break;
|
|
|
|
case Device::REBOOT:
|
|
case Device::SHUTDOWN:
|
|
case Device::REBOOT_BOOTLOADER:
|
|
return chosen_action;
|
|
|
|
case Device::WIPE_DATA:
|
|
wipe_data(ui->IsTextVisible(), device);
|
|
if (!ui->IsTextVisible()) return Device::NO_ACTION;
|
|
break;
|
|
|
|
case Device::WIPE_CACHE:
|
|
wipe_cache(ui->IsTextVisible(), device);
|
|
if (!ui->IsTextVisible()) return Device::NO_ACTION;
|
|
break;
|
|
|
|
case Device::APPLY_ADB_SIDELOAD:
|
|
case Device::APPLY_EXT:
|
|
{
|
|
bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD);
|
|
if (adb) {
|
|
status = apply_from_adb(ui, &should_wipe_cache, TEMPORARY_INSTALL_FILE);
|
|
} else {
|
|
status = apply_from_sdcard(device, &should_wipe_cache);
|
|
}
|
|
|
|
if (status == INSTALL_SUCCESS && should_wipe_cache) {
|
|
wipe_cache(false, device);
|
|
}
|
|
|
|
if (status != INSTALL_SUCCESS) {
|
|
ui->SetBackground(RecoveryUI::ERROR);
|
|
ui->Print("Installation aborted.\n");
|
|
copy_logs();
|
|
} else if (!ui->IsTextVisible()) {
|
|
return Device::NO_ACTION; // reboot if logs aren't visible
|
|
} else {
|
|
ui->Print("\nInstall from %s complete.\n", adb ? "ADB" : "SD card");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case Device::APPLY_CACHE:
|
|
ui->Print("\nAPPLY_CACHE is deprecated.\n");
|
|
break;
|
|
|
|
case Device::READ_RECOVERY_LASTLOG:
|
|
choose_recovery_file(device);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_property(const char *key, const char *name, void *cookie) {
|
|
printf("%s=%s\n", key, name);
|
|
}
|
|
|
|
static void
|
|
load_locale_from_cache() {
|
|
FILE* fp = fopen_path(LOCALE_FILE, "r");
|
|
char buffer[80];
|
|
if (fp != NULL) {
|
|
fgets(buffer, sizeof(buffer), fp);
|
|
int j = 0;
|
|
unsigned int i;
|
|
for (i = 0; i < sizeof(buffer) && buffer[i]; ++i) {
|
|
if (!isspace(buffer[i])) {
|
|
buffer[j++] = buffer[i];
|
|
}
|
|
}
|
|
buffer[j] = 0;
|
|
locale = strdup(buffer);
|
|
check_and_fclose(fp, LOCALE_FILE);
|
|
}
|
|
}
|
|
|
|
static RecoveryUI* gCurrentUI = NULL;
|
|
|
|
void
|
|
ui_print(const char* format, ...) {
|
|
char buffer[256];
|
|
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
vsnprintf(buffer, sizeof(buffer), format, ap);
|
|
va_end(ap);
|
|
|
|
if (gCurrentUI != NULL) {
|
|
gCurrentUI->Print("%s", buffer);
|
|
} else {
|
|
fputs(buffer, stdout);
|
|
}
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv) {
|
|
time_t start = time(NULL);
|
|
|
|
redirect_stdio(TEMPORARY_LOG_FILE);
|
|
|
|
// If this binary is started with the single argument "--adbd",
|
|
// instead of being the normal recovery binary, it turns into kind
|
|
// of a stripped-down version of adbd that only supports the
|
|
// 'sideload' command. Note this must be a real argument, not
|
|
// anything in the command file or bootloader control block; the
|
|
// only way recovery should be run with this argument is when it
|
|
// starts a copy of itself from the apply_from_adb() function.
|
|
if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {
|
|
adb_main(0, DEFAULT_ADB_PORT);
|
|
return 0;
|
|
}
|
|
|
|
printf("Starting recovery (pid %d) on %s", getpid(), ctime(&start));
|
|
|
|
load_volume_table();
|
|
ensure_path_mounted(LAST_LOG_FILE);
|
|
rotate_last_logs(KEEP_LOG_COUNT);
|
|
get_args(&argc, &argv);
|
|
|
|
const char *send_intent = NULL;
|
|
const char *update_package = NULL;
|
|
bool wipe_data = false;
|
|
bool should_wipe_cache = false;
|
|
bool show_text = false;
|
|
bool sideload = false;
|
|
bool sideload_auto_reboot = false;
|
|
bool just_exit = false;
|
|
bool shutdown_after = false;
|
|
|
|
int arg;
|
|
while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {
|
|
switch (arg) {
|
|
case 'i': send_intent = optarg; break;
|
|
case 'u': update_package = optarg; break;
|
|
case 'w': wipe_data = true; should_wipe_cache = true; break;
|
|
case 'c': should_wipe_cache = true; break;
|
|
case 't': show_text = true; break;
|
|
case 's': sideload = true; break;
|
|
case 'a': sideload = true; sideload_auto_reboot = true; break;
|
|
case 'x': just_exit = true; break;
|
|
case 'l': locale = optarg; break;
|
|
case 'g': {
|
|
if (stage == NULL || *stage == '\0') {
|
|
char buffer[20] = "1/";
|
|
strncat(buffer, optarg, sizeof(buffer)-3);
|
|
stage = strdup(buffer);
|
|
}
|
|
break;
|
|
}
|
|
case 'p': shutdown_after = true; break;
|
|
case 'r': reason = optarg; break;
|
|
case '?':
|
|
LOGE("Invalid command argument\n");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (locale == NULL) {
|
|
load_locale_from_cache();
|
|
}
|
|
printf("locale is [%s]\n", locale);
|
|
printf("stage is [%s]\n", stage);
|
|
printf("reason is [%s]\n", reason);
|
|
|
|
Device* device = make_device();
|
|
ui = device->GetUI();
|
|
gCurrentUI = ui;
|
|
|
|
ui->SetLocale(locale);
|
|
ui->Init();
|
|
|
|
int st_cur, st_max;
|
|
if (stage != NULL && sscanf(stage, "%d/%d", &st_cur, &st_max) == 2) {
|
|
ui->SetStage(st_cur, st_max);
|
|
}
|
|
|
|
ui->SetBackground(RecoveryUI::NONE);
|
|
if (show_text) ui->ShowText(true);
|
|
|
|
struct selinux_opt seopts[] = {
|
|
{ SELABEL_OPT_PATH, "/file_contexts" }
|
|
};
|
|
|
|
sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
|
|
|
|
if (!sehandle) {
|
|
ui->Print("Warning: No file_contexts\n");
|
|
}
|
|
|
|
device->StartRecovery();
|
|
|
|
printf("Command:");
|
|
for (arg = 0; arg < argc; arg++) {
|
|
printf(" \"%s\"", argv[arg]);
|
|
}
|
|
printf("\n");
|
|
|
|
if (update_package) {
|
|
// For backwards compatibility on the cache partition only, if
|
|
// we're given an old 'root' path "CACHE:foo", change it to
|
|
// "/cache/foo".
|
|
if (strncmp(update_package, "CACHE:", 6) == 0) {
|
|
int len = strlen(update_package) + 10;
|
|
char* modified_path = (char*)malloc(len);
|
|
strlcpy(modified_path, "/cache/", len);
|
|
strlcat(modified_path, update_package+6, len);
|
|
printf("(replacing path \"%s\" with \"%s\")\n",
|
|
update_package, modified_path);
|
|
update_package = modified_path;
|
|
}
|
|
}
|
|
printf("\n");
|
|
|
|
property_list(print_property, NULL);
|
|
property_get("ro.build.display.id", recovery_version, "");
|
|
printf("\n");
|
|
|
|
int status = INSTALL_SUCCESS;
|
|
|
|
if (update_package != NULL) {
|
|
status = install_package(update_package, &should_wipe_cache, TEMPORARY_INSTALL_FILE, true);
|
|
if (status == INSTALL_SUCCESS && should_wipe_cache) {
|
|
wipe_cache(false, device);
|
|
}
|
|
if (status != INSTALL_SUCCESS) {
|
|
ui->Print("Installation aborted.\n");
|
|
|
|
// If this is an eng or userdebug build, then automatically
|
|
// turn the text display on if the script fails so the error
|
|
// message is visible.
|
|
if (is_ro_debuggable()) {
|
|
ui->ShowText(true);
|
|
}
|
|
}
|
|
} else if (wipe_data) {
|
|
if (device->WipeData()) status = INSTALL_ERROR;
|
|
if (erase_volume("/data")) status = INSTALL_ERROR;
|
|
if (should_wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
|
|
if (erase_persistent_partition() == -1 ) status = INSTALL_ERROR;
|
|
if (status != INSTALL_SUCCESS) ui->Print("Data wipe failed.\n");
|
|
} else if (should_wipe_cache) {
|
|
if (should_wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
|
|
if (status != INSTALL_SUCCESS) ui->Print("Cache wipe failed.\n");
|
|
} else if (sideload) {
|
|
// 'adb reboot sideload' acts the same as user presses key combinations
|
|
// to enter the sideload mode. When 'sideload-auto-reboot' is used, text
|
|
// display will NOT be turned on by default. And it will reboot after
|
|
// sideload finishes even if there are errors. Unless one turns on the
|
|
// text display during the installation. This is to enable automated
|
|
// testing.
|
|
if (!sideload_auto_reboot) {
|
|
ui->ShowText(true);
|
|
}
|
|
status = apply_from_adb(ui, &should_wipe_cache, TEMPORARY_INSTALL_FILE);
|
|
if (status == INSTALL_SUCCESS && should_wipe_cache) {
|
|
wipe_cache(false, device);
|
|
}
|
|
ui->Print("\nInstall from ADB complete (status: %d).\n", status);
|
|
if (sideload_auto_reboot) {
|
|
ui->Print("Rebooting automatically.\n");
|
|
}
|
|
} else if (!just_exit) {
|
|
status = INSTALL_NONE; // No command specified
|
|
ui->SetBackground(RecoveryUI::NO_COMMAND);
|
|
}
|
|
|
|
if (!sideload_auto_reboot && (status == INSTALL_ERROR || status == INSTALL_CORRUPT)) {
|
|
copy_logs();
|
|
ui->SetBackground(RecoveryUI::ERROR);
|
|
}
|
|
|
|
Device::BuiltinAction after = shutdown_after ? Device::SHUTDOWN : Device::REBOOT;
|
|
if ((status != INSTALL_SUCCESS && !sideload_auto_reboot) || ui->IsTextVisible()) {
|
|
Device::BuiltinAction temp = prompt_and_wait(device, status);
|
|
if (temp != Device::NO_ACTION) {
|
|
after = temp;
|
|
}
|
|
}
|
|
|
|
// Save logs and clean up before rebooting or shutting down.
|
|
finish_recovery(send_intent);
|
|
|
|
switch (after) {
|
|
case Device::SHUTDOWN:
|
|
ui->Print("Shutting down...\n");
|
|
property_set(ANDROID_RB_PROPERTY, "shutdown,");
|
|
break;
|
|
|
|
case Device::REBOOT_BOOTLOADER:
|
|
ui->Print("Rebooting to bootloader...\n");
|
|
property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");
|
|
break;
|
|
|
|
default:
|
|
ui->Print("Rebooting...\n");
|
|
property_set(ANDROID_RB_PROPERTY, "reboot,");
|
|
break;
|
|
}
|
|
sleep(5); // should reboot before this finishes
|
|
return EXIT_SUCCESS;
|
|
}
|