resolve merge conflicts of 2f272c05 to nyc-mr1-dev-plus-aosp

LOCAL_SRC_FILES := \

    adb_install.cpp \

    asn1_decoder.cpp \

    bootloader.cpp \

    device.cpp \

    fuse_sdcard_provider.cpp \

    install.cpp \

LOCAL_STATIC_LIBRARIES := \

    libbatterymonitor \

    libbootloader_message \

    libext4_utils_static \

    libsparse_static \

    libminzip \

LOCAL_STATIC_LIBRARIES := libcrypto_utils_static libcrypto_static

include $(BUILD_STATIC_LIBRARY)

include $(LOCAL_PATH)/minui/Android.mk \

    $(LOCAL_PATH)/minzip/Android.mk \

include \

    $(LOCAL_PATH)/applypatch/Android.mk \

    $(LOCAL_PATH)/bootloader_message/Android.mk \

    $(LOCAL_PATH)/edify/Android.mk \

    $(LOCAL_PATH)/minadbd/Android.mk \

    $(LOCAL_PATH)/minui/Android.mk \

    $(LOCAL_PATH)/minzip/Android.mk \

    $(LOCAL_PATH)/otafault/Android.mk \

    $(LOCAL_PATH)/tests/Android.mk \

    $(LOCAL_PATH)/tools/Android.mk \

    $(LOCAL_PATH)/edify/Android.mk \

    $(LOCAL_PATH)/uncrypt/Android.mk \

    $(LOCAL_PATH)/otafault/Android.mk \

    $(LOCAL_PATH)/updater/Android.mk \

    $(LOCAL_PATH)/update_verifier/Android.mk \

    $(LOCAL_PATH)/applypatch/Android.mk

/*

 * Copyright (C) 2008 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 <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <fs_mgr.h>

#include <android-base/file.h>

#include <android-base/unique_fd.h>

#include "bootloader.h"

#include "common.h"

#include "roots.h"

static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out);

static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in);

int get_bootloader_message(bootloader_message* out) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return -1;

    }

    if (strcmp(v->fs_type, "emmc") == 0) {

        std::string s;

        if (!read_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, sizeof(bootloader_message),

                                 &s)) {

            return -1;

        }

        memcpy(out, s.data(), s.size());

        return 0;

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return -1;

}

bool read_wipe_package(size_t size, std::string* out) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return false;

    }

    if (strcmp(v->fs_type, "mtd") == 0) {

        LOGE("Read wipe package on mtd is not supported.\n");

        return false;

    } else if (strcmp(v->fs_type, "emmc") == 0) {

        return read_misc_partition(v, WIPE_PACKAGE_OFFSET_IN_MISC, size, out);

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return false;

}

int set_bootloader_message(const bootloader_message* in) {

    Volume* v = volume_for_path("/misc");

    if (v == nullptr) {

        LOGE("Cannot load volume /misc!\n");

        return -1;

    }

    if (strcmp(v->fs_type, "emmc") == 0) {

        std::string s(reinterpret_cast<const char*>(in), sizeof(*in));

        bool success = write_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, s);

        return success ? 0 : -1;

    }

    LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);

    return -1;

}

// ------------------------------------

// for misc partitions on block devices

// ------------------------------------

static void wait_for_device(const char* fn) {

    int tries = 0;

    int ret;

    do {

        ++tries;

        struct stat buf;

        ret = stat(fn, &buf);

        if (ret == -1) {

            printf("failed to stat \"%s\" try %d: %s\n", fn, tries, strerror(errno));

            sleep(1);

        }

    } while (ret && tries < 10);

    if (ret) {

        printf("failed to stat \"%s\"\n", fn);

    }

}

static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out) {

    wait_for_device(v->blk_device);

    android::base::unique_fd fd(open(v->blk_device, O_RDONLY));

    if (fd == -1) {

        LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (lseek(fd, static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

        LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    out->resize(size);

    if (!android::base::ReadFully(fd, &(*out)[0], size)) {

        LOGE("Failed to read \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    return true;

}

static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in) {

    wait_for_device(v->blk_device);

    android::base::unique_fd fd(open(v->blk_device, O_WRONLY | O_SYNC));

    if (fd == -1) {

        LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (lseek(fd, static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

        LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (!android::base::WriteFully(fd, in.data(), in.size())) {

        LOGE("Failed to write \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    if (fsync(fd) == -1) {

        LOGE("Failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));

        return false;

    }

    return true;

}

 * limitations under the License.

 */

#ifndef _RECOVERY_BOOTLOADER_H

#define _RECOVERY_BOOTLOADER_H

#include <assert.h>

#include <stddef.h>

// Spaces used by misc partition are as below:

// 0   - 2K     For bootloader_message

// 2K  - 16K    Used by Vendor's bootloader (the 2K - 4K range may be optionally used

//              as bootloader_message_ab struct)

// 16K - 64K    Used by uncrypt and recovery to store wipe_package for A/B devices

// Note that these offsets are admitted by bootloader,recovery and uncrypt, so they

// are not configurable without changing all of them.

static const size_t BOOTLOADER_MESSAGE_OFFSET_IN_MISC = 0;

static const size_t WIPE_PACKAGE_OFFSET_IN_MISC = 16 * 1024;

/* Bootloader Message (2-KiB)

 *

 * This structure describes the content of a block in flash

 * that is used for recovery and the bootloader to talk to

 * each other.

 *

 * The command field is updated by linux when it wants to

 * reboot into recovery or to update radio or bootloader firmware.

 * It is also updated by the bootloader when firmware update

 * is complete (to boot into recovery for any final cleanup)

 *

 * The status field is written by the bootloader after the

 * completion of an "update-radio" or "update-hboot" command.

 *

 * The recovery field is only written by linux and used

 * for the system to send a message to recovery or the

 * other way around.

 *

 * The stage field is written by packages which restart themselves

 * multiple times, so that the UI can reflect which invocation of the

 * package it is.  If the value is of the format "#/#" (eg, "1/3"),

 * the UI will add a simple indicator of that status.

 *

 * We used to have slot_suffix field for A/B boot control metadata in

 * this struct, which gets unintentionally cleared by recovery or

 * uncrypt. Move it into struct bootloader_message_ab to avoid the

 * issue.

 */

struct bootloader_message {

    char command[32];

    char status[32];

    char recovery[768];

    // The 'recovery' field used to be 1024 bytes.  It has only ever

    // been used to store the recovery command line, so 768 bytes

    // should be plenty.  We carve off the last 256 bytes to store the

    // stage string (for multistage packages) and possible future

    // expansion.

    char stage[32];

    // The 'reserved' field used to be 224 bytes when it was initially

    // carved off from the 1024-byte recovery field. Bump it up to

    // 1184-byte so that the entire bootloader_message struct rounds up

    // to 2048-byte.

    char reserved[1184];

};

/**

 * We must be cautious when changing the bootloader_message struct size,

 * because A/B-specific fields may end up with different offsets.

 */

#if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus)

static_assert(sizeof(struct bootloader_message) == 2048,

              "struct bootloader_message size changes, which may break A/B devices");

#endif

/**

 * The A/B-specific bootloader message structure (4-KiB).

 *

 * We separate A/B boot control metadata from the regular bootloader

 * message struct and keep it here. Everything that's A/B-specific

 * stays after struct bootloader_message, which should be managed by

 * the A/B-bootloader or boot control HAL.

 *

 * The slot_suffix field is used for A/B implementations where the

 * bootloader does not set the androidboot.ro.boot.slot_suffix kernel

 * commandline parameter. This is used by fs_mgr to mount /system and

 * other partitions with the slotselect flag set in fstab. A/B

 * implementations are free to use all 32 bytes and may store private

 * data past the first NUL-byte in this field. It is encouraged, but

 * not mandatory, to use 'struct bootloader_control' described below.

 */

struct bootloader_message_ab {

    struct bootloader_message message;

    char slot_suffix[32];

    // Round up the entire struct to 4096-byte.

    char reserved[2016];

};

/**

 * Be cautious about the struct size change, in case we put anything post

 * bootloader_message_ab struct (b/29159185).

 */

#if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus)

static_assert(sizeof(struct bootloader_message_ab) == 4096,

              "struct bootloader_message_ab size changes");

#endif

#define BOOT_CTRL_MAGIC   0x42414342 /* Bootloader Control AB */

#define BOOT_CTRL_VERSION 1

struct slot_metadata {

    // Slot priority with 15 meaning highest priority, 1 lowest

    // priority and 0 the slot is unbootable.

    uint8_t priority : 4;

    // Number of times left attempting to boot this slot.

    uint8_t tries_remaining : 3;

    // 1 if this slot has booted successfully, 0 otherwise.

    uint8_t successful_boot : 1;

    // 1 if this slot is corrupted from a dm-verity corruption, 0

    // otherwise.

    uint8_t verity_corrupted : 1;

    // Reserved for further use.

    uint8_t reserved : 7;

} __attribute__((packed));

/* Bootloader Control AB

 *

 * This struct can be used to manage A/B metadata. It is designed to

 * be put in the 'slot_suffix' field of the 'bootloader_message'

 * structure described above. It is encouraged to use the

 * 'bootloader_control' structure to store the A/B metadata, but not

 * mandatory.

 */

struct bootloader_control {

    // NUL terminated active slot suffix.

    char slot_suffix[4];

    // Bootloader Control AB magic number (see BOOT_CTRL_MAGIC).

    uint32_t magic;

    // Version of struct being used (see BOOT_CTRL_VERSION).

    uint8_t version;

    // Number of slots being managed.

    uint8_t nb_slot : 3;

    // Number of times left attempting to boot recovery.

    uint8_t recovery_tries_remaining : 3;

    // Ensure 4-bytes alignment for slot_info field.

    uint8_t reserved0[2];

    // Per-slot information.  Up to 4 slots.

    struct slot_metadata slot_info[4];

    // Reserved for further use.

    uint8_t reserved1[8];

    // CRC32 of all 28 bytes preceding this field (little endian

    // format).

    uint32_t crc32_le;

} __attribute__((packed));

#if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus)

static_assert(sizeof(struct bootloader_control) ==

              sizeof(((struct bootloader_message_ab *)0)->slot_suffix),

              "struct bootloader_control has wrong size");

#endif

/* Read and write the bootloader command from the "misc" partition.

 * These return zero on success.

 */

int get_bootloader_message(struct bootloader_message *out);

int set_bootloader_message(const struct bootloader_message *in);

#ifdef __cplusplus

#include <string>

bool read_wipe_package(size_t size, std::string* out);

#endif

#endif

// TODO: Remove this file once we remove all places that include this file.

#include "bootloader_message/include/bootloader_message/bootloader_message.h"

# Copyright (C) 2016 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.

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_CLANG := true

LOCAL_SRC_FILES := bootloader_message.cpp

LOCAL_MODULE := libbootloader_message

LOCAL_STATIC_LIBRARIES := libbase libfs_mgr

LOCAL_C_INCLUDES := $(LOCAL_PATH)/include

LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include

include $(BUILD_STATIC_LIBRARY)

 * limitations under the License.

 */

#include <bootloader_message/bootloader_message.h>

#include <errno.h>

#include <fcntl.h>

#include <string.h>

#include <android-base/unique_fd.h>

#include <fs_mgr.h>

#include "bootloader.h"

static struct fstab* read_fstab(std::string* err) {

  // The fstab path is always "/fstab.${ro.hardware}".

  std::string fstab_path = "/fstab.";

  return record->blk_device;

}

static bool write_misc_partition(const void* p, size_t size, size_t misc_offset, std::string* err) {

// In recovery mode, recovery can get started and try to access the misc

// device before the kernel has actually created it.

static bool wait_for_device(const std::string& blk_device, std::string* err) {

  int tries = 0;

  int ret;

  err->clear();

  do {

    ++tries;

    struct stat buf;

    ret = stat(blk_device.c_str(), &buf);

    if (ret == -1) {

      *err += android::base::StringPrintf("failed to stat %s try %d: %s\n",

                                          blk_device.c_str(), tries, strerror(errno));

      sleep(1);

    }

  } while (ret && tries < 10);

  if (ret) {

    *err += android::base::StringPrintf("failed to stat %s\n", blk_device.c_str());

  }

  return ret == 0;

}

static bool read_misc_partition(void* p, size_t size, size_t offset, std::string* err) {

  std::string misc_blk_device = get_misc_blk_device(err);

  if (misc_blk_device.empty()) {

    return false;

  }

  if (!wait_for_device(misc_blk_device, err)) {

    return false;

  }

  android::base::unique_fd fd(open(misc_blk_device.c_str(), O_WRONLY | O_SYNC));

  if (fd.get() == -1) {

    *err = android::base::StringPrintf("failed to open %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

    *err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  if (!android::base::ReadFully(fd.get(), p, size)) {

    *err = android::base::StringPrintf("failed to read %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  }

  return true;

}

static bool write_misc_partition(const void* p, size_t size, size_t offset, std::string* err) {

  std::string misc_blk_device = get_misc_blk_device(err);

  if (misc_blk_device.empty()) {

    return false;

                                       strerror(errno));

    return false;

  }

  if (lseek(fd.get(), static_cast<off_t>(misc_offset), SEEK_SET) !=

      static_cast<off_t>(misc_offset)) {

  if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {

    *err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),

                                       strerror(errno));

    return false;

  return true;

}

static bool write_bootloader_message(const bootloader_message& boot, std::string* err) {

bool read_bootloader_message(bootloader_message* boot, std::string* err) {

  return read_misc_partition(boot, sizeof(*boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);

}

bool write_bootloader_message(const bootloader_message& boot, std::string* err) {

  return write_misc_partition(&boot, sizeof(boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);

}

  return write_bootloader_message(boot, err);

}

bool read_wipe_package(std::string* package_data, size_t size, std::string* err) {

  package_data->resize(size);

  return read_misc_partition(&(*package_data)[0], size, WIPE_PACKAGE_OFFSET_IN_MISC, err);

}

bool write_wipe_package(const std::string& package_data, std::string* err) {

  return write_misc_partition(package_data.data(), package_data.size(),

                              WIPE_PACKAGE_OFFSET_IN_MISC, err);