Merge up to android-8.1.0_r1 and fix conflicts

Change-Id: I2dc060134d15ec9f015a606cb24ef8276f6af1fc

Android.bp

+subdirs = [
+//    "bootloader_message",
+//    "otautil",
+]

Android.mk

@@ -590,7 +590,7 @@ endif
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES := fuse_sideload.cpp
 LOCAL_CLANG := true
-LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter
+LOCAL_CFLAGS := -Wall -Werror
 LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
 
 LOCAL_MODULE_TAGS := optional
@@ -605,13 +605,35 @@ else
 endif
 include $(BUILD_SHARED_LIBRARY)
 
+# static libfusesideload
+# =============================== (required to fix build errors in 8.1 due to use by tests)
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := fuse_sideload.cpp
+LOCAL_CLANG := true
+LOCAL_CFLAGS := -Wall -Werror
+LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE := libfusesideload
+LOCAL_SHARED_LIBRARIES := libcutils libc
+ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 24; echo $$?),0)
+    LOCAL_C_INCLUDES := $(LOCAL_PATH)/libmincrypt/includes
+    LOCAL_STATIC_LIBRARIES += libmincrypttwrp
+    LOCAL_CFLAGS += -DUSE_MINCRYPT
+else
+    LOCAL_STATIC_LIBRARIES += libcrypto_static
+endif
+include $(BUILD_STATIC_LIBRARY)
+
 # libmounts (static library)
 # ===============================
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES := mounts.cpp
-LOCAL_CLANG := true
-LOCAL_CFLAGS := -Wall -Wno-unused-parameter -Werror
+LOCAL_CFLAGS := \
+    -Wall \
+    -Werror
 LOCAL_MODULE := libmounts
+LOCAL_STATIC_LIBRARIES := libbase
 include $(BUILD_STATIC_LIBRARY)
 
 # librecovery (static library)
@@ -619,7 +641,7 @@ include $(BUILD_STATIC_LIBRARY)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES := \
     install.cpp
-LOCAL_CFLAGS := -Wno-unused-parameter -Werror
+LOCAL_CFLAGS := -Wall -Werror
 LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION)
 
 ifeq ($(AB_OTA_UPDATER),true)
@@ -632,7 +654,8 @@ LOCAL_STATIC_LIBRARIES := \
     libvintf_recovery \
     libcrypto_utils \
     libcrypto \
-    libbase
+    libbase \
+    libziparchive \
 
 include $(BUILD_STATIC_LIBRARY)
 
@@ -661,6 +684,7 @@ else
     LOCAL_SHARED_LIBRARIES += libcrypto libbase
     LOCAL_SRC_FILES += verifier.cpp asn1_decoder.cpp
 endif
+
 ifeq ($(AB_OTA_UPDATER),true)
     LOCAL_CFLAGS += -DAB_OTA_UPDATER=1
 endif
@@ -679,7 +703,6 @@ include $(BUILD_SHARED_LIBRARY)
 include $(CLEAR_VARS)
 LOCAL_CLANG := true
 LOCAL_MODULE := libverifier
-LOCAL_MODULE_TAGS := tests
 LOCAL_SRC_FILES := \
     asn1_decoder.cpp \
     verifier.cpp \
@@ -687,16 +710,40 @@ LOCAL_SRC_FILES := \
 LOCAL_STATIC_LIBRARIES := libcrypto_static
 include $(BUILD_STATIC_LIBRARY)
 
+# Wear default device
+# ===============================
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := wear_device.cpp
+
+# Should match TARGET_RECOVERY_UI_LIB in BoardConfig.mk.
+LOCAL_MODULE := librecovery_ui_wear
+
+include $(BUILD_STATIC_LIBRARY)
+
+# vr headset default device
+# ===============================
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := vr_device.cpp
+
+# should match TARGET_RECOVERY_UI_LIB set in BoardConfig.mk
+LOCAL_MODULE := librecovery_ui_vr
+
+include $(BUILD_STATIC_LIBRARY)
+
 commands_recovery_local_path := $(LOCAL_PATH)
-include $(LOCAL_PATH)/tests/Android.mk \
-    $(LOCAL_PATH)/tools/Android.mk \
+
+include \
+    $(LOCAL_PATH)/applypatch/Android.mk \
+    $(LOCAL_PATH)/boot_control/Android.mk \
     $(LOCAL_PATH)/edify/Android.mk \
     $(LOCAL_PATH)/otafault/Android.mk \
-    $(LOCAL_PATH)/bootloader_message/Android.mk \
-    $(LOCAL_PATH)/bootloader_message_twrp/Android.mk \
+    $(LOCAL_PATH)/tests/Android.mk \
+    $(LOCAL_PATH)/tools/Android.mk \
     $(LOCAL_PATH)/updater/Android.mk \
     $(LOCAL_PATH)/update_verifier/Android.mk \
-    $(LOCAL_PATH)/applypatch/Android.mk
+    $(LOCAL_PATH)/bootloader_message/Android.mk \
+    $(LOCAL_PATH)/bootloader_message_twrp/Android.mk
 
 ifeq ($(wildcard system/core/uncrypt/Android.mk),)
     include $(commands_recovery_local_path)/uncrypt/Android.mk

OWNERS

+enh+aosp-gerrit@google.com
+tbao@google.com
+xunchang@google.com

adb_install.cpp

@@ -14,24 +14,27 @@
  * limitations under the License.
  */
 
-#include <unistd.h>
+#include "adb_install.h"
+
 #include <dirent.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <signal.h>
 #include <fcntl.h>
 #include <stdio.h>
+#include <unistd.h>
 
 #include "ui.h"
 #include "cutils/properties.h"
-#include "install.h"
+
 #include "common.h"
-#include "adb_install.h"
-#include "minadbd/fuse_adb_provider.h"
 #include "fuse_sideload.h"
 #ifdef USE_OLD_VERIFIER
 #include "verifier24/verifier.h"
@@ -40,86 +43,91 @@
 #endif
 
 static void set_usb_driver(bool enabled) {
-    int fd = open("/sys/class/android_usb/android0/enable", O_WRONLY);
-    if (fd < 0) {
-/* These error messages show when built in older Android branches (e.g. Gingerbread)
-   It's not a critical error so we're disabling the error messages.
-        ui->Print("failed to open driver control: %s\n", strerror(errno));
+  char configfs[PROPERTY_VALUE_MAX];
+  property_get("sys.usb.configfs", configfs, "false");
+  if (strcmp(configfs, "false") == 0 || strcmp(configfs, "0") == 0)
+    return;
+
+  int fd = open("/sys/class/android_usb/android0/enable", O_WRONLY);
+  if (fd < 0) {
+/*  These error messages show when built in older Android branches (e.g. Gingerbread)
+    It's not a critical error so we're disabling the error messages.
+    ui->Print("failed to open driver control: %s\n", strerror(errno));
 */
-		printf("failed to open driver control: %s\n", strerror(errno));
-        return;
-    }
+    printf("failed to open driver control: %s\n", strerror(errno));
+    return;
+  }
 
-    if (TEMP_FAILURE_RETRY(write(fd, enabled ? "1" : "0", 1)) == -1) {
+  if (TEMP_FAILURE_RETRY(write(fd, enabled ? "1" : "0", 1)) == -1) {
 /*
-        ui->Print("failed to set driver control: %s\n", strerror(errno));
+    ui->Print("failed to set driver control: %s\n", strerror(errno));
 */
-		printf("failed to set driver control: %s\n", strerror(errno));
-    }
-    if (close(fd) < 0) {
+    printf("failed to set driver control: %s\n", strerror(errno));
+  }
+  if (close(fd) < 0) {
 /*
-        ui->Print("failed to close driver control: %s\n", strerror(errno));
+    ui->Print("failed to close driver control: %s\n", strerror(errno));
 */
-		printf("failed to close driver control: %s\n", strerror(errno));
-    }
+    printf("failed to close driver control: %s\n", strerror(errno));
+  }
 }
 
 // On Android 8.0 for some reason init can't seem to completely stop adbd
 // so we have to kill it too if it doesn't die on its own.
 static void kill_adbd() {
-    DIR* dir = opendir("/proc");
-    if (dir) {
-        struct dirent* de = 0;
-
-        while ((de = readdir(dir)) != 0) {
-            if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
-                continue;
-
-            int pid = -1;
-            int ret = sscanf(de->d_name, "%d", &pid);
-
-            if (ret == 1) {
-                char cmdpath[PATH_MAX];
-                sprintf(cmdpath, "/proc/%d/cmdline", pid);
-
-                FILE* file = fopen(cmdpath, "r");
-                size_t task_size = PATH_MAX;
-                char task[PATH_MAX];
-                char* p = task;
-                if (getline(&p, &task_size, file) > 0) {
-                    if (strstr(task, "adbd") != 0) {
-                        printf("adbd pid %d found, sending kill.\n", pid);
-                        kill(pid, SIGINT);
-                        usleep(5000);
-                        kill(pid, SIGKILL);
-                    }
-                }
-                fclose(file);
-            }
+  DIR* dir = opendir("/proc");
+  if (dir) {
+    struct dirent* de = 0;
+
+    while ((de = readdir(dir)) != 0) {
+      if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
+        continue;
+
+      int pid = -1;
+      int ret = sscanf(de->d_name, "%d", &pid);
+
+      if (ret == 1) {
+        char cmdpath[PATH_MAX];
+        sprintf(cmdpath, "/proc/%d/cmdline", pid);
+
+        FILE* file = fopen(cmdpath, "r");
+        size_t task_size = PATH_MAX;
+        char task[PATH_MAX];
+        char* p = task;
+        if (getline(&p, &task_size, file) > 0) {
+          if (strstr(task, "adbd") != 0) {
+            printf("adbd pid %d found, sending kill.\n", pid);
+            kill(pid, SIGINT);
+            usleep(5000);
+            kill(pid, SIGKILL);
+          }
         }
-        closedir(dir);
+        fclose(file);
+      }
     }
+    closedir(dir);
+  }
 }
 
 static void stop_adbd() {
-    printf("Stopping adbd...\n");
-    property_set("ctl.stop", "adbd");
-    usleep(5000);
-    kill_adbd();
-    set_usb_driver(false);
+  printf("Stopping adbd...\n");
+  property_set("ctl.stop", "adbd");
+  usleep(5000);
+  kill_adbd();
+  set_usb_driver(false);
 }
 
 static bool is_ro_debuggable() {
-    char value[PROPERTY_VALUE_MAX+1];
-    return (property_get("ro.debuggable", value, NULL) == 1 && value[0] == '1');
+  char value[PROPERTY_VALUE_MAX+1];
+  return (property_get("ro.debuggable", value, NULL) == 1 && value[0] == '1');
 }
 
 static void maybe_restart_adbd() {
-    if (is_ro_debuggable()) {
-        printf("Restarting adbd...\n");
-        set_usb_driver(true);
-        property_set("ctl.start", "adbd");
-    }
+  if (is_ro_debuggable()) {
+    printf("Restarting adbd...\n");
+    set_usb_driver(true);
+    property_set("ctl.start", "adbd");
+  }
 }
 
 // How long (in seconds) we wait for the host to start sending us a
@@ -129,83 +137,83 @@ static void maybe_restart_adbd() {
 int
 apply_from_adb(const char* install_file, pid_t* child_pid) {
 
-    stop_adbd();
-    set_usb_driver(true);
+  stop_adbd();
+  set_usb_driver(true);
 /*
 int apply_from_adb(RecoveryUI* ui, bool* wipe_cache, const char* install_file) {
-    modified_flash = true;
+  modified_flash = true;
 
-    stop_adbd(ui);
-    set_usb_driver(ui, true);
+  stop_adbd(ui);
+  set_usb_driver(ui, true);
 
-    ui->Print("\n\nNow send the package you want to apply\n"
-              "to the device with \"adb sideload <filename>\"...\n");
+  ui->Print("\n\nNow send the package you want to apply\n"
+            "to the device with \"adb sideload <filename>\"...\n");
 */
-    pid_t child;
-    if ((child = fork()) == 0) {
-        execl("/sbin/recovery", "recovery", "--adbd", install_file, NULL);
-        _exit(-1);
-    }
-
-    *child_pid = child;
-    // caller can now kill the child thread from another thread
-
-    // FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the host
-    // connects and starts serving a package.  Poll for its
-    // appearance.  (Note that inotify doesn't work with FUSE.)
-    int result = INSTALL_ERROR;
-    int status;
-    bool waited = false;
-    struct stat st;
-    for (int i = 0; i < ADB_INSTALL_TIMEOUT; ++i) {
-        if (waitpid(child, &status, WNOHANG) != 0) {
-            result = -1;
-            waited = true;
-            break;
-        }
-
-        if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &st) != 0) {
-            if (errno == ENOENT && i < ADB_INSTALL_TIMEOUT-1) {
-                sleep(1);
-                continue;
-            } else {
-                printf("\nTimed out waiting for package: %s\n\n", strerror(errno));
-                result = -1;
-                kill(child, SIGKILL);
-                break;
-            }
-        }
-        // Install is handled elsewhere in TWRP
-        //install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, install_file, false);
-	return 0;
+  pid_t child;
+  if ((child = fork()) == 0) {
+    execl("/sbin/recovery", "recovery", "--adbd", install_file, NULL);
+    _exit(-1);
+  }
+
+  *child_pid = child;
+  // caller can now kill the child thread from another thread
+
+  // FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the host
+  // connects and starts serving a package.  Poll for its
+  // appearance.  (Note that inotify doesn't work with FUSE.)
+  int result = INSTALL_ERROR;
+  int status;
+  bool waited = false;
+  struct stat st;
+  for (int i = 0; i < ADB_INSTALL_TIMEOUT; ++i) {
+    if (waitpid(child, &status, WNOHANG) != 0) {
+      result = -1;
+      waited = true;
+      break;
     }
 
-    // if we got here, something failed
-    *child_pid = 0;
-
-    if (!waited) {
-        // Calling stat() on this magic filename signals the minadbd
-        // subprocess to shut down.
-        stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
-
-        // TODO(dougz): there should be a way to cancel waiting for a
-        // package (by pushing some button combo on the device).  For now
-        // you just have to 'adb sideload' a file that's not a valid
-        // package, like "/dev/null".
-        waitpid(child, &status, 0);
+    if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &st) != 0) {
+      if (errno == ENOENT && i < ADB_INSTALL_TIMEOUT-1) {
+        sleep(1);
+        continue;
+      } else {
+        printf("\nTimed out waiting for package: %s\n\n", strerror(errno));
+        result = -1;
+        kill(child, SIGKILL);
+        break;
+      }
     }
-
-    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
-        if (WEXITSTATUS(status) == 3) {
-            printf("\nYou need adb 1.0.32 or newer to sideload\nto this device.\n\n");
-            result = -2;
-        } else if (!WIFSIGNALED(status)) {
-            printf("status %d\n", WEXITSTATUS(status));
-        }
+    // Install is handled elsewhere in TWRP
+    //install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, install_file, false);
+    return 0;
+  }
+
+  // if we got here, something failed
+  *child_pid = 0;
+
+  if (!waited) {
+    // Calling stat() on this magic filename signals the minadbd
+    // subprocess to shut down.
+    stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
+
+    // TODO(dougz): there should be a way to cancel waiting for a
+    // package (by pushing some button combo on the device).  For now
+    // you just have to 'adb sideload' a file that's not a valid
+    // package, like "/dev/null".
+    waitpid(child, &status, 0);
+  }
+
+  if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+    if (WEXITSTATUS(status) == 3) {
+      printf("\nYou need adb 1.0.32 or newer to sideload\nto this device.\n\n");
+      result = -2;
+    } else if (!WIFSIGNALED(status)) {
+      printf("adbd status %d\n", WEXITSTATUS(status));
     }
+  }
 
-    set_usb_driver(false);
-    maybe_restart_adbd();
+  set_usb_driver(false);
+  maybe_restart_adbd();
 
-    return result;
+  return result;
 }

adb_install.h

@@ -17,6 +17,8 @@
 #ifndef _ADB_INSTALL_H
 #define _ADB_INSTALL_H
 
+#include <sys/types.h>
+
 //class RecoveryUI;
 
 static void set_usb_driver(bool enabled);

applypatch/applypatch.cpp

@@ -27,6 +27,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
@@ -45,7 +46,7 @@
 #include "print_sha1.h"
 
 static int LoadPartitionContents(const std::string& filename, FileContents* file);
-static ssize_t FileSink(const unsigned char* data, ssize_t len, void* token);
+static size_t FileSink(const unsigned char* data, size_t len, int fd);
 static int GenerateTarget(const FileContents& source_file, const std::unique_ptr<Value>& patch,
                           const std::string& target_filename,
                           const uint8_t target_sha1[SHA_DIGEST_LENGTH], const Value* bonus_data);
@@ -224,8 +225,8 @@ int SaveFileContents(const char* filename, const FileContents* file) {
     return -1;
   }
 
-  ssize_t bytes_written = FileSink(file->data.data(), file->data.size(), &fd);
-  if (bytes_written != static_cast<ssize_t>(file->data.size())) {
+  size_t bytes_written = FileSink(file->data.data(), file->data.size(), fd);
+  if (bytes_written != file->data.size()) {
     printf("short write of \"%s\" (%zd bytes of %zu): %s\n", filename, bytes_written,
            file->data.size(), strerror(errno));
     return -1;
@@ -531,25 +532,17 @@ int ShowLicenses() {
     return 0;
 }
 
-ssize_t FileSink(const unsigned char* data, ssize_t len, void* token) {
-    int fd = *static_cast<int*>(token);
-    ssize_t done = 0;
-    ssize_t wrote;
-    while (done < len) {
-        wrote = TEMP_FAILURE_RETRY(ota_write(fd, data+done, len-done));
-        if (wrote == -1) {
-            printf("error writing %zd bytes: %s\n", (len-done), strerror(errno));
-            return done;
-        }
-        done += wrote;
+static size_t FileSink(const unsigned char* data, size_t len, int fd) {
+  size_t done = 0;
+  while (done < len) {
+    ssize_t wrote = TEMP_FAILURE_RETRY(ota_write(fd, data + done, len - done));
+    if (wrote == -1) {
+      printf("error writing %zd bytes: %s\n", (len - done), strerror(errno));
+      return done;
     }
-    return done;
-}
-
-ssize_t MemorySink(const unsigned char* data, ssize_t len, void* token) {
-    std::string* s = static_cast<std::string*>(token);
-    s->append(reinterpret_cast<const char*>(data), len);
-    return len;
+    done += wrote;
+  }
+  return done;
 }
 
 // Return the amount of free space (in bytes) on the filesystem
@@ -745,9 +738,11 @@ static int GenerateTarget(const FileContents& source_file, const std::unique_ptr
   }
 
   // We store the decoded output in memory.
-  SinkFn sink = MemorySink;
   std::string memory_sink_str;  // Don't need to reserve space.
-  void* token = &memory_sink_str;
+  SinkFn sink = [&memory_sink_str](const unsigned char* data, size_t len) {
+    memory_sink_str.append(reinterpret_cast<const char*>(data), len);
+    return len;
+  };
 
   SHA_CTX ctx;
   SHA1_Init(&ctx);
@@ -755,10 +750,10 @@ static int GenerateTarget(const FileContents& source_file, const std::unique_ptr
   int result;
   if (use_bsdiff) {
     result = ApplyBSDiffPatch(source_file.data.data(), source_file.data.size(), patch.get(), 0,
-                              sink, token, &ctx);
+                              sink, &ctx);
   } else {
     result = ApplyImagePatch(source_file.data.data(), source_file.data.size(), patch.get(), sink,
-                             token, &ctx, bonus_data);
+                             &ctx, bonus_data);
   }
 
   if (result != 0) {

applypatch/applypatch.sh

-#!/bin/bash
-#
-# A test suite for applypatch.  Run in a client where you have done
-# envsetup, choosecombo, etc.
-#
-# DO NOT RUN THIS ON A DEVICE YOU CARE ABOUT.  It will mess up your
-# system partition.
-#
-#
-# TODO: find some way to get this run regularly along with the rest of
-# the tests.
-
-EMULATOR_PORT=5580
-DATA_DIR=$ANDROID_BUILD_TOP/bootable/recovery/applypatch/testdata
-
-# This must be the filename that applypatch uses for its copies.
-CACHE_TEMP_SOURCE=/cache/saved.file
-
-# Put all binaries and files here.  We use /cache because it's a
-# temporary filesystem in the emulator; it's created fresh each time
-# the emulator starts.
-WORK_DIR=/system
-
-# partition that WORK_DIR is located on, without the leading slash
-WORK_FS=system
-
-# set to 0 to use a device instead
-USE_EMULATOR=1
-
-# ------------------------
-
-tmpdir=$(mktemp -d)
-
-if [ "$USE_EMULATOR" == 1 ]; then
-  emulator -wipe-data -noaudio -no-window -port $EMULATOR_PORT &
-  pid_emulator=$!
-  ADB="adb -s emulator-$EMULATOR_PORT "
-else
-  ADB="adb -d "
-fi
-
-echo "waiting to connect to device"
-$ADB wait-for-device
-echo "device is available"
-$ADB remount
-# free up enough space on the system partition for the test to run.
-$ADB shell rm -r /system/media
-
-# run a command on the device; exit with the exit status of the device
-# command.