1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define TRACE_TAG TRACE_TRANSPORT
18
19#include "sysdeps.h"
20#include "transport.h"
21
22#include <ctype.h>
23#include <errno.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <unistd.h>
28
29#include <base/stringprintf.h>
30
31#include "adb.h"
32#include "adb_utils.h"
33
34static void transport_unref(atransport *t);
35
36static atransport transport_list = {
37    .next = &transport_list,
38    .prev = &transport_list,
39};
40
41static atransport pending_list = {
42    .next = &pending_list,
43    .prev = &pending_list,
44};
45
46ADB_MUTEX_DEFINE( transport_lock );
47
48void kick_transport(atransport* t)
49{
50    if (t && !t->kicked)
51    {
52        int  kicked;
53
54        adb_mutex_lock(&transport_lock);
55        kicked = t->kicked;
56        if (!kicked)
57            t->kicked = 1;
58        adb_mutex_unlock(&transport_lock);
59
60        if (!kicked)
61            t->kick(t);
62    }
63}
64
65// Each atransport contains a list of adisconnects (t->disconnects).
66// An adisconnect contains a link to the next/prev adisconnect, a function
67// pointer to a disconnect callback which takes a void* piece of user data and
68// the atransport, and some user data for the callback (helpfully named
69// "opaque").
70//
71// The list is circular. New items are added to the entry member of the list
72// (t->disconnects) by add_transport_disconnect.
73//
74// run_transport_disconnects invokes each function in the list.
75//
76// Gotchas:
77//   * run_transport_disconnects assumes that t->disconnects is non-null, so
78//     this can't be run on a zeroed atransport.
79//   * The callbacks in this list are not removed when called, and this function
80//     is not guarded against running more than once. As such, ensure that this
81//     function is not called multiple times on the same atransport.
82//     TODO(danalbert): Just fix this so that it is guarded once you have tests.
83void run_transport_disconnects(atransport* t)
84{
85    adisconnect*  dis = t->disconnects.next;
86
87    D("%s: run_transport_disconnects\n", t->serial);
88    while (dis != &t->disconnects) {
89        adisconnect*  next = dis->next;
90        dis->func( dis->opaque, t );
91        dis = next;
92    }
93}
94
95static void dump_packet(const char* name, const char* func, apacket* p) {
96    unsigned  command = p->msg.command;
97    int       len     = p->msg.data_length;
98    char      cmd[9];
99    char      arg0[12], arg1[12];
100    int       n;
101
102    for (n = 0; n < 4; n++) {
103        int  b = (command >> (n*8)) & 255;
104        if (b < 32 || b >= 127)
105            break;
106        cmd[n] = (char)b;
107    }
108    if (n == 4) {
109        cmd[4] = 0;
110    } else {
111        /* There is some non-ASCII name in the command, so dump
112            * the hexadecimal value instead */
113        snprintf(cmd, sizeof cmd, "%08x", command);
114    }
115
116    if (p->msg.arg0 < 256U)
117        snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
118    else
119        snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
120
121    if (p->msg.arg1 < 256U)
122        snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
123    else
124        snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
125
126    D("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
127        name, func, cmd, arg0, arg1, len);
128    dump_hex(p->data, len);
129}
130
131static int
132read_packet(int  fd, const char* name, apacket** ppacket)
133{
134    char *p = (char*)ppacket;  /* really read a packet address */
135    int   r;
136    int   len = sizeof(*ppacket);
137    char  buff[8];
138    if (!name) {
139        snprintf(buff, sizeof buff, "fd=%d", fd);
140        name = buff;
141    }
142    while(len > 0) {
143        r = adb_read(fd, p, len);
144        if(r > 0) {
145            len -= r;
146            p   += r;
147        } else {
148            D("%s: read_packet (fd=%d), error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
149            if((r < 0) && (errno == EINTR)) continue;
150            return -1;
151        }
152    }
153
154    if (ADB_TRACING) {
155        dump_packet(name, "from remote", *ppacket);
156    }
157    return 0;
158}
159
160static int
161write_packet(int  fd, const char* name, apacket** ppacket)
162{
163    char *p = (char*) ppacket;  /* we really write the packet address */
164    int r, len = sizeof(ppacket);
165    char buff[8];
166    if (!name) {
167        snprintf(buff, sizeof buff, "fd=%d", fd);
168        name = buff;
169    }
170
171    if (ADB_TRACING) {
172        dump_packet(name, "to remote", *ppacket);
173    }
174    len = sizeof(ppacket);
175    while(len > 0) {
176        r = adb_write(fd, p, len);
177        if(r > 0) {
178            len -= r;
179            p += r;
180        } else {
181            D("%s: write_packet (fd=%d) error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
182            if((r < 0) && (errno == EINTR)) continue;
183            return -1;
184        }
185    }
186    return 0;
187}
188
189static void transport_socket_events(int fd, unsigned events, void *_t)
190{
191    atransport *t = reinterpret_cast<atransport*>(_t);
192    D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
193    if(events & FDE_READ){
194        apacket *p = 0;
195        if(read_packet(fd, t->serial, &p)){
196            D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
197        } else {
198            handle_packet(p, (atransport *) _t);
199        }
200    }
201}
202
203void send_packet(apacket *p, atransport *t)
204{
205    unsigned char *x;
206    unsigned sum;
207    unsigned count;
208
209    p->msg.magic = p->msg.command ^ 0xffffffff;
210
211    count = p->msg.data_length;
212    x = (unsigned char *) p->data;
213    sum = 0;
214    while(count-- > 0){
215        sum += *x++;
216    }
217    p->msg.data_check = sum;
218
219    print_packet("send", p);
220
221    if (t == NULL) {
222        D("Transport is null \n");
223        // Zap errno because print_packet() and other stuff have errno effect.
224        errno = 0;
225        fatal_errno("Transport is null");
226    }
227
228    if(write_packet(t->transport_socket, t->serial, &p)){
229        fatal_errno("cannot enqueue packet on transport socket");
230    }
231}
232
233/* The transport is opened by transport_register_func before
234** the input and output threads are started.
235**
236** The output thread issues a SYNC(1, token) message to let
237** the input thread know to start things up.  In the event
238** of transport IO failure, the output thread will post a
239** SYNC(0,0) message to ensure shutdown.
240**
241** The transport will not actually be closed until both
242** threads exit, but the input thread will kick the transport
243** on its way out to disconnect the underlying device.
244*/
245
246static void *output_thread(void *_t)
247{
248    atransport *t = reinterpret_cast<atransport*>(_t);
249    apacket *p;
250
251    D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
252       t->serial, t->fd, t->sync_token + 1);
253    p = get_apacket();
254    p->msg.command = A_SYNC;
255    p->msg.arg0 = 1;
256    p->msg.arg1 = ++(t->sync_token);
257    p->msg.magic = A_SYNC ^ 0xffffffff;
258    if(write_packet(t->fd, t->serial, &p)) {
259        put_apacket(p);
260        D("%s: failed to write SYNC packet\n", t->serial);
261        goto oops;
262    }
263
264    D("%s: data pump started\n", t->serial);
265    for(;;) {
266        p = get_apacket();
267
268        if(t->read_from_remote(p, t) == 0){
269            D("%s: received remote packet, sending to transport\n",
270              t->serial);
271            if(write_packet(t->fd, t->serial, &p)){
272                put_apacket(p);
273                D("%s: failed to write apacket to transport\n", t->serial);
274                goto oops;
275            }
276        } else {
277            D("%s: remote read failed for transport\n", t->serial);
278            put_apacket(p);
279            break;
280        }
281    }
282
283    D("%s: SYNC offline for transport\n", t->serial);
284    p = get_apacket();
285    p->msg.command = A_SYNC;
286    p->msg.arg0 = 0;
287    p->msg.arg1 = 0;
288    p->msg.magic = A_SYNC ^ 0xffffffff;
289    if(write_packet(t->fd, t->serial, &p)) {
290        put_apacket(p);
291        D("%s: failed to write SYNC apacket to transport", t->serial);
292    }
293
294oops:
295    D("%s: transport output thread is exiting\n", t->serial);
296    kick_transport(t);
297    transport_unref(t);
298    return 0;
299}
300
301static void *input_thread(void *_t)
302{
303    atransport *t = reinterpret_cast<atransport*>(_t);
304    apacket *p;
305    int active = 0;
306
307    D("%s: starting transport input thread, reading from fd %d\n",
308       t->serial, t->fd);
309
310    for(;;){
311        if(read_packet(t->fd, t->serial, &p)) {
312            D("%s: failed to read apacket from transport on fd %d\n",
313               t->serial, t->fd );
314            break;
315        }
316        if(p->msg.command == A_SYNC){
317            if(p->msg.arg0 == 0) {
318                D("%s: transport SYNC offline\n", t->serial);
319                put_apacket(p);
320                break;
321            } else {
322                if(p->msg.arg1 == t->sync_token) {
323                    D("%s: transport SYNC online\n", t->serial);
324                    active = 1;
325                } else {
326                    D("%s: transport ignoring SYNC %d != %d\n",
327                      t->serial, p->msg.arg1, t->sync_token);
328                }
329            }
330        } else {
331            if(active) {
332                D("%s: transport got packet, sending to remote\n", t->serial);
333                t->write_to_remote(p, t);
334            } else {
335                D("%s: transport ignoring packet while offline\n", t->serial);
336            }
337        }
338
339        put_apacket(p);
340    }
341
342    // this is necessary to avoid a race condition that occured when a transport closes
343    // while a client socket is still active.
344    close_all_sockets(t);
345
346    D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
347    kick_transport(t);
348    transport_unref(t);
349    return 0;
350}
351
352
353static int transport_registration_send = -1;
354static int transport_registration_recv = -1;
355static fdevent transport_registration_fde;
356
357
358#if ADB_HOST
359
360/* this adds support required by the 'track-devices' service.
361 * this is used to send the content of "list_transport" to any
362 * number of client connections that want it through a single
363 * live TCP connection
364 */
365struct device_tracker {
366    asocket          socket;
367    int              update_needed;
368    device_tracker*  next;
369};
370
371/* linked list of all device trackers */
372static device_tracker*   device_tracker_list;
373
374static void
375device_tracker_remove( device_tracker*  tracker )
376{
377    device_tracker**  pnode = &device_tracker_list;
378    device_tracker*   node  = *pnode;
379
380    adb_mutex_lock( &transport_lock );
381    while (node) {
382        if (node == tracker) {
383            *pnode = node->next;
384            break;
385        }
386        pnode = &node->next;
387        node  = *pnode;
388    }
389    adb_mutex_unlock( &transport_lock );
390}
391
392static void
393device_tracker_close( asocket*  socket )
394{
395    device_tracker*  tracker = (device_tracker*) socket;
396    asocket*         peer    = socket->peer;
397
398    D( "device tracker %p removed\n", tracker);
399    if (peer) {
400        peer->peer = NULL;
401        peer->close(peer);
402    }
403    device_tracker_remove(tracker);
404    free(tracker);
405}
406
407static int
408device_tracker_enqueue( asocket*  socket, apacket*  p )
409{
410    /* you can't read from a device tracker, close immediately */
411    put_apacket(p);
412    device_tracker_close(socket);
413    return -1;
414}
415
416static int device_tracker_send(device_tracker* tracker, const std::string& string) {
417    apacket* p = get_apacket();
418    asocket* peer = tracker->socket.peer;
419
420    snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size()));
421    memcpy(&p->data[4], string.data(), string.size());
422    p->len = 4 + string.size();
423    return peer->enqueue(peer, p);
424}
425
426static void device_tracker_ready(asocket* socket) {
427    device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
428
429    // We want to send the device list when the tracker connects
430    // for the first time, even if no update occurred.
431    if (tracker->update_needed > 0) {
432        tracker->update_needed = 0;
433
434        std::string transports = list_transports(false);
435        device_tracker_send(tracker, transports);
436    }
437}
438
439asocket*
440create_device_tracker(void)
441{
442    device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
443    if (tracker == nullptr) fatal("cannot allocate device tracker");
444
445    D( "device tracker %p created\n", tracker);
446
447    tracker->socket.enqueue = device_tracker_enqueue;
448    tracker->socket.ready   = device_tracker_ready;
449    tracker->socket.close   = device_tracker_close;
450    tracker->update_needed  = 1;
451
452    tracker->next       = device_tracker_list;
453    device_tracker_list = tracker;
454
455    return &tracker->socket;
456}
457
458
459// Call this function each time the transport list has changed.
460void update_transports() {
461    std::string transports = list_transports(false);
462
463    device_tracker* tracker = device_tracker_list;
464    while (tracker != nullptr) {
465        device_tracker* next = tracker->next;
466        // This may destroy the tracker if the connection is closed.
467        device_tracker_send(tracker, transports);
468        tracker = next;
469    }
470}
471
472#else
473
474void update_transports() {
475    // Nothing to do on the device side.
476}
477
478#endif // ADB_HOST
479
480struct tmsg
481{
482    atransport *transport;
483    int         action;
484};
485
486static int
487transport_read_action(int  fd, struct tmsg*  m)
488{
489    char *p   = (char*)m;
490    int   len = sizeof(*m);
491    int   r;
492
493    while(len > 0) {
494        r = adb_read(fd, p, len);
495        if(r > 0) {
496            len -= r;
497            p   += r;
498        } else {
499            if((r < 0) && (errno == EINTR)) continue;
500            D("transport_read_action: on fd %d, error %d: %s\n",
501              fd, errno, strerror(errno));
502            return -1;
503        }
504    }
505    return 0;
506}
507
508static int
509transport_write_action(int  fd, struct tmsg*  m)
510{
511    char *p   = (char*)m;
512    int   len = sizeof(*m);
513    int   r;
514
515    while(len > 0) {
516        r = adb_write(fd, p, len);
517        if(r > 0) {
518            len -= r;
519            p   += r;
520        } else {
521            if((r < 0) && (errno == EINTR)) continue;
522            D("transport_write_action: on fd %d, error %d: %s\n",
523              fd, errno, strerror(errno));
524            return -1;
525        }
526    }
527    return 0;
528}
529
530static void transport_registration_func(int _fd, unsigned ev, void *data)
531{
532    tmsg m;
533    adb_thread_t output_thread_ptr;
534    adb_thread_t input_thread_ptr;
535    int s[2];
536    atransport *t;
537
538    if(!(ev & FDE_READ)) {
539        return;
540    }
541
542    if(transport_read_action(_fd, &m)) {
543        fatal_errno("cannot read transport registration socket");
544    }
545
546    t = m.transport;
547
548    if(m.action == 0){
549        D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
550
551            /* IMPORTANT: the remove closes one half of the
552            ** socket pair.  The close closes the other half.
553            */
554        fdevent_remove(&(t->transport_fde));
555        adb_close(t->fd);
556
557        adb_mutex_lock(&transport_lock);
558        t->next->prev = t->prev;
559        t->prev->next = t->next;
560        adb_mutex_unlock(&transport_lock);
561
562        run_transport_disconnects(t);
563
564        if (t->product)
565            free(t->product);
566        if (t->serial)
567            free(t->serial);
568        if (t->model)
569            free(t->model);
570        if (t->device)
571            free(t->device);
572        if (t->devpath)
573            free(t->devpath);
574
575        memset(t,0xee,sizeof(atransport));
576        free(t);
577
578        update_transports();
579        return;
580    }
581
582    /* don't create transport threads for inaccessible devices */
583    if (t->connection_state != CS_NOPERM) {
584        /* initial references are the two threads */
585        t->ref_count = 2;
586
587        if(adb_socketpair(s)) {
588            fatal_errno("cannot open transport socketpair");
589        }
590
591        D("transport: %s socketpair: (%d,%d) starting", t->serial, s[0], s[1]);
592
593        t->transport_socket = s[0];
594        t->fd = s[1];
595
596        fdevent_install(&(t->transport_fde),
597                        t->transport_socket,
598                        transport_socket_events,
599                        t);
600
601        fdevent_set(&(t->transport_fde), FDE_READ);
602
603        if(adb_thread_create(&input_thread_ptr, input_thread, t)){
604            fatal_errno("cannot create input thread");
605        }
606
607        if(adb_thread_create(&output_thread_ptr, output_thread, t)){
608            fatal_errno("cannot create output thread");
609        }
610    }
611
612    adb_mutex_lock(&transport_lock);
613    /* remove from pending list */
614    t->next->prev = t->prev;
615    t->prev->next = t->next;
616    /* put us on the master device list */
617    t->next = &transport_list;
618    t->prev = transport_list.prev;
619    t->next->prev = t;
620    t->prev->next = t;
621    adb_mutex_unlock(&transport_lock);
622
623    t->disconnects.next = t->disconnects.prev = &t->disconnects;
624
625    update_transports();
626}
627
628void init_transport_registration(void)
629{
630    int s[2];
631
632    if(adb_socketpair(s)){
633        fatal_errno("cannot open transport registration socketpair");
634    }
635    D("socketpair: (%d,%d)", s[0], s[1]);
636
637    transport_registration_send = s[0];
638    transport_registration_recv = s[1];
639
640    fdevent_install(&transport_registration_fde,
641                    transport_registration_recv,
642                    transport_registration_func,
643                    0);
644
645    fdevent_set(&transport_registration_fde, FDE_READ);
646}
647
648/* the fdevent select pump is single threaded */
649static void register_transport(atransport *transport)
650{
651    tmsg m;
652    m.transport = transport;
653    m.action = 1;
654    D("transport: %s registered\n", transport->serial);
655    if(transport_write_action(transport_registration_send, &m)) {
656        fatal_errno("cannot write transport registration socket\n");
657    }
658}
659
660static void remove_transport(atransport *transport)
661{
662    tmsg m;
663    m.transport = transport;
664    m.action = 0;
665    D("transport: %s removed\n", transport->serial);
666    if(transport_write_action(transport_registration_send, &m)) {
667        fatal_errno("cannot write transport registration socket\n");
668    }
669}
670
671
672static void transport_unref_locked(atransport *t)
673{
674    t->ref_count--;
675    if (t->ref_count == 0) {
676        D("transport: %s unref (kicking and closing)\n", t->serial);
677        if (!t->kicked) {
678            t->kicked = 1;
679            t->kick(t);
680        }
681        t->close(t);
682        remove_transport(t);
683    } else {
684        D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
685    }
686}
687
688static void transport_unref(atransport *t)
689{
690    if (t) {
691        adb_mutex_lock(&transport_lock);
692        transport_unref_locked(t);
693        adb_mutex_unlock(&transport_lock);
694    }
695}
696
697void add_transport_disconnect(atransport*  t, adisconnect*  dis)
698{
699    adb_mutex_lock(&transport_lock);
700    dis->next       = &t->disconnects;
701    dis->prev       = dis->next->prev;
702    dis->prev->next = dis;
703    dis->next->prev = dis;
704    adb_mutex_unlock(&transport_lock);
705}
706
707void remove_transport_disconnect(atransport*  t, adisconnect*  dis)
708{
709    dis->prev->next = dis->next;
710    dis->next->prev = dis->prev;
711    dis->next = dis->prev = dis;
712}
713
714static int qual_match(const char *to_test,
715                      const char *prefix, const char *qual, bool sanitize_qual)
716{
717    if (!to_test || !*to_test)
718        /* Return true if both the qual and to_test are null strings. */
719        return !qual || !*qual;
720
721    if (!qual)
722        return 0;
723
724    if (prefix) {
725        while (*prefix) {
726            if (*prefix++ != *to_test++)
727                return 0;
728        }
729    }
730
731    while (*qual) {
732        char ch = *qual++;
733        if (sanitize_qual && !isalnum(ch))
734            ch = '_';
735        if (ch != *to_test++)
736            return 0;
737    }
738
739    /* Everything matched so far.  Return true if *to_test is a NUL. */
740    return !*to_test;
741}
742
743atransport* acquire_one_transport(int state, transport_type ttype,
744                                  const char* serial, std::string* error_out)
745{
746    atransport *t;
747    atransport *result = NULL;
748    int ambiguous = 0;
749
750retry:
751    if (error_out) *error_out = android::base::StringPrintf("device '%s' not found", serial);
752
753    adb_mutex_lock(&transport_lock);
754    for (t = transport_list.next; t != &transport_list; t = t->next) {
755        if (t->connection_state == CS_NOPERM) {
756            if (error_out) *error_out = "insufficient permissions for device";
757            continue;
758        }
759
760        /* check for matching serial number */
761        if (serial) {
762            if ((t->serial && !strcmp(serial, t->serial)) ||
763                (t->devpath && !strcmp(serial, t->devpath)) ||
764                qual_match(serial, "product:", t->product, false) ||
765                qual_match(serial, "model:", t->model, true) ||
766                qual_match(serial, "device:", t->device, false)) {
767                if (result) {
768                    if (error_out) *error_out = "more than one device";
769                    ambiguous = 1;
770                    result = NULL;
771                    break;
772                }
773                result = t;
774            }
775        } else {
776            if (ttype == kTransportUsb && t->type == kTransportUsb) {
777                if (result) {
778                    if (error_out) *error_out = "more than one device";
779                    ambiguous = 1;
780                    result = NULL;
781                    break;
782                }
783                result = t;
784            } else if (ttype == kTransportLocal && t->type == kTransportLocal) {
785                if (result) {
786                    if (error_out) *error_out = "more than one emulator";
787                    ambiguous = 1;
788                    result = NULL;
789                    break;
790                }
791                result = t;
792            } else if (ttype == kTransportAny) {
793                if (result) {
794                    if (error_out) *error_out = "more than one device/emulator";
795                    ambiguous = 1;
796                    result = NULL;
797                    break;
798                }
799                result = t;
800            }
801        }
802    }
803    adb_mutex_unlock(&transport_lock);
804
805    if (result) {
806        if (result->connection_state == CS_UNAUTHORIZED) {
807            if (error_out) {
808                *error_out = "device unauthorized.\n";
809                char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
810                *error_out += "This adbd's $ADB_VENDOR_KEYS is ";
811                *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
812                *error_out += "; try 'adb kill-server' if that seems wrong.\n";
813                *error_out += "Otherwise check for a confirmation dialog on your device.";
814            }
815            result = NULL;
816        }
817
818        /* offline devices are ignored -- they are either being born or dying */
819        if (result && result->connection_state == CS_OFFLINE) {
820            if (error_out) *error_out = "device offline";
821            result = NULL;
822        }
823
824        /* check for required connection state */
825        if (result && state != CS_ANY && result->connection_state != state) {
826            if (error_out) *error_out = "invalid device state";
827            result = NULL;
828        }
829    }
830
831    if (result) {
832        /* found one that we can take */
833        if (error_out) *error_out = "success";
834    } else if (state != CS_ANY && (serial || !ambiguous)) {
835        adb_sleep_ms(1000);
836        goto retry;
837    }
838
839    return result;
840}
841
842const char* atransport::connection_state_name() const {
843    switch (connection_state) {
844    case CS_OFFLINE: return "offline";
845    case CS_BOOTLOADER: return "bootloader";
846    case CS_DEVICE: return "device";
847    case CS_HOST: return "host";
848    case CS_RECOVERY: return "recovery";
849    case CS_NOPERM: return "no permissions";
850    case CS_SIDELOAD: return "sideload";
851    case CS_UNAUTHORIZED: return "unauthorized";
852    default: return "unknown";
853    }
854}
855
856#if ADB_HOST
857
858static void append_transport_info(std::string* result, const char* key,
859                                  const char* value, bool sanitize) {
860    if (value == nullptr || *value == '\0') {
861        return;
862    }
863
864    *result += ' ';
865    *result += key;
866
867    for (const char* p = value; *p; ++p) {
868        result->push_back((!sanitize || isalnum(*p)) ? *p : '_');
869    }
870}
871
872static void append_transport(atransport* t, std::string* result, bool long_listing) {
873    const char* serial = t->serial;
874    if (!serial || !serial[0]) {
875        serial = "(no serial number)";
876    }
877
878    if (!long_listing) {
879        *result += serial;
880        *result += '\t';
881        *result += t->connection_state_name();
882    } else {
883        android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name());
884
885        append_transport_info(result, "", t->devpath, false);
886        append_transport_info(result, "product:", t->product, false);
887        append_transport_info(result, "model:", t->model, true);
888        append_transport_info(result, "device:", t->device, false);
889    }
890    *result += '\n';
891}
892
893std::string list_transports(bool long_listing) {
894    std::string result;
895    adb_mutex_lock(&transport_lock);
896    for (atransport* t = transport_list.next; t != &transport_list; t = t->next) {
897        append_transport(t, &result, long_listing);
898    }
899    adb_mutex_unlock(&transport_lock);
900    return result;
901}
902
903/* hack for osx */
904void close_usb_devices()
905{
906    adb_mutex_lock(&transport_lock);
907    for (atransport* t = transport_list.next; t != &transport_list; t = t->next) {
908        if ( !t->kicked ) {
909            t->kicked = 1;
910            t->kick(t);
911        }
912    }
913    adb_mutex_unlock(&transport_lock);
914}
915#endif // ADB_HOST
916
917int register_socket_transport(int s, const char *serial, int port, int local)
918{
919    atransport *t = reinterpret_cast<atransport*>(calloc(1, sizeof(atransport)));
920    if (t == nullptr) {
921        return -1;
922    }
923
924    atransport *n;
925    char buff[32];
926
927    if (!serial) {
928        snprintf(buff, sizeof buff, "T-%p", t);
929        serial = buff;
930    }
931    D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
932    if (init_socket_transport(t, s, port, local) < 0) {
933        free(t);
934        return -1;
935    }
936
937    adb_mutex_lock(&transport_lock);
938    for (n = pending_list.next; n != &pending_list; n = n->next) {
939        if (n->serial && !strcmp(serial, n->serial)) {
940            adb_mutex_unlock(&transport_lock);
941            free(t);
942            return -1;
943        }
944    }
945
946    for (n = transport_list.next; n != &transport_list; n = n->next) {
947        if (n->serial && !strcmp(serial, n->serial)) {
948            adb_mutex_unlock(&transport_lock);
949            free(t);
950            return -1;
951        }
952    }
953
954    t->next = &pending_list;
955    t->prev = pending_list.prev;
956    t->next->prev = t;
957    t->prev->next = t;
958    t->serial = strdup(serial);
959    adb_mutex_unlock(&transport_lock);
960
961    register_transport(t);
962    return 0;
963}
964
965#if ADB_HOST
966atransport *find_transport(const char *serial)
967{
968    atransport *t;
969
970    adb_mutex_lock(&transport_lock);
971    for(t = transport_list.next; t != &transport_list; t = t->next) {
972        if (t->serial && !strcmp(serial, t->serial)) {
973            break;
974        }
975     }
976    adb_mutex_unlock(&transport_lock);
977
978    if (t != &transport_list)
979        return t;
980    else
981        return 0;
982}
983
984void unregister_transport(atransport *t)
985{
986    adb_mutex_lock(&transport_lock);
987    t->next->prev = t->prev;
988    t->prev->next = t->next;
989    adb_mutex_unlock(&transport_lock);
990
991    kick_transport(t);
992    transport_unref(t);
993}
994
995// unregisters all non-emulator TCP transports
996void unregister_all_tcp_transports()
997{
998    atransport *t, *next;
999    adb_mutex_lock(&transport_lock);
1000    for (t = transport_list.next; t != &transport_list; t = next) {
1001        next = t->next;
1002        if (t->type == kTransportLocal && t->adb_port == 0) {
1003            t->next->prev = t->prev;
1004            t->prev->next = next;
1005            // we cannot call kick_transport when holding transport_lock
1006            if (!t->kicked)
1007            {
1008                t->kicked = 1;
1009                t->kick(t);
1010            }
1011            transport_unref_locked(t);
1012        }
1013     }
1014
1015    adb_mutex_unlock(&transport_lock);
1016}
1017
1018#endif
1019
1020void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable)
1021{
1022    atransport *t = reinterpret_cast<atransport*>(calloc(1, sizeof(atransport)));
1023    if (t == nullptr) fatal("cannot allocate USB atransport");
1024    D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
1025      serial ? serial : "");
1026    init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM));
1027    if(serial) {
1028        t->serial = strdup(serial);
1029    }
1030    if(devpath) {
1031        t->devpath = strdup(devpath);
1032    }
1033
1034    adb_mutex_lock(&transport_lock);
1035    t->next = &pending_list;
1036    t->prev = pending_list.prev;
1037    t->next->prev = t;
1038    t->prev->next = t;
1039    adb_mutex_unlock(&transport_lock);
1040
1041    register_transport(t);
1042}
1043
1044/* this should only be used for transports with connection_state == CS_NOPERM */
1045void unregister_usb_transport(usb_handle *usb)
1046{
1047    atransport *t;
1048    adb_mutex_lock(&transport_lock);
1049    for(t = transport_list.next; t != &transport_list; t = t->next) {
1050        if (t->usb == usb && t->connection_state == CS_NOPERM) {
1051            t->next->prev = t->prev;
1052            t->prev->next = t->next;
1053            break;
1054        }
1055     }
1056    adb_mutex_unlock(&transport_lock);
1057}
1058
1059#undef TRACE_TAG
1060#define TRACE_TAG  TRACE_RWX
1061
1062int check_header(apacket *p)
1063{
1064    if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1065        D("check_header(): invalid magic\n");
1066        return -1;
1067    }
1068
1069    if(p->msg.data_length > MAX_PAYLOAD) {
1070        D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length);
1071        return -1;
1072    }
1073
1074    return 0;
1075}
1076
1077int check_data(apacket *p)
1078{
1079    unsigned count, sum;
1080    unsigned char *x;
1081
1082    count = p->msg.data_length;
1083    x = p->data;
1084    sum = 0;
1085    while(count-- > 0) {
1086        sum += *x++;
1087    }
1088
1089    if(sum != p->msg.data_check) {
1090        return -1;
1091    } else {
1092        return 0;
1093    }
1094}
1095