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

Commit 52bd8526 authored by Josh Gao's avatar Josh Gao
Browse files

adb: clang-format sockets.cpp. 

Bug: http://b/28347842
Change-Id: Ie3748b6c803d4e8056e9d7abd065a8b99d945a5b
parent 903b749f

adb/sockets.cpp

+230 −246
Original line number Diff line number Diff line
@@ -44,8 +44,7 @@ static void local_socket_close_locked(asocket *s); 
static unsigned local_socket_next_id = 1;



static asocket local_socket_list = {

    .next = &local_socket_list,

    .prev = &local_socket_list,

    .next = &local_socket_list, .prev = &local_socket_list,

};



/* the the list of currently closing local sockets.
@@ -53,22 +52,21 @@ static asocket local_socket_list = { 
** write to their fd.

*/

static asocket local_socket_closing_list = {

    .next = &local_socket_closing_list,

    .prev = &local_socket_closing_list,

    .next = &local_socket_closing_list, .prev = &local_socket_closing_list,

};



// Parse the global list of sockets to find one with id |local_id|.

// If |peer_id| is not 0, also check that it is connected to a peer

// with id |peer_id|. Returns an asocket handle on success, NULL on failure.

asocket *find_local_socket(unsigned local_id, unsigned peer_id)

{

asocket* find_local_socket(unsigned local_id, unsigned peer_id) {

    asocket* s;

    asocket* result = NULL;



    adb_mutex_lock(&socket_list_lock);

    for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {

        if (s->id != local_id)

        if (s->id != local_id) {

            continue;

        }

        if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {

            result = s;

        }
@@ -79,36 +77,31 @@ asocket *find_local_socket(unsigned local_id, unsigned peer_id) 
    return result;

}



static void

insert_local_socket(asocket*  s, asocket*  list)

{

static void insert_local_socket(asocket* s, asocket* list) {

    s->next = list;

    s->prev = s->next->prev;

    s->prev->next = s;

    s->next->prev = s;

}





void install_local_socket(asocket *s)

{

void install_local_socket(asocket* s) {

    adb_mutex_lock(&socket_list_lock);



    s->id = local_socket_next_id++;



    // Socket ids should never be 0.

    if (local_socket_next_id == 0)

    if (local_socket_next_id == 0) {

        local_socket_next_id = 1;

    }



    insert_local_socket(s, &local_socket_list);



    adb_mutex_unlock(&socket_list_lock);

}



void remove_socket(asocket *s)

{

void remove_socket(asocket* s) {

    // socket_list_lock should already be held

    if (s->prev && s->next)

    {

    if (s->prev && s->next) {

        s->prev->next = s->next;

        s->next->prev = s->prev;

        s->next = 0;
@@ -117,8 +110,7 @@ void remove_socket(asocket *s) 
    }

}



void close_all_sockets(atransport *t)

{

void close_all_sockets(atransport* t) {

    asocket* s;



    /* this is a little gross, but since s->close() *will* modify
@@ -135,8 +127,7 @@ restart: 
    adb_mutex_unlock(&socket_list_lock);

}



static int local_socket_enqueue(asocket *s, apacket *p)

{

static int local_socket_enqueue(asocket* s, apacket* p) {

    D("LS(%d): enqueue %d", s->id, p->len);



    p->ptr = p->data;
@@ -190,23 +181,20 @@ enqueue: 
    return 1; /* not ready (backlog) */

}



static void local_socket_ready(asocket *s)

{

static void local_socket_ready(asocket* s) {

    /* far side is ready for data, pay attention to

       readable events */

    fdevent_add(&s->fde, FDE_READ);

}



static void local_socket_close(asocket *s)

{

static void local_socket_close(asocket* s) {

    adb_mutex_lock(&socket_list_lock);

    local_socket_close_locked(s);

    adb_mutex_unlock(&socket_list_lock);

}



// be sure to hold the socket list lock when calling this

static void local_socket_destroy(asocket  *s)

{

static void local_socket_destroy(asocket* s) {

    apacket *p, *n;

    int exit_on_close = s->exit_on_close;
@@ -232,19 +220,17 @@ static void local_socket_destroy(asocket *s) 
    }

}





static void local_socket_close_locked(asocket *s)

{

static void local_socket_close_locked(asocket* s) {

    D("entered local_socket_close_locked. LS(%d) fd=%d", s->id, s->fd);

    if (s->peer) {

        D("LS(%d): closing peer. peer->id=%d peer->fd=%d",

          s->id, s->peer->id, s->peer->fd);

        D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);

        /* Note: it's important to call shutdown before disconnecting from

         * the peer, this ensures that remote sockets can still get the id

         * of the local socket they're connected to, to send a CLOSE()

         * protocol event. */

        if (s->peer->shutdown)

        if (s->peer->shutdown) {

            s->peer->shutdown(s->peer);

        }

        s->peer->peer = 0;

        // tweak to avoid deadlock

        if (s->peer->close == local_socket_close) {
@@ -276,8 +262,7 @@ static void local_socket_close_locked(asocket *s) 
    CHECK_EQ(FDE_WRITE, s->fde.state & FDE_WRITE);

}



static void local_socket_event_func(int fd, unsigned ev, void* _s)

{

static void local_socket_event_func(int fd, unsigned ev, void* _s) {

    asocket* s = reinterpret_cast<asocket*>(_s);

    D("LS(%d): event_func(fd=%d(==%d), ev=%04x)", s->id, s->fd, fd, ev);
@@ -334,7 +319,6 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s) 
        s->peer->ready(s->peer);

    }





    if (ev & FDE_READ) {

        apacket* p = get_apacket();

        unsigned char* x = p->data;
@@ -345,8 +329,8 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s) 


        while (avail > 0) {

            r = adb_read(fd, x, avail);

            D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu",

              s->id, s->fd, r, r < 0 ? errno : 0, avail);

            D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu", s->id, s->fd, r,

              r < 0 ? errno : 0, avail);

            if (r == -1) {

                if (errno == EAGAIN) {

                    break;
@@ -361,8 +345,8 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s) 
            is_eof = 1;

            break;

        }

        D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d",

          s->id, s->fd, r, is_eof, s->fde.force_eof);

        D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d", s->id, s->fd, r, is_eof,

          s->fde.force_eof);

        if ((avail == max_payload) || (s->peer == 0)) {

            put_apacket(p);

        } else {
@@ -397,8 +381,7 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s) 
        }

        /* Don't allow a forced eof if data is still there */

        if ((s->fde.force_eof && !r) || is_eof) {

            D(" closing because is_eof=%d r=%d s->fde.force_eof=%d",

              is_eof, r, s->fde.force_eof);

            D(" closing because is_eof=%d r=%d s->fde.force_eof=%d", is_eof, r, s->fde.force_eof);

            s->close(s);

            return;

        }
@@ -414,10 +397,11 @@ static void local_socket_event_func(int fd, unsigned ev, void* _s) 
    }

}



asocket *create_local_socket(int fd)

{

asocket* create_local_socket(int fd) {

    asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));

    if (s == NULL) fatal("cannot allocate socket");

    if (s == NULL) {

        fatal("cannot allocate socket");

    }

    s->fd = fd;

    s->enqueue = local_socket_enqueue;

    s->ready = local_socket_ready;
@@ -430,9 +414,7 @@ asocket *create_local_socket(int fd) 
    return s;

}



asocket *create_local_service_socket(const char *name,

                                     const atransport* transport)

{

asocket* create_local_service_socket(const char* name, const atransport* transport) {

#if !ADB_HOST

    if (!strcmp(name, "jdwp")) {

        return create_jdwp_service_socket();
@@ -442,20 +424,23 @@ asocket *create_local_service_socket(const char *name, 
    }

#endif

    int fd = service_to_fd(name, transport);

    if(fd < 0) return 0;

    if (fd < 0) {

        return 0;

    }



    asocket* s = create_local_socket(fd);

    D("LS(%d): bound to '%s' via %d", s->id, name, fd);



#if !ADB_HOST

    char debug[PROPERTY_VALUE_MAX];

    if (!strncmp(name, "root:", 5))

    if (!strncmp(name, "root:", 5)) {

        property_get("ro.debuggable", debug, "");

    }



    if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0)

        || (!strncmp(name, "unroot:", 7) && getuid() == 0)

        || !strncmp(name, "usb:", 4)

        || !strncmp(name, "tcpip:", 6)) {

    if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0) ||

        (!strncmp(name, "unroot:", 7) && getuid() == 0) ||

        !strncmp(name, "usb:", 4) ||

        !strncmp(name, "tcpip:", 6)) {

        D("LS(%d): enabling exit_on_close", s->id);

        s->exit_on_close = 1;

    }
@@ -465,8 +450,7 @@ asocket *create_local_service_socket(const char *name, 
}



#if ADB_HOST

static asocket *create_host_service_socket(const char *name, const char* serial)

{

static asocket* create_host_service_socket(const char* name, const char* serial) {

    asocket* s;



    s = host_service_to_socket(name, serial);
@@ -480,10 +464,8 @@ static asocket *create_host_service_socket(const char *name, const char* serial) 
}

#endif /* ADB_HOST */



static int remote_socket_enqueue(asocket *s, apacket *p)

{

    D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d",

      s->id, s->fd, s->peer->fd);

static int remote_socket_enqueue(asocket* s, apacket* p) {

    D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);

    p->msg.command = A_WRTE;

    p->msg.arg0 = s->peer->id;

    p->msg.arg1 = s->id;
@@ -492,10 +474,8 @@ static int remote_socket_enqueue(asocket *s, apacket *p) 
    return 1;

}



static void remote_socket_ready(asocket *s)

{

    D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d",

      s->id, s->fd, s->peer->fd);

static void remote_socket_ready(asocket* s) {

    D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);

    apacket* p = get_apacket();

    p->msg.command = A_OKAY;

    p->msg.arg0 = s->peer->id;
@@ -503,10 +483,9 @@ static void remote_socket_ready(asocket *s) 
    send_packet(p, s->transport);

}



static void remote_socket_shutdown(asocket *s)

{

    D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d",

      s->id, s->fd, s->peer?s->peer->fd:-1);

static void remote_socket_shutdown(asocket* s) {

    D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,

      s->peer ? s->peer->fd : -1);

    apacket* p = get_apacket();

    p->msg.command = A_CLSE;

    if (s->peer) {
@@ -516,16 +495,14 @@ static void remote_socket_shutdown(asocket *s) 
    send_packet(p, s->transport);

}



static void remote_socket_close(asocket *s)

{

static void remote_socket_close(asocket* s) {

    if (s->peer) {

        s->peer->peer = 0;

        D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d",

          s->id, s->peer->id, s->peer->fd);

        D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);

        s->peer->close(s->peer);

    }

    D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d",

      s->id, s->fd, s->peer?s->peer->fd:-1);

    D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,

      s->peer ? s->peer->fd : -1);

    D("RS(%d): closed", s->id);

    free(s);

}
@@ -534,12 +511,15 @@ static void remote_socket_close(asocket *s) 
// |t|. Where |id| is the socket id of the corresponding service on the other

//  side of the transport (it is allocated by the remote side and _cannot_ be 0).

// Returns a new non-NULL asocket handle.

asocket *create_remote_socket(unsigned id, atransport *t)

{

    if (id == 0) fatal("invalid remote socket id (0)");

asocket* create_remote_socket(unsigned id, atransport* t) {

    if (id == 0) {

        fatal("invalid remote socket id (0)");

    }

    asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));



    if (s == NULL) fatal("cannot allocate socket");

    if (s == NULL) {

        fatal("cannot allocate socket");

    }

    s->id = id;

    s->enqueue = remote_socket_enqueue;

    s->ready = remote_socket_ready;
@@ -551,8 +531,7 @@ asocket *create_remote_socket(unsigned id, atransport *t) 
    return s;

}



void connect_to_remote(asocket *s, const char *destination)

{

void connect_to_remote(asocket* s, const char* destination) {

    D("Connect_to_remote call RS(%d) fd=%d", s->id, s->fd);

    apacket* p = get_apacket();

    size_t len = strlen(destination) + 1;
@@ -569,11 +548,9 @@ void connect_to_remote(asocket *s, const char *destination) 
    send_packet(p, s->transport);

}





/* this is used by magic sockets to rig local sockets to

   send the go-ahead message when they connect */

static void local_socket_ready_notify(asocket *s)

{

static void local_socket_ready_notify(asocket* s) {

    s->ready = local_socket_ready;

    s->shutdown = NULL;

    s->close = local_socket_close;
@@ -584,8 +561,7 @@ static void local_socket_ready_notify(asocket *s) 
/* this is used by magic sockets to rig local sockets to

   send the failure message if they are closed before

   connected (to avoid closing them without a status message) */

static void local_socket_close_notify(asocket *s)

{

static void local_socket_close_notify(asocket* s) {

    s->ready = local_socket_ready;

    s->shutdown = NULL;

    s->close = local_socket_close;
@@ -593,24 +569,37 @@ static void local_socket_close_notify(asocket *s) 
    s->close(s);

}



static unsigned unhex(unsigned char *s, int len)

{

static unsigned unhex(unsigned char* s, int len) {

    unsigned n = 0, c;



    while (len-- > 0) {

        switch ((c = *s++)) {

        case '0': case '1': case '2':

        case '3': case '4': case '5':

        case '6': case '7': case '8':

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                c -= '0';

                break;

        case 'a': case 'b': case 'c':

        case 'd': case 'e': case 'f':

            case 'a':

            case 'b':

            case 'c':

            case 'd':

            case 'e':

            case 'f':

                c = c - 'a' + 10;

                break;

        case 'A': case 'B': case 'C':

        case 'D': case 'E': case 'F':

            case 'A':

            case 'B':

            case 'C':

            case 'D':

            case 'E':

            case 'F':

                c = c - 'A' + 10;

                break;

            default:
@@ -673,8 +662,7 @@ char* skip_host_serial(char* service) { 


#endif  // ADB_HOST



static int smart_socket_enqueue(asocket *s, apacket *p)

{

static int smart_socket_enqueue(asocket* s, apacket* p) {

    unsigned len;

#if ADB_HOST

    char* service = nullptr;
@@ -694,8 +682,7 @@ static int smart_socket_enqueue(asocket *s, apacket *p) 
            goto fail;

        }



        memcpy(s->pkt_first->data + s->pkt_first->len,

               p->data, p->len);

        memcpy(s->pkt_first->data + s->pkt_first->len, p->data, p->len);

        s->pkt_first->len += p->len;

        put_apacket(p);
@@ -703,7 +690,9 @@ static int smart_socket_enqueue(asocket *s, apacket *p) 
    }



    /* don't bother if we can't decode the length */

    if(p->len < 4) return 0;

    if (p->len < 4) {

        return 0;

    }



    len = unhex(p->data, 4);

    if ((len < 1) || (len > MAX_PAYLOAD_V1)) {
@@ -819,7 +808,6 @@ static int smart_socket_enqueue(asocket *s, apacket *p) 
        goto fail;

    }





    /* instrument our peer to pass the success or fail

    ** message back once it connects or closes, then

    ** detach from it, request the connection, and
@@ -846,13 +834,11 @@ fail: 
    return -1;

}



static void smart_socket_ready(asocket *s)

{

static void smart_socket_ready(asocket* s) {

    D("SS(%d): ready", s->id);

}



static void smart_socket_close(asocket *s)

{

static void smart_socket_close(asocket* s) {

    D("SS(%d): closed", s->id);

    if (s->pkt_first) {

        put_apacket(s->pkt_first);
@@ -865,8 +851,7 @@ static void smart_socket_close(asocket *s) 
    free(s);

}



static asocket *create_smart_socket(void)

{

static asocket* create_smart_socket(void) {

    D("Creating smart socket");

    asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));

    if (s == NULL) fatal("cannot allocate socket");
@@ -879,8 +864,7 @@ static asocket *create_smart_socket(void) 
    return s;

}



void connect_to_smartsocket(asocket *s)

{

void connect_to_smartsocket(asocket* s) {

    D("Connecting to smart socket");

    asocket* ss = create_smart_socket();

    s->peer = ss;