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

Commit 7a3f8d66 authored by Yabin Cui's avatar Yabin Cui
Browse files

adb: clean up debug tracing a little. 

Always use LOG() for debug tracing.
Remove useless D_lock. I believe it is useless to lock just before and after fprintf.

I verified the log output both on host and on device. The output looks fine to me.

Change-Id: I96ccfe408ff56864361551afe9ad464d197ae104
parent 03bbd64a

adb/adb.cpp

+18 −20
Original line number Diff line number Diff line
@@ -53,8 +53,6 @@ 
#include <sys/mount.h>

#endif



ADB_MUTEX_DEFINE(D_lock);



#if !ADB_HOST

const char* adb_device_banner = "device";

static android::base::LogdLogger gLogdLogger;
@@ -184,7 +182,7 @@ static void setup_trace_mask() { 
    for (const auto& elem : elements) {

        const auto& flag = trace_flags.find(elem);

        if (flag == trace_flags.end()) {

            D("Unknown trace flag: %s\n", flag->first.c_str());

            D("Unknown trace flag: %s", flag->first.c_str());

            continue;

        }
@@ -234,13 +232,13 @@ void put_apacket(apacket *p) 


void handle_online(atransport *t)

{

    D("adb: online\n");

    D("adb: online");

    t->online = 1;

}



void handle_offline(atransport *t)

{

    D("adb: offline\n");

    D("adb: offline");

    //Close the associated usb

    t->online = 0;
@@ -294,7 +292,7 @@ void print_packet(const char *label, apacket *p) 


static void send_ready(unsigned local, unsigned remote, atransport *t)

{

    D("Calling send_ready \n");

    D("Calling send_ready");

    apacket *p = get_apacket();

    p->msg.command = A_OKAY;

    p->msg.arg0 = local;
@@ -304,7 +302,7 @@ static void send_ready(unsigned local, unsigned remote, atransport *t) 


static void send_close(unsigned local, unsigned remote, atransport *t)

{

    D("Calling send_close \n");

    D("Calling send_close");

    apacket *p = get_apacket();

    p->msg.command = A_CLSE;

    p->msg.arg0 = local;
@@ -339,7 +337,7 @@ std::string get_connection_string() { 
}



void send_connect(atransport* t) {

    D("Calling send_connect \n");

    D("Calling send_connect");

    apacket* cp = get_apacket();

    cp->msg.command = A_CNXN;

    cp->msg.arg0 = t->get_protocol_version();
@@ -369,7 +367,7 @@ static void qual_overwrite(char** dst, const std::string& src) { 
}



void parse_banner(const std::string& banner, atransport* t) {

    D("parse_banner: %s\n", banner.c_str());

    D("parse_banner: %s", banner.c_str());



    // The format is something like:

    // "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;".
@@ -402,23 +400,23 @@ void parse_banner(const std::string& banner, atransport* t) { 


    const std::string& type = pieces[0];

    if (type == "bootloader") {

        D("setting connection_state to kCsBootloader\n");

        D("setting connection_state to kCsBootloader");

        t->connection_state = kCsBootloader;

        update_transports();

    } else if (type == "device") {

        D("setting connection_state to kCsDevice\n");

        D("setting connection_state to kCsDevice");

        t->connection_state = kCsDevice;

        update_transports();

    } else if (type == "recovery") {

        D("setting connection_state to kCsRecovery\n");

        D("setting connection_state to kCsRecovery");

        t->connection_state = kCsRecovery;

        update_transports();

    } else if (type == "sideload") {

        D("setting connection_state to kCsSideload\n");

        D("setting connection_state to kCsSideload");

        t->connection_state = kCsSideload;

        update_transports();

    } else {

        D("setting connection_state to kCsHost\n");

        D("setting connection_state to kCsHost");

        t->connection_state = kCsHost;

    }

}
@@ -450,7 +448,7 @@ void handle_packet(apacket *p, atransport *t) 
{

    asocket *s;



    D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],

    D("handle_packet() %c%c%c%c", ((char*) (&(p->msg.command)))[0],

            ((char*) (&(p->msg.command)))[1],

            ((char*) (&(p->msg.command)))[2],

            ((char*) (&(p->msg.command)))[3]);
@@ -526,7 +524,7 @@ void handle_packet(apacket *p, atransport *t) 
                    /* Other READY messages must use the same local-id */

                    s->ready(s);

                } else {

                    D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s\n",

                    D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s",

                      p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial);

                }

            }
@@ -547,7 +545,7 @@ void handle_packet(apacket *p, atransport *t) 
                 * socket has a peer on the same transport.

                 */

                if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) {

                    D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s\n",

                    D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s",

                      p->msg.arg1, t->serial, s->peer->transport->serial);

                } else {

                    s->close(s);
@@ -563,7 +561,7 @@ void handle_packet(apacket *p, atransport *t) 
                p->len = p->msg.data_length;



                if(s->enqueue(s, p) == 0) {

                    D("Enqueue the socket\n");

                    D("Enqueue the socket");

                    send_ready(s->id, rid, t);

                }

                return;
@@ -1125,9 +1123,9 @@ int handle_host_request(const char* service, TransportType type, 
    if (!strncmp(service, "devices", 7)) {

        bool long_listing = (strcmp(service+7, "-l") == 0);

        if (long_listing || service[7] == 0) {

            D("Getting device list...\n");

            D("Getting device list...");

            std::string device_list = list_transports(long_listing);

            D("Sending device list...\n");

            D("Sending device list...");

            return SendOkay(reply_fd, device_list);

        }

        return 1;

adb/adb_auth.cpp

+6 −6
Original line number Diff line number Diff line
@@ -32,13 +32,13 @@ bool auth_required = true; 


void send_auth_request(atransport *t)

{

    D("Calling send_auth_request\n");

    D("Calling send_auth_request");

    apacket *p;

    int ret;



    ret = adb_auth_generate_token(t->token, sizeof(t->token));

    if (ret != sizeof(t->token)) {

        D("Error generating token ret=%d\n", ret);

        D("Error generating token ret=%d", ret);

        return;

    }
@@ -52,13 +52,13 @@ void send_auth_request(atransport *t) 


void send_auth_response(uint8_t *token, size_t token_size, atransport *t)

{

    D("Calling send_auth_response\n");

    D("Calling send_auth_response");

    apacket *p = get_apacket();

    int ret;



    ret = adb_auth_sign(t->key, token, token_size, p->data);

    if (!ret) {

        D("Error signing the token\n");

        D("Error signing the token");

        put_apacket(p);

        return;

    }
@@ -71,13 +71,13 @@ void send_auth_response(uint8_t *token, size_t token_size, atransport *t) 


void send_auth_publickey(atransport *t)

{

    D("Calling send_auth_publickey\n");

    D("Calling send_auth_publickey");

    apacket *p = get_apacket();

    int ret;



    ret = adb_auth_get_userkey(p->data, MAX_PAYLOAD_V1);

    if (!ret) {

        D("Failed to get user public key\n");

        D("Failed to get user public key");

        put_apacket(p);

        return;

    }

adb/adb_auth_client.cpp

+16 −16
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ static void read_keys(const char *file, struct listnode *list) 


    f = fopen(file, "re");

    if (!f) {

        D("Can't open '%s'\n", file);

        D("Can't open '%s'", file);

        return;

    }
@@ -69,7 +69,7 @@ static void read_keys(const char *file, struct listnode *list) 
        auto key = reinterpret_cast<adb_public_key*>(

            calloc(1, sizeof(adb_public_key) + 4));

        if (key == nullptr) {

            D("Can't malloc key\n");

            D("Can't malloc key");

            break;

        }
@@ -79,13 +79,13 @@ static void read_keys(const char *file, struct listnode *list) 


        ret = __b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4);

        if (ret != sizeof(key->key)) {

            D("%s: Invalid base64 data ret=%d\n", file, ret);

            D("%s: Invalid base64 data ret=%d", file, ret);

            free(key);

            continue;

        }



        if (key->key.len != RSANUMWORDS) {

            D("%s: Invalid key len %d\n", file, key->key.len);

            D("%s: Invalid key len %d", file, key->key.len);

            free(key);

            continue;

        }
@@ -117,7 +117,7 @@ static void load_keys(struct listnode *list) 


    while ((path = *paths++)) {

        if (!stat(path, &buf)) {

            D("Loading keys from '%s'\n", path);

            D("Loading keys from '%s'", path);

            read_keys(path, list);

        }

    }
@@ -163,7 +163,7 @@ int adb_auth_verify(uint8_t* token, uint8_t* sig, int siglen) 


static void usb_disconnected(void* unused, atransport* t)

{

    D("USB disconnect\n");

    D("USB disconnect");

    usb_transport = NULL;

    needs_retry = false;

}
@@ -176,7 +176,7 @@ static void adb_auth_event(int fd, unsigned events, void *data) 
    if (events & FDE_READ) {

        ret = unix_read(fd, response, sizeof(response));

        if (ret <= 0) {

            D("Framework disconnect\n");

            D("Framework disconnect");

            if (usb_transport)

                fdevent_remove(&usb_transport->auth_fde);

            framework_fd = -1;
@@ -199,26 +199,26 @@ void adb_auth_confirm_key(unsigned char *key, size_t len, atransport *t) 
    }



    if (framework_fd < 0) {

        D("Client not connected\n");

        D("Client not connected");

        needs_retry = true;

        return;

    }



    if (key[len - 1] != '\0') {

        D("Key must be a null-terminated string\n");

        D("Key must be a null-terminated string");

        return;

    }



    ret = snprintf(msg, sizeof(msg), "PK%s", key);

    if (ret >= (signed)sizeof(msg)) {

        D("Key too long. ret=%d\n", ret);

        D("Key too long. ret=%d", ret);

        return;

    }

    D("Sending '%s'\n", msg);

    D("Sending '%s'", msg);



    ret = unix_write(framework_fd, msg, ret);

    if (ret < 0) {

        D("Failed to write PK, errno=%d\n", errno);

        D("Failed to write PK, errno=%d", errno);

        return;

    }
@@ -236,7 +236,7 @@ static void adb_auth_listener(int fd, unsigned events, void *data) 


    s = adb_socket_accept(fd, &addr, &alen);

    if (s < 0) {

        D("Failed to accept: errno=%d\n", errno);

        D("Failed to accept: errno=%d", errno);

        return;

    }
@@ -251,7 +251,7 @@ static void adb_auth_listener(int fd, unsigned events, void *data) 
void adbd_cloexec_auth_socket() {

    int fd = android_get_control_socket("adbd");

    if (fd == -1) {

        D("Failed to get adbd socket\n");

        D("Failed to get adbd socket");

        return;

    }

    fcntl(fd, F_SETFD, FD_CLOEXEC);
@@ -260,12 +260,12 @@ void adbd_cloexec_auth_socket() { 
void adbd_auth_init(void) {

    int fd = android_get_control_socket("adbd");

    if (fd == -1) {

        D("Failed to get adbd socket\n");

        D("Failed to get adbd socket");

        return;

    }



    if (listen(fd, 4) == -1) {

        D("Failed to listen on '%d'\n", fd);

        D("Failed to listen on '%d'", fd);

        return;

    }

adb/adb_auth_host.cpp

+29 −29
Original line number Diff line number Diff line
@@ -164,26 +164,26 @@ static int write_public_keyfile(RSA *private_key, const char *private_key_path) 


    if (snprintf(path, sizeof(path), "%s.pub", private_key_path) >=

        (int)sizeof(path)) {

        D("Path too long while writing public key\n");

        D("Path too long while writing public key");

        return 0;

    }



    if (!RSA_to_RSAPublicKey(private_key, &pkey)) {

        D("Failed to convert to publickey\n");

        D("Failed to convert to publickey");

        return 0;

    }



    outfile = fopen(path, "w");

    if (!outfile) {

        D("Failed to open '%s'\n", path);

        D("Failed to open '%s'", path);

        return 0;

    }



    D("Writing public key to '%s'\n", path);

    D("Writing public key to '%s'", path);



#if defined(OPENSSL_IS_BORINGSSL)

    if (!EVP_EncodedLength(&encoded_length, sizeof(pkey))) {

        D("Public key too large to base64 encode\n");

        D("Public key too large to base64 encode");

        goto out;

    }

#else
@@ -194,7 +194,7 @@ static int write_public_keyfile(RSA *private_key, const char *private_key_path) 


    encoded = new uint8_t[encoded_length];

    if (encoded == nullptr) {

        D("Allocation failure\n");

        D("Allocation failure");

        goto out;

    }
@@ -203,7 +203,7 @@ static int write_public_keyfile(RSA *private_key, const char *private_key_path) 


    if (fwrite(encoded, encoded_length, 1, outfile) != 1 ||

        fwrite(info, strlen(info), 1, outfile) != 1) {

        D("Write error while writing public key\n");

        D("Write error while writing public key");

        goto out;

    }
@@ -226,10 +226,10 @@ static int generate_key(const char *file) 
    FILE *f = NULL;

    int ret = 0;



    D("generate_key '%s'\n", file);

    D("generate_key '%s'", file);



    if (!pkey || !exponent || !rsa) {

        D("Failed to allocate key\n");

        D("Failed to allocate key");

        goto out;

    }
@@ -241,7 +241,7 @@ static int generate_key(const char *file) 


    f = fopen(file, "w");

    if (!f) {

        D("Failed to open '%s'\n", file);

        D("Failed to open '%s'", file);

        umask(old_mask);

        goto out;

    }
@@ -249,12 +249,12 @@ static int generate_key(const char *file) 
    umask(old_mask);



    if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {

        D("Failed to write key\n");

        D("Failed to write key");

        goto out;

    }



    if (!write_public_keyfile(rsa, file)) {

        D("Failed to write public key\n");

        D("Failed to write public key");

        goto out;

    }
@@ -271,11 +271,11 @@ out: 


static int read_key(const char *file, struct listnode *list)

{

    D("read_key '%s'\n", file);

    D("read_key '%s'", file);



    FILE* fp = fopen(file, "r");

    if (!fp) {

        D("Failed to open '%s': %s\n", file, strerror(errno));

        D("Failed to open '%s': %s", file, strerror(errno));

        return 0;

    }
@@ -283,7 +283,7 @@ static int read_key(const char *file, struct listnode *list) 
    key->rsa = RSA_new();



    if (!PEM_read_RSAPrivateKey(fp, &key->rsa, NULL, NULL)) {

        D("Failed to read key\n");

        D("Failed to read key");

        fclose(fp);

        RSA_free(key->rsa);

        delete key;
@@ -307,7 +307,7 @@ static int get_user_keyfilepath(char *filename, size_t len) 
        WCHAR path[MAX_PATH];

        const HRESULT hr = SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, path);

        if (FAILED(hr)) {

            D("SHGetFolderPathW failed: %s\n",

            D("SHGetFolderPathW failed: %s",

              SystemErrorCodeToString(hr).c_str());

            return -1;

        }
@@ -322,7 +322,7 @@ static int get_user_keyfilepath(char *filename, size_t len) 
    format = "%s/%s";

#endif



    D("home '%s'\n", home);

    D("home '%s'", home);



    if (snprintf(android_dir, sizeof(android_dir), format, home,

                        ANDROID_PATH) >= (int)sizeof(android_dir))
@@ -330,7 +330,7 @@ static int get_user_keyfilepath(char *filename, size_t len) 


    if (stat(android_dir, &buf)) {

        if (adb_mkdir(android_dir, 0750) < 0) {

            D("Cannot mkdir '%s'\n", android_dir);

            D("Cannot mkdir '%s'", android_dir);

            return -1;

        }

    }
@@ -346,15 +346,15 @@ static int get_user_key(struct listnode *list) 


    ret = get_user_keyfilepath(path, sizeof(path));

    if (ret < 0 || ret >= (signed)sizeof(path)) {

        D("Error getting user key filename\n");

        D("Error getting user key filename");

        return 0;

    }



    D("user key '%s'\n", path);

    D("user key '%s'", path);



    if (stat(path, &buf) == -1) {

        if (!generate_key(path)) {

            D("Failed to generate new key\n");

            D("Failed to generate new key");

            return 0;

        }

    }
@@ -370,7 +370,7 @@ static void get_vendor_keys(struct listnode* key_list) { 


    for (auto& path : android::base::Split(adb_keys_path, ENV_PATH_SEPARATOR_STR)) {

        if (!read_key(path.c_str(), key_list)) {

            D("Failed to read '%s'\n", path.c_str());

            D("Failed to read '%s'", path.c_str());

        }

    }

}
@@ -382,7 +382,7 @@ int adb_auth_sign(void *node, const unsigned char* token, size_t token_size, 
    struct adb_private_key *key = node_to_item(node, struct adb_private_key, node);



    if (token_size != TOKEN_SIZE) {

        D("Unexpected token size %zd\n", token_size);

        D("Unexpected token size %zd", token_size);

        return 0;

    }
@@ -390,7 +390,7 @@ int adb_auth_sign(void *node, const unsigned char* token, size_t token_size, 
        return 0;

    }



    D("adb_auth_sign len=%d\n", len);

    D("adb_auth_sign len=%d", len);

    return (int)len;

}
@@ -421,7 +421,7 @@ int adb_auth_get_userkey(unsigned char *data, size_t len) 
    char path[PATH_MAX];

    int ret = get_user_keyfilepath(path, sizeof(path) - 4);

    if (ret < 0 || ret >= (signed)(sizeof(path) - 4)) {

        D("Error getting user key filename\n");

        D("Error getting user key filename");

        return 0;

    }

    strcat(path, ".pub");
@@ -433,12 +433,12 @@ int adb_auth_get_userkey(unsigned char *data, size_t len) 
    unsigned size;

    char* file_data = reinterpret_cast<char*>(load_file(path, &size));

    if (file_data == nullptr) {

        D("Can't load '%s'\n", path);

        D("Can't load '%s'", path);

        return 0;

    }



    if (len < (size_t)(size + 1)) {

        D("%s: Content too large ret=%d\n", path, size);

        D("%s: Content too large ret=%d", path, size);

        free(file_data);

        return 0;

    }
@@ -460,13 +460,13 @@ void adb_auth_init(void) 
{

    int ret;



    D("adb_auth_init\n");

    D("adb_auth_init");



    list_init(&key_list);



    ret = get_user_key(&key_list);

    if (!ret) {

        D("Failed to get user key\n");

        D("Failed to get user key");

        return;

    }

adb/adb_client.cpp

+9 −9
Original line number Diff line number Diff line
@@ -90,14 +90,14 @@ static int switch_socket_transport(int fd, std::string* error) { 
        adb_close(fd);

        return -1;

    }

    D("Switch transport in progress\n");

    D("Switch transport in progress");



    if (!adb_status(fd, error)) {

        adb_close(fd);

        D("Switch transport failed: %s\n", error->c_str());

        D("Switch transport failed: %s", error->c_str());

        return -1;

    }

    D("Switch transport success\n");

    D("Switch transport success");

    return 0;

}
@@ -123,7 +123,7 @@ bool adb_status(int fd, std::string* error) { 
}



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

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

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

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

        *error = android::base::StringPrintf("bad service name length (%zd)",

                                             service.size());
@@ -164,7 +164,7 @@ int _adb_connect(const std::string& service, std::string* error) { 
        return -1;

    }



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

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

    return fd;

}
@@ -172,7 +172,7 @@ int adb_connect(const std::string& service, std::string* error) { 
    // first query the adb server's version

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



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

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

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

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

        // error is the original network connection error
@@ -246,11 +246,11 @@ int adb_connect(const std::string& service, std::string* error) { 


    fd = _adb_connect(service, error);

    if (fd == -1) {

        D("_adb_connect error: %s\n", error->c_str());

        D("_adb_connect error: %s", error->c_str());

    } else if(fd == -2) {

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

    }

    D("adb_connect: return fd %d\n", fd);

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



    return fd;

error:
@@ -277,7 +277,7 @@ bool adb_command(const std::string& service) { 
}



bool adb_query(const std::string& service, std::string* result, std::string* error) {

    D("adb_query: %s\n", service.c_str());

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

    int fd = adb_connect(service, error);

    if (fd < 0) {

        return false;