diff --git a/adb/adb_client.cpp b/adb/adb_client.cpp index db9b71087..d29c08e83 100644 --- a/adb/adb_client.cpp +++ b/adb/adb_client.cpp @@ -50,6 +50,15 @@ void adb_set_transport(TransportType type, const char* serial) __adb_serial = serial; } +void adb_get_transport(TransportType* type, const char** serial) { + if (type) { + *type = __adb_transport; + } + if (serial) { + *serial = __adb_serial; + } +} + void adb_set_tcp_specifics(int server_port) { __adb_server_port = server_port; diff --git a/adb/adb_client.h b/adb/adb_client.h index a9df4d7a6..d5cd9220a 100644 --- a/adb/adb_client.h +++ b/adb/adb_client.h @@ -39,6 +39,9 @@ bool adb_query(const std::string& service, std::string* _Nonnull result, // Set the preferred transport to connect to. void adb_set_transport(TransportType type, const char* _Nullable serial); +// Get the preferred transport to connect to. +void adb_get_transport(TransportType* _Nullable type, const char* _Nullable* _Nullable serial); + // Set TCP specifics of the transport to use. void adb_set_tcp_specifics(int server_port); diff --git a/adb/adb_utils.h b/adb/adb_utils.h index f1149b3d7..89fcd66ec 100644 --- a/adb/adb_utils.h +++ b/adb/adb_utils.h @@ -19,6 +19,8 @@ #include +#include + void close_stdin(); bool getcwd(std::string* cwd); @@ -39,4 +41,45 @@ std::string perror_str(const char* msg); bool set_file_block_mode(int fd, bool block); +extern int adb_close(int fd); + +// Helper to automatically close an FD when it goes out of scope. +class ScopedFd { + public: + ScopedFd() { + } + + ~ScopedFd() { + Reset(); + } + + void Reset(int fd = -1) { + if (fd != fd_) { + if (valid()) { + adb_close(fd_); + } + fd_ = fd; + } + } + + int Release() { + int temp = fd_; + fd_ = -1; + return temp; + } + + bool valid() const { + return fd_ >= 0; + } + + int fd() const { + return fd_; + } + + private: + int fd_ = -1; + + DISALLOW_COPY_AND_ASSIGN(ScopedFd); +}; + #endif diff --git a/adb/commandline.cpp b/adb/commandline.cpp index 37d114605..30a38e399 100644 --- a/adb/commandline.cpp +++ b/adb/commandline.cpp @@ -1072,6 +1072,51 @@ static bool wait_for_device(const char* service, TransportType t, const char* se return adb_command(cmd); } +static bool adb_root(const char* command) { + std::string error; + ScopedFd fd; + + fd.Reset(adb_connect(android::base::StringPrintf("%s:", command), &error)); + if (!fd.valid()) { + fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str()); + return false; + } + + // Figure out whether we actually did anything. + char buf[256]; + char* cur = buf; + ssize_t bytes_left = sizeof(buf); + while (bytes_left > 0) { + ssize_t bytes_read = adb_read(fd.fd(), cur, bytes_left); + if (bytes_read == 0) { + break; + } else if (bytes_read < 0) { + fprintf(stderr, "adb: error while reading for %s: %s\n", command, strerror(errno)); + return false; + } + cur += bytes_read; + bytes_left -= bytes_read; + } + + if (bytes_left == 0) { + fprintf(stderr, "adb: unexpected output length for %s\n", command); + return false; + } + + fflush(stdout); + WriteFdExactly(STDOUT_FILENO, buf, sizeof(buf) - bytes_left); + if (cur != buf && strstr(buf, "restarting") == nullptr) { + return true; + } + + // Give adbd 500ms to kill itself, then wait-for-device for it to come back up. + adb_sleep_ms(500); + TransportType type; + const char* serial; + adb_get_transport(&type, &serial); + return wait_for_device("wait-for-device", type, serial); +} + // Connects to the device "shell" service with |command| and prints the // resulting output. static int send_shell_command(TransportType transport_type, const char* serial, @@ -1220,6 +1265,9 @@ static int restore(int argc, const char** argv) { printf("Now unlock your device and confirm the restore operation.\n"); copy_to_file(tarFd, fd); + // Wait until the other side finishes, or it'll get sent SIGHUP. + copy_to_file(fd, STDOUT_FILENO); + adb_close(fd); adb_close(tarFd); return 0; @@ -1632,8 +1680,6 @@ int adb_commandline(int argc, const char **argv) { !strcmp(argv[0], "reboot") || !strcmp(argv[0], "reboot-bootloader") || !strcmp(argv[0], "usb") || - !strcmp(argv[0], "root") || - !strcmp(argv[0], "unroot") || !strcmp(argv[0], "disable-verity") || !strcmp(argv[0], "enable-verity")) { std::string command; @@ -1645,8 +1691,9 @@ int adb_commandline(int argc, const char **argv) { command = android::base::StringPrintf("%s:", argv[0]); } return adb_connect_command(command); - } - else if (!strcmp(argv[0], "bugreport")) { + } else if (!strcmp(argv[0], "root") || !strcmp(argv[0], "unroot")) { + return adb_root(argv[0]) ? 0 : 1; + } else if (!strcmp(argv[0], "bugreport")) { if (argc != 1) return usage(); // No need for shell protocol with bugreport, always disable for // simplicity. diff --git a/adb/shell_service.cpp b/adb/shell_service.cpp index 8ece28c03..ce107084c 100644 --- a/adb/shell_service.cpp +++ b/adb/shell_service.cpp @@ -135,37 +135,6 @@ std::string ReadAll(int fd) { return received; } -// Helper to automatically close an FD when it goes out of scope. -class ScopedFd { - public: - ScopedFd() {} - ~ScopedFd() { Reset(); } - - void Reset(int fd=-1) { - if (fd != fd_) { - if (valid()) { - adb_close(fd_); - } - fd_ = fd; - } - } - - int Release() { - int temp = fd_; - fd_ = -1; - return temp; - } - - bool valid() const { return fd_ >= 0; } - - int fd() const { return fd_; } - - private: - int fd_ = -1; - - DISALLOW_COPY_AND_ASSIGN(ScopedFd); -}; - // Creates a socketpair and saves the endpoints to |fd1| and |fd2|. bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) { int sockets[2]; diff --git a/adb/sysdeps.h b/adb/sysdeps.h index ce0f28932..81d201e65 100644 --- a/adb/sysdeps.h +++ b/adb/sysdeps.h @@ -576,8 +576,7 @@ static __inline__ int adb_shutdown(int fd, int direction) // Closes a file descriptor that came from adb_open() or adb_open_mode(), but // not designed to take a file descriptor from unix_open(). See the comments // for adb_open() for more info. -static __inline__ int adb_close(int fd) -{ +__inline__ int adb_close(int fd) { return close(fd); } #undef close