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

Commit 1f5a49f7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes from topic 'adb_cmd_socket' 

* changes:
  adb: allow use of arbitrary socket specs for command socket.
  adb: extract the adb-specific unique_fd out into its own header.
  adb: add helper to get the ~/.android directory.
parents f3d43032 9c869b58

adb/adb.cpp

+5 −8
Original line number Diff line number Diff line
@@ -611,8 +611,7 @@ static unsigned __stdcall _redirect_stderr_thread(HANDLE h) { 


#endif



int launch_server(int server_port)

{

int launch_server(const std::string& socket_spec) {

#if defined(_WIN32)

    /* we need to start the server in the background                    */

    /* we create a PIPE that will be used to wait for the server's "OK" */
@@ -715,9 +714,8 @@ int launch_server(int server_port) 
    }



    WCHAR   args[64];

    snwprintf(args, arraysize(args),

              L"adb -P %d fork-server server --reply-fd %d", server_port,

              ack_write_as_int);

    snwprintf(args, arraysize(args), L"adb -L %s fork-server server --reply-fd %d",

              socket_spec.c_str(), ack_write_as_int);



    PROCESS_INFORMATION   pinfo;

    ZeroMemory(&pinfo, sizeof(pinfo));
@@ -862,12 +860,11 @@ int launch_server(int server_port) 


        adb_close(fd[0]);



        char str_port[30];

        snprintf(str_port, sizeof(str_port), "%d", server_port);

        char reply_fd[30];

        snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]);

        // child process

        int result = execl(path.c_str(), "adb", "-P", str_port, "fork-server", "server", "--reply-fd", reply_fd, NULL);

        int result = execl(path.c_str(), "adb", "-L", socket_spec.c_str(), "fork-server", "server",

                           "--reply-fd", reply_fd, NULL);

        // this should not return

        fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);

    } else  {

adb/adb.h

+2 −2
Original line number Diff line number Diff line
@@ -126,8 +126,8 @@ void fatal_errno(const char* fmt, ...) __attribute__((noreturn, format(__printf_ 


void handle_packet(apacket *p, atransport *t);



int launch_server(int server_port);

int adb_server_main(int is_daemon, int server_port, int ack_reply_fd);

int launch_server(const std::string& socket_spec);

int adb_server_main(int is_daemon, const std::string& socket_spec, int ack_reply_fd);



/* initialize a transport object's func pointers and state */

#if ADB_HOST

adb/adb_auth_host.cpp

+1 −15
Original line number Diff line number Diff line
@@ -246,21 +246,7 @@ static bool read_keys(const std::string& path, bool allow_dir = true) { 
}



static std::string get_user_key_path() {

    const std::string home = adb_get_homedir_path(true);

    LOG(DEBUG) << "adb_get_homedir_path returned '" << home << "'";



    const std::string android_dir = android::base::StringPrintf("%s%c.android", home.c_str(),

                                                                OS_PATH_SEPARATOR);



    struct stat buf;

    if (stat(android_dir.c_str(), &buf) == -1) {

        if (adb_mkdir(android_dir.c_str(), 0750) == -1) {

            PLOG(ERROR) << "Cannot mkdir '" << android_dir << "'";

            return "";

        }

    }



    return android_dir + OS_PATH_SEPARATOR + "adbkey";

    return adb_get_android_dir_path() + OS_PATH_SEPARATOR + "adbkey";

}



static bool get_user_key() {

adb/adb_client.cpp

+15 −30
Original line number Diff line number Diff line
@@ -37,12 +37,12 @@ 


#include "adb_io.h"

#include "adb_utils.h"

#include "socket_spec.h"



static TransportType __adb_transport = kTransportAny;

static const char* __adb_serial = NULL;



static int __adb_server_port = DEFAULT_ADB_PORT;

static const char* __adb_server_name = NULL;

static const char* __adb_server_socket_spec;



void adb_set_transport(TransportType type, const char* serial)

{
@@ -59,14 +59,11 @@ void adb_get_transport(TransportType* type, const char** serial) { 
    }

}



void adb_set_tcp_specifics(int server_port)

{

    __adb_server_port = server_port;

void adb_set_socket_spec(const char* socket_spec) {

    if (!__adb_server_socket_spec) {

        LOG(FATAL) << "attempted to reinitialize adb_server_socket_spec";

    }



void adb_set_tcp_name(const char* hostname)

{

    __adb_server_name = hostname;

    __adb_server_socket_spec = socket_spec;

}



static int switch_socket_transport(int fd, std::string* error) {
@@ -139,24 +136,13 @@ int _adb_connect(const std::string& service, std::string* error) { 
        return -1;

    }



    int fd;

    std::string reason;

    if (__adb_server_name) {

        fd = network_connect(__adb_server_name, __adb_server_port, SOCK_STREAM, 0, &reason);

        if (fd == -1) {

            *error = android::base::StringPrintf("can't connect to %s:%d: %s",

                                                 __adb_server_name, __adb_server_port,

                                                 reason.c_str());

            return -2;

        }

    } else {

        fd = network_loopback_client(__adb_server_port, SOCK_STREAM, &reason);

        if (fd == -1) {

            *error = android::base::StringPrintf("cannot connect to daemon: %s",

                                                 reason.c_str());

    int fd = socket_spec_connect(__adb_server_socket_spec, &reason);

    if (fd < 0) {

        *error = android::base::StringPrintf("cannot connect to daemon at %s: %s",

                                             __adb_server_socket_spec, reason.c_str());

        return -2;

    }

    }



    if ((memcmp(&service[0],"host",4) != 0 || service == "host:reconnect") &&

        switch_socket_transport(fd, error)) {
@@ -185,15 +171,14 @@ int adb_connect(const std::string& service, std::string* error) { 
    int fd = _adb_connect("host:version", error);



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

    if (fd == -2 && __adb_server_name) {

    if (fd == -2 && !is_local_socket_spec(__adb_server_socket_spec)) {

        fprintf(stderr,"** Cannot start server on remote host\n");

        // error is the original network connection error

        return fd;

    } else if (fd == -2) {

        fprintf(stdout,"* daemon not running. starting it now on port %d *\n",

                __adb_server_port);

        fprintf(stdout, "* daemon not running. starting it now at %s *\n", __adb_server_socket_spec);

    start_server:

        if (launch_server(__adb_server_port)) {

        if (launch_server(__adb_server_socket_spec)) {

            fprintf(stderr,"* failed to start daemon *\n");

            // launch_server() has already printed detailed error info, so just

            // return a generic error string about the overall adb_connect()

adb/adb_client.h

+3 −5
Original line number Diff line number Diff line
@@ -43,11 +43,9 @@ 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);



// Set TCP Hostname of the transport to use.

void adb_set_tcp_name(const char* _Nullable hostname);

// Set the socket specification for the adb server.

// This function can only be called once, and the argument must live to the end of the process.

void adb_set_socket_spec(const char* _Nonnull socket_spec);



// Send commands to the current emulator instance. Will fail if there is not

// exactly one emulator connected (or if you use -s <serial> with a <serial>