Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1cd680ce authored by Josh Gao's avatar Josh Gao Committed by Gerrit Code Review
Browse files

Merge changes I93514d22,I57dbc113,I707ffbd1 

* changes:
  adb: wait for restore to complete before returning.
  adb: wait for adbd to die and respawn in root/unroot.
  adb: make ScopedFd universally accessible and useful.
parents 3c608c74 d26abed7

adb/adb_client.cpp

+9 −0
Original line number Diff line number Diff line
@@ -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;

adb/adb_client.h

+3 −0
Original line number Diff line number Diff line
@@ -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);

adb/adb_utils.h

+43 −0
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ 


#include <string>



#include <android-base/macros.h>



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

adb/commandline.cpp

+51 −4
Original line number Diff line number Diff line
@@ -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.

adb/shell_service.cpp

+0 −31
Original line number Diff line number Diff line
@@ -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];