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

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

adb: extract atransport's connection interface. 

As step one of refactoring atransport to separate out protocol handling
from its underlying connection, extract atransport's existing
hand-rolled connection vtable out to its own abstract interface.

This should not change behavior except in one case: emulators are
now treated as TCP devices for the purposes of `adb disconnect`.

Test: python test_device.py, with walleye over USB + TCP
Test: manually connecting and disconnecting devices/emulators
Change-Id: I877b8027e567cc6a7461749432b49f6cb2c2f0d7
parent fb413a23

adb/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ adb_host_sanitize := 
adb_target_sanitize :=



ADB_COMMON_CFLAGS := \

    -frtti \

    -Wall -Wextra -Werror \

    -Wno-unused-parameter \

    -Wno-missing-field-initializers \

adb/adb.h

+0 −3
Original line number Diff line number Diff line
@@ -136,9 +136,6 @@ 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

int get_available_local_transport_index();

#endif

int init_socket_transport(atransport* t, int s, int port, int local);

void init_usb_transport(atransport* t, usb_handle* usb);

adb/services.cpp

+0 −8
Original line number Diff line number Diff line
@@ -407,14 +407,6 @@ void connect_emulator(const std::string& port_spec, std::string* response) { 
        return;

    }



    // Check if more emulators can be registered. Similar unproblematic

    // race condition as above.

    int candidate_slot = get_available_local_transport_index();

    if (candidate_slot < 0) {

        *response = "Cannot accept more emulators";

        return;

    }



    // Preconditions met, try to connect to the emulator.

    std::string error;

    if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {

adb/transport.cpp

+49 −7
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ 


#include "adb.h"

#include "adb_auth.h"

#include "adb_io.h"

#include "adb_trace.h"

#include "adb_utils.h"

#include "diagnose_usb.h"
@@ -65,6 +66,36 @@ TransportId NextTransportId() { 
    return next++;

}



bool FdConnection::Read(apacket* packet) {

    if (!ReadFdExactly(fd_.get(), &packet->msg, sizeof(amessage))) {

        D("remote local: read terminated (message)");

        return false;

    }



    if (!ReadFdExactly(fd_.get(), &packet->data, packet->msg.data_length)) {

        D("remote local: terminated (data)");

        return false;

    }



    return true;

}



bool FdConnection::Write(apacket* packet) {

    uint32_t length = packet->msg.data_length;



    if (!WriteFdExactly(fd_.get(), &packet->msg, sizeof(amessage) + length)) {

        D("remote local: write terminated");

        return false;

    }



    return true;

}



void FdConnection::Close() {

    adb_shutdown(fd_.get());

    fd_.reset();

}



static std::string dump_packet(const char* name, const char* func, apacket* p) {

    unsigned command = p->msg.command;

    int len = p->msg.data_length;
@@ -220,11 +251,18 @@ static void read_transport_thread(void* _t) { 


        {

            ATRACE_NAME("read_transport read_remote");

            if (t->read_from_remote(p, t) != 0) {

            if (!t->connection->Read(p)) {

                D("%s: remote read failed for transport", t->serial);

                put_apacket(p);

                break;

            }



            if (!check_header(p, t)) {

                D("%s: remote read: bad header", t->serial);

                put_apacket(p);

                break;

            }



#if ADB_HOST

            if (p->msg.command == 0) {

                put_apacket(p);
@@ -626,7 +664,7 @@ static void transport_unref(atransport* t) { 
    t->ref_count--;

    if (t->ref_count == 0) {

        D("transport: %s unref (kicking and closing)", t->serial);

        t->close(t);

        t->connection->Close();

        remove_transport(t);

    } else {

        D("transport: %s unref (count=%zu)", t->serial, t->ref_count);
@@ -754,14 +792,14 @@ atransport* acquire_one_transport(TransportType type, const char* serial, Transp 
}



int atransport::Write(apacket* p) {

    return write_func_(p, this);

    return this->connection->Write(p) ? 0 : -1;

}



void atransport::Kick() {

    if (!kicked_) {

        D("kicking transport %s", this->serial);

        kicked_ = true;

        CHECK(kick_func_ != nullptr);

        kick_func_(this);

        this->connection->Close();

    }

}
@@ -1083,8 +1121,12 @@ void register_usb_transport(usb_handle* usb, const char* serial, const char* dev 
// This should only be used for transports with connection_state == kCsNoPerm.

void unregister_usb_transport(usb_handle* usb) {

    std::lock_guard<std::recursive_mutex> lock(transport_lock);

    transport_list.remove_if(

        [usb](atransport* t) { return t->usb == usb && t->GetConnectionState() == kCsNoPerm; });

    transport_list.remove_if([usb](atransport* t) {

        if (auto connection = dynamic_cast<UsbConnection*>(t->connection.get())) {

            return connection->handle_ == usb && t->GetConnectionState() == kCsNoPerm;

        }

        return false;

    });

}



bool check_header(apacket* p, atransport* t) {

adb/transport.h

+49 −29
Original line number Diff line number Diff line
@@ -28,10 +28,11 @@ 
#include <string>

#include <unordered_set>



#include "adb.h"



#include <openssl/rsa.h>



#include "adb.h"

#include "adb_unique_fd.h"



typedef std::unordered_set<std::string> FeatureSet;



const FeatureSet& supported_features();
@@ -56,6 +57,50 @@ extern const char* const kFeaturePushSync; 


TransportId NextTransportId();



// Abstraction for a blocking packet transport.

struct Connection {

    Connection() = default;

    Connection(const Connection& copy) = delete;

    Connection(Connection&& move) = delete;



    // Destroy a Connection. Formerly known as 'Close' in atransport.

    virtual ~Connection() = default;



    // Read/Write a packet. These functions are concurrently called from a transport's reader/writer

    // threads.

    virtual bool Read(apacket* packet) = 0;

    virtual bool Write(apacket* packet) = 0;



    // Terminate a connection.

    // This method must be thread-safe, and must cause concurrent Reads/Writes to terminate.

    // Formerly known as 'Kick' in atransport.

    virtual void Close() = 0;

};



struct FdConnection : public Connection {

    explicit FdConnection(unique_fd fd) : fd_(std::move(fd)) {}



    bool Read(apacket* packet) override final;

    bool Write(apacket* packet) override final;



    void Close() override;



  private:

    unique_fd fd_;

};



struct UsbConnection : public Connection {

    explicit UsbConnection(usb_handle* handle) : handle_(handle) {}

    ~UsbConnection();



    bool Read(apacket* packet) override final;

    bool Write(apacket* packet) override final;



    void Close() override final;



    usb_handle* handle_;

};



class atransport {

  public:

    // TODO(danalbert): We expose waaaaaaay too much stuff because this was
@@ -73,12 +118,6 @@ class atransport { 
    }

    virtual ~atransport() {}



    int (*read_from_remote)(apacket* p, atransport* t) = nullptr;

    void (*close)(atransport* t) = nullptr;



    void SetWriteFunction(int (*write_func)(apacket*, atransport*)) { write_func_ = write_func; }

    void SetKickFunction(void (*kick_func)(atransport*)) { kick_func_ = kick_func; }

    bool IsKicked() { return kicked_; }

    int Write(apacket* p);

    void Kick();
@@ -95,9 +134,7 @@ class atransport { 
    bool online = false;

    TransportType type = kTransportAny;



    // USB handle or socket fd as needed.

    usb_handle* usb = nullptr;

    int sfd = -1;

    std::unique_ptr<Connection> connection;



    // Used to identify transports for clients.

    char* serial = nullptr;
@@ -105,22 +142,8 @@ class atransport { 
    char* model = nullptr;

    char* device = nullptr;

    char* devpath = nullptr;

    void SetLocalPortForEmulator(int port) {

        CHECK_EQ(local_port_for_emulator_, -1);

        local_port_for_emulator_ = port;

    }



    bool GetLocalPortForEmulator(int* port) const {

        if (type == kTransportLocal && local_port_for_emulator_ != -1) {

            *port = local_port_for_emulator_;

            return true;

        }

        return false;

    }



    bool IsTcpDevice() const {

        return type == kTransportLocal && local_port_for_emulator_ == -1;

    }

    bool IsTcpDevice() const { return type == kTransportLocal; }



#if ADB_HOST

    std::shared_ptr<RSA> NextKey();
@@ -165,10 +188,7 @@ class atransport { 
    bool MatchesTarget(const std::string& target) const;



private:

    int local_port_for_emulator_ = -1;

    bool kicked_ = false;

    void (*kick_func_)(atransport*) = nullptr;

    int (*write_func_)(apacket*, atransport*) = nullptr;



    // A set of features transmitted in the banner with the initial connection.

    // This is stored in the banner as 'features=feature0,feature1,etc'.