From ffdec180176094dac0fb902263370dea1deb138f Mon Sep 17 00:00:00 2001 From: Elliott Hughes Date: Fri, 23 Sep 2016 15:40:03 -0700 Subject: [PATCH] Switch adb to . Bug: http://b/23102347 Test: manual Change-Id: Iffa66258c01f84f41b9af99ab5e768a0a2669106 --- adb/adb.cpp | 10 ++- adb/adb_trace.cpp | 12 +--- adb/daemon/main.cpp | 34 ++++------ adb/remount_service.cpp | 20 ++---- adb/services.cpp | 29 +++----- adb/set_verity_enable_state_service.cpp | 89 +++++++++++-------------- adb/sockets.cpp | 8 +-- adb/transport_local.cpp | 14 ++-- adb/usb_linux_client.cpp | 4 +- 9 files changed, 85 insertions(+), 135 deletions(-) diff --git a/adb/adb.cpp b/adb/adb.cpp index 056dbef4d..9ae3f1c26 100644 --- a/adb/adb.cpp +++ b/adb/adb.cpp @@ -48,9 +48,9 @@ #include "transport.h" #if !ADB_HOST -#include #include #include +#include #endif std::string adb_version() { @@ -200,11 +200,9 @@ std::string get_connection_string() { "ro.product.device", }; - for (const auto& prop_name : cnxn_props) { - char value[PROPERTY_VALUE_MAX]; - property_get(prop_name, value, ""); - connection_properties.push_back( - android::base::StringPrintf("%s=%s", prop_name, value)); + for (const auto& prop : cnxn_props) { + std::string value = std::string(prop) + "=" + android::base::GetProperty(prop, ""); + connection_properties.push_back(value); } #endif diff --git a/adb/adb_trace.cpp b/adb/adb_trace.cpp index 62900c0bf..369dec963 100644 --- a/adb/adb_trace.cpp +++ b/adb/adb_trace.cpp @@ -27,7 +27,7 @@ #include "adb.h" #if !ADB_HOST -#include +#include #endif #if !ADB_HOST @@ -88,19 +88,11 @@ std::string get_trace_setting_from_env() { return std::string(setting); } -#if !ADB_HOST -std::string get_trace_setting_from_prop() { - char buf[PROPERTY_VALUE_MAX]; - property_get("persist.adb.trace_mask", buf, ""); - return std::string(buf); -} -#endif - std::string get_trace_setting() { #if ADB_HOST return get_trace_setting_from_env(); #else - return get_trace_setting_from_prop(); + return android::base::GetProperty("persist.adb.trace_mask", ""); #endif } diff --git a/adb/daemon/main.cpp b/adb/daemon/main.cpp index b54243e22..094988a99 100644 --- a/adb/daemon/main.cpp +++ b/adb/daemon/main.cpp @@ -29,11 +29,11 @@ #include #include +#include #include #include #include -#include "cutils/properties.h" #include "debuggerd/client.h" #include "private/android_filesystem_config.h" #include "selinux/android.h" @@ -48,9 +48,7 @@ static const char* root_seclabel = nullptr; static void drop_capabilities_bounding_set_if_needed(struct minijail *j) { #if defined(ALLOW_ADBD_ROOT) - char value[PROPERTY_VALUE_MAX]; - property_get("ro.debuggable", value, ""); - if (strcmp(value, "1") == 0) { + if (android::base::GetBoolProperty("ro.debuggable", false)) { return; } #endif @@ -59,8 +57,6 @@ static void drop_capabilities_bounding_set_if_needed(struct minijail *j) { static bool should_drop_privileges() { #if defined(ALLOW_ADBD_ROOT) - char value[PROPERTY_VALUE_MAX]; - // The properties that affect `adb root` and `adb unroot` are ro.secure and // ro.debuggable. In this context the names don't make the expected behavior // particularly obvious. @@ -71,24 +67,19 @@ static bool should_drop_privileges() { // // ro.secure: // Drop privileges by default. Set to 1 on userdebug and user builds. - property_get("ro.secure", value, "1"); - bool ro_secure = (strcmp(value, "1") == 0); - - property_get("ro.debuggable", value, ""); - bool ro_debuggable = (strcmp(value, "1") == 0); + bool ro_secure = android::base::GetBoolProperty("ro.secure", true); + bool ro_debuggable = android::base::GetBoolProperty("ro.debuggable", false); // Drop privileges if ro.secure is set... bool drop = ro_secure; - property_get("service.adb.root", value, ""); - bool adb_root = (strcmp(value, "1") == 0); - bool adb_unroot = (strcmp(value, "0") == 0); - // ... except "adb root" lets you keep privileges in a debuggable build. + std::string prop = android::base::GetProperty("service.adb.root", ""); + bool adb_root = (prop == "1"); + bool adb_unroot = (prop == "0"); if (ro_debuggable && adb_root) { drop = false; } - // ... and "adb unroot" lets you explicitly drop privileges. if (adb_unroot) { drop = true; @@ -159,7 +150,7 @@ int adbd_main(int server_port) { // descriptor will always be open. adbd_cloexec_auth_socket(); - if (ALLOW_ADBD_NO_AUTH && property_get_bool("ro.adb.secure", 0) == 0) { + if (ALLOW_ADBD_NO_AUTH && !android::base::GetBoolProperty("ro.adb.secure", false)) { auth_required = false; } @@ -187,14 +178,13 @@ int adbd_main(int server_port) { // If one of these properties is set, also listen on that port. // If one of the properties isn't set and we couldn't listen on usb, listen // on the default port. - char prop_port[PROPERTY_VALUE_MAX]; - property_get("service.adb.tcp.port", prop_port, ""); - if (prop_port[0] == '\0') { - property_get("persist.adb.tcp.port", prop_port, ""); + std::string prop_port = android::base::GetProperty("service.adb.tcp.port", ""); + if (prop_port.empty()) { + prop_port = android::base::GetProperty("persist.adb.tcp.port", ""); } int port; - if (sscanf(prop_port, "%d", &port) == 1 && port > 0) { + if (sscanf(prop_port.c_str(), "%d", &port) == 1 && port > 0) { D("using port=%d", port); // Listen on TCP port specified by service.adb.tcp.port property. local_init(port); diff --git a/adb/remount_service.cpp b/adb/remount_service.cpp index 8f1c9b015..5ca73cc27 100644 --- a/adb/remount_service.cpp +++ b/adb/remount_service.cpp @@ -29,10 +29,11 @@ #include +#include + #include "adb.h" #include "adb_io.h" #include "adb_utils.h" -#include "cutils/properties.h" #include "fs_mgr.h" // Returns the device used to mount a directory in /proc/mounts. @@ -53,10 +54,7 @@ static std::string find_proc_mount(const char* dir) { // Returns the device used to mount a directory in the fstab. static std::string find_fstab_mount(const char* dir) { - char propbuf[PROPERTY_VALUE_MAX]; - - property_get("ro.hardware", propbuf, ""); - std::string fstab_filename = std::string("/fstab.") + propbuf; + std::string fstab_filename = "/fstab." + android::base::GetProperty("ro.hardware", ""); struct fstab* fstab = fs_mgr_read_fstab(fstab_filename.c_str()); struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, dir); std::string dev = rec ? std::string(rec->blk_device) : ""; @@ -113,12 +111,8 @@ void remount_service(int fd, void* cookie) { return; } - char prop_buf[PROPERTY_VALUE_MAX]; - property_get("partition.system.verified", prop_buf, ""); - bool system_verified = (strlen(prop_buf) > 0); - - property_get("partition.vendor.verified", prop_buf, ""); - bool vendor_verified = (strlen(prop_buf) > 0); + bool system_verified = !(android::base::GetProperty("partition.system.verified", "").empty()); + bool vendor_verified = !(android::base::GetProperty("partition.vendor.verified", "").empty()); if (system_verified || vendor_verified) { // Allow remount but warn of likely bad effects @@ -136,9 +130,7 @@ void remount_service(int fd, void* cookie) { } bool success = true; - property_get("ro.build.system_root_image", prop_buf, ""); - bool system_root = !strcmp(prop_buf, "true"); - if (system_root) { + if (android::base::GetBoolProperty("ro.build.system_root_image", false)) { success &= remount_partition(fd, "/"); } else { success &= remount_partition(fd, "/system"); diff --git a/adb/services.cpp b/adb/services.cpp index 2207a3eaf..0c3dd00f9 100644 --- a/adb/services.cpp +++ b/adb/services.cpp @@ -39,7 +39,7 @@ #if !ADB_HOST #include "cutils/android_reboot.h" -#include "cutils/properties.h" +#include #endif #include "adb.h" @@ -73,15 +73,13 @@ void restart_root_service(int fd, void *cookie) { WriteFdExactly(fd, "adbd is already running as root\n"); adb_close(fd); } else { - char value[PROPERTY_VALUE_MAX]; - property_get("ro.debuggable", value, ""); - if (strcmp(value, "1") != 0) { + if (!android::base::GetBoolProperty("ro.debuggable", false)) { WriteFdExactly(fd, "adbd cannot run as root in production builds\n"); adb_close(fd); return; } - property_set("service.adb.root", "1"); + android::base::SetProperty("service.adb.root", "1"); WriteFdExactly(fd, "restarting adbd as root\n"); adb_close(fd); } @@ -92,7 +90,7 @@ void restart_unroot_service(int fd, void *cookie) { WriteFdExactly(fd, "adbd not running as root\n"); adb_close(fd); } else { - property_set("service.adb.root", "0"); + android::base::SetProperty("service.adb.root", "0"); WriteFdExactly(fd, "restarting adbd as non root\n"); adb_close(fd); } @@ -106,15 +104,13 @@ void restart_tcp_service(int fd, void *cookie) { return; } - char value[PROPERTY_VALUE_MAX]; - snprintf(value, sizeof(value), "%d", port); - property_set("service.adb.tcp.port", value); + android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port)); WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port); adb_close(fd); } void restart_usb_service(int fd, void *cookie) { - property_set("service.adb.tcp.port", "0"); + android::base::SetProperty("service.adb.tcp.port", "0"); WriteFdExactly(fd, "restarting in USB mode\n"); adb_close(fd); } @@ -155,16 +151,9 @@ static bool reboot_service_impl(int fd, const char* arg) { sync(); - char property_val[PROPERTY_VALUE_MAX]; - int ret = snprintf(property_val, sizeof(property_val), "reboot,%s", reboot_arg); - if (ret >= static_cast(sizeof(property_val))) { - WriteFdFmt(fd, "reboot string too long: %d\n", ret); - return false; - } - - ret = property_set(ANDROID_RB_PROPERTY, property_val); - if (ret < 0) { - WriteFdFmt(fd, "reboot failed: %d\n", ret); + std::string reboot_string = android::base::StringPrintf("reboot,%s", reboot_arg); + if (!android::base::SetProperty(ANDROID_RB_PROPERTY, reboot_string)) { + WriteFdFmt(fd, "reboot (%s) failed\n", reboot_string.c_str()); return false; } diff --git a/adb/set_verity_enable_state_service.cpp b/adb/set_verity_enable_state_service.cpp index f5188e94f..ae628e4bd 100644 --- a/adb/set_verity_enable_state_service.cpp +++ b/adb/set_verity_enable_state_service.cpp @@ -24,16 +24,17 @@ #include #include -#include "cutils/properties.h" +#include "android-base/properties.h" +#include "android-base/stringprintf.h" #include "adb.h" #include "adb_io.h" +#include "adb_unique_fd.h" #include "fs_mgr.h" #include "remount_service.h" #include "fec/io.h" -#define FSTAB_PREFIX "/fstab." struct fstab *fstab; #ifdef ALLOW_ADBD_DISABLE_VERITY @@ -88,56 +89,46 @@ static int set_verity_enabled_state(int fd, const char *block_device, return 0; } -void set_verity_enabled_state_service(int fd, void* cookie) -{ +void set_verity_enabled_state_service(int fd, void* cookie) { + unique_fd closer(fd); + bool enable = (cookie != NULL); - if (kAllowDisableVerity) { - char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)]; - char propbuf[PROPERTY_VALUE_MAX]; - int i; - bool any_changed = false; - - property_get("ro.secure", propbuf, "0"); - if (strcmp(propbuf, "1")) { - WriteFdFmt(fd, "verity not enabled - ENG build\n"); - goto errout; - } - - property_get("ro.debuggable", propbuf, "0"); - if (strcmp(propbuf, "1")) { - WriteFdFmt(fd, "verity cannot be disabled/enabled - USER build\n"); - goto errout; - } - - property_get("ro.hardware", propbuf, ""); - snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX"%s", - propbuf); - - fstab = fs_mgr_read_fstab(fstab_filename); - if (!fstab) { - WriteFdFmt(fd, "Failed to open %s\nMaybe run adb root?\n", fstab_filename); - goto errout; - } - - /* Loop through entries looking for ones that vold manages */ - for (i = 0; i < fstab->num_entries; i++) { - if(fs_mgr_is_verified(&fstab->recs[i])) { - if (!set_verity_enabled_state(fd, fstab->recs[i].blk_device, - fstab->recs[i].mount_point, - enable)) { - any_changed = true; - } - } - } - - if (any_changed) { - WriteFdFmt(fd, "Now reboot your device for settings to take effect\n"); - } - } else { + if (!kAllowDisableVerity) { WriteFdFmt(fd, "%s-verity only works for userdebug builds\n", enable ? "enable" : "disable"); } -errout: - adb_close(fd); + if (!android::base::GetBoolProperty("ro.secure", false)) { + WriteFdFmt(fd, "verity not enabled - ENG build\n"); + return; + } + + if (!android::base::GetBoolProperty("ro.debuggable", false)) { + WriteFdFmt(fd, "verity cannot be disabled/enabled - USER build\n"); + return; + } + + std::string fstab_filename = "/fstab." + android::base::GetProperty("ro.hardware", ""); + + fstab = fs_mgr_read_fstab(fstab_filename.c_str()); + if (!fstab) { + WriteFdFmt(fd, "Failed to open %s\nMaybe run adb root?\n", fstab_filename.c_str()); + return; + } + + // Loop through entries looking for ones that vold manages. + bool any_changed = false; + for (int i = 0; i < fstab->num_entries; i++) { + if (fs_mgr_is_verified(&fstab->recs[i])) { + if (!set_verity_enabled_state(fd, fstab->recs[i].blk_device, + fstab->recs[i].mount_point, + enable)) { + any_changed = true; + } + } + } + + if (any_changed) { + WriteFdFmt(fd, "Now reboot your device for settings to take effect\n"); + } } diff --git a/adb/sockets.cpp b/adb/sockets.cpp index abba7452b..503e018d1 100644 --- a/adb/sockets.cpp +++ b/adb/sockets.cpp @@ -31,7 +31,7 @@ #include #if !ADB_HOST -#include "cutils/properties.h" +#include #endif #include "adb.h" @@ -416,12 +416,12 @@ asocket* create_local_service_socket(const char* name, const atransport* transpo D("LS(%d): bound to '%s' via %d", s->id, name, fd); #if !ADB_HOST - char debug[PROPERTY_VALUE_MAX]; + bool debuggable = false; if (!strncmp(name, "root:", 5)) { - property_get("ro.debuggable", debug, ""); + debuggable = android::base::GetBoolProperty("ro.debuggable", false); } - if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0) || + if ((!strncmp(name, "root:", 5) && getuid() != 0 && debuggable) || (!strncmp(name, "unroot:", 7) && getuid() == 0) || !strncmp(name, "usb:", 4) || !strncmp(name, "tcpip:", 6)) { diff --git a/adb/transport_local.cpp b/adb/transport_local.cpp index f8959439b..a94b41efa 100644 --- a/adb/transport_local.cpp +++ b/adb/transport_local.cpp @@ -33,7 +33,7 @@ #include #if !ADB_HOST -#include "cutils/properties.h" +#include #endif #include "adb.h" @@ -356,15 +356,13 @@ void local_init(int port) func = client_socket_thread; debug_name = "client"; #else - /* For the adbd daemon in the system image we need to distinguish - * between the device, and the emulator. */ - char is_qemu[PROPERTY_VALUE_MAX]; - property_get("ro.kernel.qemu", is_qemu, ""); - if (!strcmp(is_qemu, "1")) { - /* Running inside the emulator: use QEMUD pipe as the transport. */ + // For the adbd daemon in the system image we need to distinguish + // between the device, and the emulator. + if (android::base::GetBoolProperty("ro.kernel.qemu", false)) { + // Running inside the emulator: use QEMUD pipe as the transport. func = qemu_socket_thread; } else { - /* Running inside the device: use TCP socket as the transport. */ + // Running inside the device: use TCP socket as the transport. func = server_socket_thread; } debug_name = "server"; diff --git a/adb/usb_linux_client.cpp b/adb/usb_linux_client.cpp index 1b054394e..6de10f53e 100644 --- a/adb/usb_linux_client.cpp +++ b/adb/usb_linux_client.cpp @@ -18,7 +18,6 @@ #include "sysdeps.h" -#include #include #include #include @@ -36,6 +35,7 @@ #include #include +#include #include "adb.h" #include "transport.h" @@ -478,7 +478,7 @@ static void usb_ffs_open_thread(void* x) { } adb_sleep_ms(1000); } - property_set("sys.usb.ffs.ready", "1"); + android::base::SetProperty("sys.usb.ffs.ready", "1"); D("[ usb_thread - registering device ]"); register_usb_transport(usb, 0, 0, 1);