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

Commit b3c14ec6 authored by Josh Gao's avatar Josh Gao
Browse files

adb: make `adb kill-server` wait for the server to die. 

Make the host:kill service shutdown its socket on process exit, instead
of immediately. Also, unify the two 'kill-server' implementations and
hide _adb_connect.

Bug: http://b/37104408
Test: adb kill-server; adb start-server
Change-Id: I9475f5d084d5fb91d33e393f2fd4e34056613384
parent 707a6e46

adb/adb.cpp

+4 −7
Original line number Diff line number Diff line
@@ -1054,15 +1054,12 @@ int handle_host_request(const char* service, TransportType type, 
    if (strcmp(service, "kill") == 0) {

        fprintf(stderr, "adb server killed by remote request\n");

        fflush(stdout);

        SendOkay(reply_fd);



        // On Windows, if the process exits with open sockets that

        // shutdown(SD_SEND) has not been called on, TCP RST segments will be

        // sent to the peers which will cause their next recv() to error-out

        // with WSAECONNRESET. In the case of this code, that means the client

        // may not read the OKAY sent above.

        adb_shutdown(reply_fd);

        // Send a reply even though we don't read it anymore, so that old versions

        // of adb that do read it don't spew error messages.

        SendOkay(reply_fd);



        // Rely on process exit to close the socket for us.

        android::base::quick_exit(0);

    }

adb/adb_client.cpp

+21 −13
Original line number Diff line number Diff line
@@ -123,7 +123,7 @@ bool adb_status(int fd, std::string* error) { 
    return false;

}



int _adb_connect(const std::string& service, std::string* error) {

static int _adb_connect(const std::string& service, std::string* error) {

    D("_adb_connect: %s", service.c_str());

    if (service.empty() || service.size() > MAX_PAYLOAD_V1) {

        *error = android::base::StringPrintf("bad service name length (%zd)",
@@ -158,6 +158,25 @@ int _adb_connect(const std::string& service, std::string* error) { 
    return fd;

}



bool adb_kill_server() {

    D("adb_kill_server");

    std::string reason;

    int fd = socket_spec_connect(__adb_server_socket_spec, &reason);

    if (fd < 0) {

        fprintf(stderr, "cannot connect to daemon at %s: %s\n", __adb_server_socket_spec,

                reason.c_str());

        return true;

    }



    if (!SendProtocolString(fd, "host:kill")) {

        fprintf(stderr, "error: write failure during connection: %s\n", strerror(errno));

        return false;

    }



    ReadOrderlyShutdown(fd);

    return true;

}



int adb_connect(const std::string& service, std::string* error) {

    // first query the adb server's version

    int fd = _adb_connect("host:version", error);
@@ -214,18 +233,7 @@ int adb_connect(const std::string& service, std::string* error) { 
        if (version != ADB_SERVER_VERSION) {

            fprintf(stderr, "adb server version (%d) doesn't match this client (%d); killing...\n",

                    version, ADB_SERVER_VERSION);

            fd = _adb_connect("host:kill", error);

            if (fd >= 0) {

                ReadOrderlyShutdown(fd);

                adb_close(fd);

            } else {

                // If we couldn't connect to the server or had some other error,

                // report it, but still try to start the server.

                fprintf(stderr, "error: %s\n", error->c_str());

            }



            /* XXX can we better detect its death? */

            std::this_thread::sleep_for(2s);

            adb_kill_server();

            goto start_server;

        }

    }

adb/adb_client.h

+3 −1
Original line number Diff line number Diff line
@@ -26,7 +26,9 @@ 
// Connect to adb, connect to the named service, and return a valid fd for

// interacting with that service upon success or a negative number on failure.

int adb_connect(const std::string& service, std::string* _Nonnull error);

int _adb_connect(const std::string& service, std::string* _Nonnull error);



// Kill the currently running adb server, if it exists.

bool adb_kill_server();



// Connect to adb, connect to the named service, returns true if the connection

// succeeded AND the service returned OKAY. Outputs any returned error otherwise.

adb/commandline.cpp

+1 −19
Original line number Diff line number Diff line
@@ -1546,25 +1546,7 @@ int adb_commandline(int argc, const char** argv) { 
        return 0;

    }

    else if (!strcmp(argv[0], "kill-server")) {

        std::string error;

        int fd = _adb_connect("host:kill", &error);

        if (fd == -2) {

            // Failed to make network connection to server. Don't output the

            // network error since that is expected.

            fprintf(stderr,"* server not running *\n");

            // Successful exit code because the server is already "killed".

            return 0;

        } else if (fd == -1) {

            // Some other error.

            fprintf(stderr, "error: %s\n", error.c_str());

            return 1;

        } else {

            // Successfully connected, kill command sent, okay status came back.

            // Server should exit() in a moment, if not already.

            ReadOrderlyShutdown(fd);

            adb_close(fd);

            return 0;

        }

        return adb_kill_server() ? 0 : 1;

    }

    else if (!strcmp(argv[0], "sideload")) {

        if (argc != 2) return syntax_error("sideload requires an argument");