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

Commit 3aaea90b authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 4579913 from e9153c72 to pi-release 

Change-Id: I5bec263c1b535bebd559c3cb9f52a83708194814
parents fcd1b75f e9153c72

adb/Android.mk

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

adb_target_sanitize :=





ADB_COMMON_CFLAGS := \

ADB_COMMON_CFLAGS := \

    -frtti \

    -Wall -Wextra -Werror \

    -Wall -Wextra -Werror \

    -Wno-unused-parameter \

    -Wno-unused-parameter \

    -Wno-missing-field-initializers \

    -Wno-missing-field-initializers \

adb/adb.h

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

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 */

/* 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);

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

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

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

adb/services.cpp

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

        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.

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

    std::string error;

    std::string error;

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

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

adb/transport.cpp

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




#include "adb.h"

#include "adb.h"

#include "adb_auth.h"

#include "adb_auth.h"

#include "adb_io.h"

#include "adb_trace.h"

#include "adb_trace.h"

#include "adb_utils.h"

#include "adb_utils.h"

#include "diagnose_usb.h"

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

    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) {

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

    unsigned command = p->msg.command;

    unsigned command = p->msg.command;

    int len = p->msg.data_length;

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




        {

        {

            ATRACE_NAME("read_transport read_remote");

            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);

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

                put_apacket(p);

                put_apacket(p);

                break;

                break;

            }

            }



            if (!check_header(p, t)) {

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

                put_apacket(p);

                break;

            }



#if ADB_HOST

#if ADB_HOST

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

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

                put_apacket(p);

                continue;

                continue;

            }

            }

#endif

#endif
@@ -625,7 +664,7 @@ static void transport_unref(atransport* t) { 
    t->ref_count--;

    t->ref_count--;

    if (t->ref_count == 0) {

    if (t->ref_count == 0) {

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

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

        t->close(t);

        t->connection->Close();

        remove_transport(t);

        remove_transport(t);

    } else {

    } else {

        D("transport: %s unref (count=%zu)", t->serial, t->ref_count);

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

}





int atransport::Write(apacket* p) {

int atransport::Write(apacket* p) {

    return write_func_(p, this);

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

}

}





void atransport::Kick() {

void atransport::Kick() {

    if (!kicked_) {

    if (!kicked_) {

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

        kicked_ = true;

        kicked_ = true;

        CHECK(kick_func_ != nullptr);

        this->connection->Close();

        kick_func_(this);

    }

    }

}

}
@@ -1082,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.

// This should only be used for transports with connection_state == kCsNoPerm.

void unregister_usb_transport(usb_handle* usb) {

void unregister_usb_transport(usb_handle* usb) {

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

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

    transport_list.remove_if(

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

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

        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) {

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

adb/transport.h

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

#include <string>

#include <unordered_set>

#include <unordered_set>





#include "adb.h"



#include <openssl/rsa.h>

#include <openssl/rsa.h>





#include "adb.h"

#include "adb_unique_fd.h"



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

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





const FeatureSet& supported_features();

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




TransportId NextTransportId();

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 {

class atransport {

  public:

  public:

    // TODO(danalbert): We expose waaaaaaay too much stuff because this was

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

    }

    virtual ~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);

    int Write(apacket* p);

    void Kick();

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

    bool online = false;

    TransportType type = kTransportAny;

    TransportType type = kTransportAny;





    // USB handle or socket fd as needed.

    std::unique_ptr<Connection> connection;

    usb_handle* usb = nullptr;

    int sfd = -1;





    // Used to identify transports for clients.

    // Used to identify transports for clients.

    char* serial = nullptr;

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

    char* model = nullptr;

    char* device = nullptr;

    char* device = nullptr;

    char* devpath = 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 {

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

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

    }





#if ADB_HOST

#if ADB_HOST

    std::shared_ptr<RSA> NextKey();

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

    bool MatchesTarget(const std::string& target) const;





private:

private:

    int local_port_for_emulator_ = -1;

    bool kicked_ = false;

    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.

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

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

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