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

Commit af0e220f authored by Cody Schuffelen's avatar Cody Schuffelen
Browse files

Combine tcp_connect and socket_spec_connect. 

This will make it easier to add new types of transports by combining the
logic the adb server and adb daemon use to connect to things.

Bug:121166534
Test: adb connect against a cuttlefish instance over the shm proxy.
Change-Id: Ic7fc848c60a85eef968c3735838c87cb7fdaf38b
parent 6a462405

adb/client/adb_client.cpp

+12 −14
Original line number Diff line number Diff line
@@ -144,53 +144,51 @@ static int _adb_connect(const std::string& service, std::string* error) { 
    }



    std::string reason;

    int fd = socket_spec_connect(__adb_server_socket_spec, &reason);

    if (fd < 0) {

    unique_fd fd;

    if (!socket_spec_connect(&fd, __adb_server_socket_spec, nullptr, nullptr, &reason)) {

        *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 && switch_socket_transport(fd, error)) {

    if (memcmp(&service[0], "host", 4) != 0 && switch_socket_transport(fd.get(), error)) {

        return -1;

    }



    if (!SendProtocolString(fd, service)) {

    if (!SendProtocolString(fd.get(), service)) {

        *error = perror_str("write failure during connection");

        adb_close(fd);

        return -1;

    }



    if (!adb_status(fd, error)) {

        adb_close(fd);

    if (!adb_status(fd.get(), error)) {

        return -1;

    }



    D("_adb_connect: return fd %d", fd);

    return fd;

    D("_adb_connect: return fd %d", fd.get());

    return fd.release();

}



bool adb_kill_server() {

    D("adb_kill_server");

    std::string reason;

    int fd = socket_spec_connect(__adb_server_socket_spec, &reason);

    if (fd < 0) {

    unique_fd fd;

    if (!socket_spec_connect(&fd, __adb_server_socket_spec, nullptr, nullptr, &reason)) {

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

                reason.c_str());

        return true;

    }



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

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

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

        return false;

    }



    // The server might send OKAY, so consume that.

    char buf[4];

    ReadFdExactly(fd, buf, 4);

    ReadFdExactly(fd.get(), buf, 4);

    // Now that no more data is expected, wait for socket orderly shutdown or error, indicating

    // server death.

    ReadOrderlyShutdown(fd);

    ReadOrderlyShutdown(fd.get());

    return true;

}

adb/services.cpp

+4 −5
Original line number Diff line number Diff line
@@ -72,24 +72,23 @@ unique_fd create_service_thread(const char* service_name, std::function<void(uni 
}



int service_to_fd(std::string_view name, atransport* transport) {

    int ret = -1;

    unique_fd ret;



    if (is_socket_spec(name)) {

        std::string error;

        ret = socket_spec_connect(name, &error);

        if (ret < 0) {

        if (!socket_spec_connect(&ret, name, nullptr, nullptr, &error)) {

            LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;

        }

    } else {

#if !ADB_HOST

        ret = daemon_service_to_fd(name, transport).release();

        ret = daemon_service_to_fd(name, transport);

#endif

    }



    if (ret >= 0) {

        close_on_exec(ret);

    }

    return ret;

    return ret.release();

}



#if ADB_HOST

adb/socket_spec.cpp

+27 −22
Original line number Diff line number Diff line
@@ -67,7 +67,7 @@ static auto& kLocalSocketTypes = *new std::unordered_map<std::string, LocalSocke 
});



bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* port,

                           std::string* error) {

                           std::string* serial, std::string* error) {

    if (!spec.starts_with("tcp:")) {

        *error = "specification is not tcp: ";

        *error += spec;
@@ -92,7 +92,7 @@ bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* po 


        // FIXME: ParseNetAddress rejects port 0. This currently doesn't hurt, because listening

        //        on an address that isn't 'localhost' is unsupported.

        if (!android::base::ParseNetAddress(addr, &hostname_value, &port_value, nullptr, error)) {

        if (!android::base::ParseNetAddress(addr, &hostname_value, &port_value, serial, error)) {

            return false;

        }
@@ -139,63 +139,68 @@ bool is_local_socket_spec(std::string_view spec) { 


    std::string error;

    std::string hostname;

    if (!parse_tcp_socket_spec(spec, &hostname, nullptr, &error)) {

    if (!parse_tcp_socket_spec(spec, &hostname, nullptr, nullptr, &error)) {

        return false;

    }

    return tcp_host_is_local(hostname);

}



int socket_spec_connect(std::string_view spec, std::string* error) {

    if (spec.starts_with("tcp:")) {

bool socket_spec_connect(unique_fd* fd, std::string_view address, int* port, std::string* serial,

                         std::string* error) {

    if (address.starts_with("tcp:")) {

        std::string hostname;

        int port;

        if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {

            return -1;

        int port_value = port ? *port : 0;

        if (!parse_tcp_socket_spec(address, &hostname, &port_value, serial, error)) {

            return false;

        }



        int result;

        if (tcp_host_is_local(hostname)) {

            result = network_loopback_client(port, SOCK_STREAM, error);

            fd->reset(network_loopback_client(port_value, SOCK_STREAM, error));

        } else {

#if ADB_HOST

            result = network_connect(hostname, port, SOCK_STREAM, 0, error);

            fd->reset(network_connect(hostname, port_value, SOCK_STREAM, 0, error));

#else

            // Disallow arbitrary connections in adbd.

            *error = "adbd does not support arbitrary tcp connections";

            return -1;

            return false;

#endif

        }



        if (result >= 0) {

            disable_tcp_nagle(result);

        if (fd->get() > 0) {

            disable_tcp_nagle(fd->get());

            if (port) {

                *port = port_value;

            }

        return result;

            return true;

        }

        return false;

    }



    for (const auto& it : kLocalSocketTypes) {

        std::string prefix = it.first + ":";

        if (spec.starts_with(prefix)) {

        if (address.starts_with(prefix)) {

            if (!it.second.available) {

                *error = StringPrintf("socket type %s is unavailable on this platform",

                                      it.first.c_str());

                return -1;

                return false;

            }



            return network_local_client(&spec[prefix.length()], it.second.socket_namespace,

                                        SOCK_STREAM, error);

            fd->reset(network_local_client(&address[prefix.length()], it.second.socket_namespace,

                                           SOCK_STREAM, error));

            return true;

        }

    }



    *error = "unknown socket specification: ";

    *error += spec;

    return -1;

    *error += address;

    return false;

}



int socket_spec_listen(std::string_view spec, std::string* error, int* resolved_tcp_port) {

    if (spec.starts_with("tcp:")) {

        std::string hostname;

        int port;

        if (!parse_tcp_socket_spec(spec, &hostname, &port, error)) {

        if (!parse_tcp_socket_spec(spec, &hostname, &port, nullptr, error)) {

            return -1;

        }

adb/socket_spec.h

+6 −2
Original line number Diff line number Diff line
@@ -17,14 +17,18 @@ 
#pragma once



#include <string>

#include <tuple>



#include "adb_unique_fd.h"



// Returns true if the argument starts with a plausible socket prefix.

bool is_socket_spec(std::string_view spec);

bool is_local_socket_spec(std::string_view spec);



int socket_spec_connect(std::string_view spec, std::string* error);

bool socket_spec_connect(unique_fd* fd, std::string_view address, int* port, std::string* serial,

                         std::string* error);

int socket_spec_listen(std::string_view spec, std::string* error, int* resolved_tcp_port = nullptr);



// Exposed for testing.

bool parse_tcp_socket_spec(std::string_view spec, std::string* hostname, int* port,

                           std::string* error);
 
                           std::string* serial, std::string* error);

adb/socket_spec_test.cpp

+19 −16
Original line number Diff line number Diff line
@@ -21,34 +21,37 @@ 
#include <gtest/gtest.h>



TEST(socket_spec, parse_tcp_socket_spec) {

    std::string hostname, error;

    std::string hostname, error, serial;

    int port;

    EXPECT_TRUE(parse_tcp_socket_spec("tcp:5037", &hostname, &port, &error));

    EXPECT_TRUE(parse_tcp_socket_spec("tcp:5037", &hostname, &port, &serial, &error));

    EXPECT_EQ("", hostname);

    EXPECT_EQ(5037, port);

    EXPECT_EQ("", serial);



    // Bad ports:

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:-1", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:65536", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:-1", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:65536", &hostname, &port, &serial, &error));



    EXPECT_TRUE(parse_tcp_socket_spec("tcp:localhost:1234", &hostname, &port, &error));

    EXPECT_TRUE(parse_tcp_socket_spec("tcp:localhost:1234", &hostname, &port, &serial, &error));

    EXPECT_EQ("localhost", hostname);

    EXPECT_EQ(1234, port);

    EXPECT_EQ("localhost:1234", serial);



    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:-1", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:65536", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:-1", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:localhost:65536", &hostname, &port, &serial, &error));



    // IPv6:

    EXPECT_TRUE(parse_tcp_socket_spec("tcp:[::1]:1234", &hostname, &port, &error));

    EXPECT_TRUE(parse_tcp_socket_spec("tcp:[::1]:1234", &hostname, &port, &serial, &error));

    EXPECT_EQ("::1", hostname);

    EXPECT_EQ(1234, port);

    EXPECT_EQ("[::1]:1234", serial);



    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:-1", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1:1234", &hostname, &port, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:[::1]:-1", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1", &hostname, &port, &serial, &error));

    EXPECT_FALSE(parse_tcp_socket_spec("tcp:::1:1234", &hostname, &port, &serial, &error));

}