Home | History | Annotate | Download | only in adb 
      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 TRANSPORT
     18 
     19 #include "sysdeps.h"
     20 #include "transport.h"
     21 
     22 #include <ctype.h>
     23 #include <errno.h>
     24 #include <inttypes.h>
     25 #include <stdio.h>
     26 #include <stdlib.h>
     27 #include <string.h>
     28 #include <unistd.h>
     29 
     30 #include <algorithm>
     31 #include <list>
     32 #include <mutex>
     33 #include <thread>
     34 
     35 #include <android-base/logging.h>
     36 #include <android-base/parsenetaddress.h>
     37 #include <android-base/quick_exit.h>
     38 #include <android-base/stringprintf.h>
     39 #include <android-base/strings.h>
     40 #include <android-base/thread_annotations.h>
     41 
     42 #include "adb.h"
     43 #include "adb_auth.h"
     44 #include "adb_trace.h"
     45 #include "adb_utils.h"
     46 #include "diagnose_usb.h"
     47 #include "fdevent.h"
     48 
     49 static void transport_unref(atransport *t);
     50 
     51 // TODO: unordered_map<TransportId, atransport*>
     52 static auto& transport_list = *new std::list<atransport*>();
     53 static auto& pending_list = *new std::list<atransport*>();
     54 
     55 static auto& transport_lock = *new std::recursive_mutex();
     56 
     57 const char* const kFeatureShell2 = "shell_v2";
     58 const char* const kFeatureCmd = "cmd";
     59 const char* const kFeatureStat2 = "stat_v2";
     60 const char* const kFeatureLibusb = "libusb";
     61 const char* const kFeaturePushSync = "push_sync";
     62 
     63 TransportId NextTransportId() {
     64     static std::atomic<TransportId> next(1);
     65     return next++;
     66 }
     67 
     68 static std::string dump_packet(const char* name, const char* func, apacket* p) {
     69     unsigned command = p->msg.command;
     70     int len = p->msg.data_length;
     71     char cmd[9];
     72     char arg0[12], arg1[12];
     73     int n;
     74 
     75     for (n = 0; n < 4; n++) {
     76         int b = (command >> (n * 8)) & 255;
     77         if (b < 32 || b >= 127) break;
     78         cmd[n] = (char)b;
     79     }
     80     if (n == 4) {
     81         cmd[4] = 0;
     82     } else {
     83         /* There is some non-ASCII name in the command, so dump
     84             * the hexadecimal value instead */
     85         snprintf(cmd, sizeof cmd, "%08x", command);
     86     }
     87 
     88     if (p->msg.arg0 < 256U)
     89         snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
     90     else
     91         snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
     92 
     93     if (p->msg.arg1 < 256U)
     94         snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
     95     else
     96         snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
     97 
     98     std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ", name,
     99                                                      func, cmd, arg0, arg1, len);
    100     result += dump_hex(p->data, len);
    101     return result;
    102 }
    103 
    104 static int read_packet(int fd, const char* name, apacket** ppacket) {
    105     ATRACE_NAME("read_packet");
    106     char buff[8];
    107     if (!name) {
    108         snprintf(buff, sizeof buff, "fd=%d", fd);
    109         name = buff;
    110     }
    111     char* p = reinterpret_cast<char*>(ppacket); /* really read a packet address */
    112     int len = sizeof(apacket*);
    113     while (len > 0) {
    114         int r = adb_read(fd, p, len);
    115         if (r > 0) {
    116             len -= r;
    117             p += r;
    118         } else {
    119             D("%s: read_packet (fd=%d), error ret=%d: %s", name, fd, r, strerror(errno));
    120             return -1;
    121         }
    122     }
    123 
    124     VLOG(TRANSPORT) << dump_packet(name, "from remote", *ppacket);
    125     return 0;
    126 }
    127 
    128 static int write_packet(int fd, const char* name, apacket** ppacket) {
    129     ATRACE_NAME("write_packet");
    130     char buff[8];
    131     if (!name) {
    132         snprintf(buff, sizeof buff, "fd=%d", fd);
    133         name = buff;
    134     }
    135     VLOG(TRANSPORT) << dump_packet(name, "to remote", *ppacket);
    136     char* p = reinterpret_cast<char*>(ppacket); /* we really write the packet address */
    137     int len = sizeof(apacket*);
    138     while (len > 0) {
    139         int r = adb_write(fd, p, len);
    140         if (r > 0) {
    141             len -= r;
    142             p += r;
    143         } else {
    144             D("%s: write_packet (fd=%d) error ret=%d: %s", name, fd, r, strerror(errno));
    145             return -1;
    146         }
    147     }
    148     return 0;
    149 }
    150 
    151 static void transport_socket_events(int fd, unsigned events, void* _t) {
    152     atransport* t = reinterpret_cast<atransport*>(_t);
    153     D("transport_socket_events(fd=%d, events=%04x,...)", fd, events);
    154     if (events & FDE_READ) {
    155         apacket* p = 0;
    156         if (read_packet(fd, t->serial, &p)) {
    157             D("%s: failed to read packet from transport socket on fd %d", t->serial, fd);
    158         } else {
    159             handle_packet(p, (atransport*)_t);
    160         }
    161     }
    162 }
    163 
    164 void send_packet(apacket* p, atransport* t) {
    165     p->msg.magic = p->msg.command ^ 0xffffffff;
    166     p->msg.data_check = calculate_apacket_checksum(p);
    167 
    168     print_packet("send", p);
    169 
    170     if (t == NULL) {
    171         fatal("Transport is null");
    172     }
    173 
    174     if (write_packet(t->transport_socket, t->serial, &p)) {
    175         fatal_errno("cannot enqueue packet on transport socket");
    176     }
    177 }
    178 
    179 // The transport is opened by transport_register_func before
    180 // the read_transport and write_transport threads are started.
    181 //
    182 // The read_transport thread issues a SYNC(1, token) message to let
    183 // the write_transport thread know to start things up.  In the event
    184 // of transport IO failure, the read_transport thread will post a
    185 // SYNC(0,0) message to ensure shutdown.
    186 //
    187 // The transport will not actually be closed until both threads exit, but the threads
    188 // will kick the transport on their way out to disconnect the underlying device.
    189 //
    190 // read_transport thread reads data from a transport (representing a usb/tcp connection),
    191 // and makes the main thread call handle_packet().
    192 static void read_transport_thread(void* _t) {
    193     atransport* t = reinterpret_cast<atransport*>(_t);
    194     apacket* p;
    195 
    196     adb_thread_setname(
    197         android::base::StringPrintf("<-%s", (t->serial != nullptr ? t->serial : "transport")));
    198     D("%s: starting read_transport thread on fd %d, SYNC online (%d)", t->serial, t->fd,
    199       t->sync_token + 1);
    200     p = get_apacket();
    201     p->msg.command = A_SYNC;
    202     p->msg.arg0 = 1;
    203     p->msg.arg1 = ++(t->sync_token);
    204     p->msg.magic = A_SYNC ^ 0xffffffff;
    205     if (write_packet(t->fd, t->serial, &p)) {
    206         put_apacket(p);
    207         D("%s: failed to write SYNC packet", t->serial);
    208         goto oops;
    209     }
    210 
    211     D("%s: data pump started", t->serial);
    212     for (;;) {
    213         ATRACE_NAME("read_transport loop");
    214         p = get_apacket();
    215 
    216         {
    217             ATRACE_NAME("read_transport read_remote");
    218             if (t->read_from_remote(p, t) != 0) {
    219                 D("%s: remote read failed for transport", t->serial);
    220                 put_apacket(p);
    221                 break;
    222             }
    223 #if ADB_HOST
    224             if (p->msg.command == 0) {
    225                 continue;
    226             }
    227 #endif
    228         }
    229 
    230         D("%s: received remote packet, sending to transport", t->serial);
    231         if (write_packet(t->fd, t->serial, &p)) {
    232             put_apacket(p);
    233             D("%s: failed to write apacket to transport", t->serial);
    234             goto oops;
    235         }
    236     }
    237 
    238     D("%s: SYNC offline for transport", t->serial);
    239     p = get_apacket();
    240     p->msg.command = A_SYNC;
    241     p->msg.arg0 = 0;
    242     p->msg.arg1 = 0;
    243     p->msg.magic = A_SYNC ^ 0xffffffff;
    244     if (write_packet(t->fd, t->serial, &p)) {
    245         put_apacket(p);
    246         D("%s: failed to write SYNC apacket to transport", t->serial);
    247     }
    248 
    249 oops:
    250     D("%s: read_transport thread is exiting", t->serial);
    251     kick_transport(t);
    252     transport_unref(t);
    253 }
    254 
    255 // write_transport thread gets packets sent by the main thread (through send_packet()),
    256 // and writes to a transport (representing a usb/tcp connection).
    257 static void write_transport_thread(void* _t) {
    258     atransport* t = reinterpret_cast<atransport*>(_t);
    259     apacket* p;
    260     int active = 0;
    261 
    262     adb_thread_setname(
    263         android::base::StringPrintf("->%s", (t->serial != nullptr ? t->serial : "transport")));
    264     D("%s: starting write_transport thread, reading from fd %d", t->serial, t->fd);
    265 
    266     for (;;) {
    267         ATRACE_NAME("write_transport loop");
    268         if (read_packet(t->fd, t->serial, &p)) {
    269             D("%s: failed to read apacket from transport on fd %d", t->serial, t->fd);
    270             break;
    271         }
    272 
    273         if (p->msg.command == A_SYNC) {
    274             if (p->msg.arg0 == 0) {
    275                 D("%s: transport SYNC offline", t->serial);
    276                 put_apacket(p);
    277                 break;
    278             } else {
    279                 if (p->msg.arg1 == t->sync_token) {
    280                     D("%s: transport SYNC online", t->serial);
    281                     active = 1;
    282                 } else {
    283                     D("%s: transport ignoring SYNC %d != %d", t->serial, p->msg.arg1, t->sync_token);
    284                 }
    285             }
    286         } else {
    287             if (active) {
    288                 D("%s: transport got packet, sending to remote", t->serial);
    289                 ATRACE_NAME("write_transport write_remote");
    290                 if (t->Write(p) != 0) {
    291                     D("%s: remote write failed for transport", t->serial);
    292                     put_apacket(p);
    293                     break;
    294                 }
    295             } else {
    296                 D("%s: transport ignoring packet while offline", t->serial);
    297             }
    298         }
    299 
    300         put_apacket(p);
    301     }
    302 
    303     D("%s: write_transport thread is exiting, fd %d", t->serial, t->fd);
    304     kick_transport(t);
    305     transport_unref(t);
    306 }
    307 
    308 void kick_transport(atransport* t) {
    309     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    310     // As kick_transport() can be called from threads without guarantee that t is valid,
    311     // check if the transport is in transport_list first.
    312     //
    313     // TODO(jmgao): WTF? Is this actually true?
    314     if (std::find(transport_list.begin(), transport_list.end(), t) != transport_list.end()) {
    315         t->Kick();
    316     }
    317 }
    318 
    319 static int transport_registration_send = -1;
    320 static int transport_registration_recv = -1;
    321 static fdevent transport_registration_fde;
    322 
    323 #if ADB_HOST
    324 
    325 /* this adds support required by the 'track-devices' service.
    326  * this is used to send the content of "list_transport" to any
    327  * number of client connections that want it through a single
    328  * live TCP connection
    329  */
    330 struct device_tracker {
    331     asocket socket;
    332     int update_needed;
    333     device_tracker* next;
    334 };
    335 
    336 /* linked list of all device trackers */
    337 static device_tracker* device_tracker_list;
    338 
    339 static void device_tracker_remove(device_tracker* tracker) {
    340     device_tracker** pnode = &device_tracker_list;
    341     device_tracker* node = *pnode;
    342 
    343     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    344     while (node) {
    345         if (node == tracker) {
    346             *pnode = node->next;
    347             break;
    348         }
    349         pnode = &node->next;
    350         node = *pnode;
    351     }
    352 }
    353 
    354 static void device_tracker_close(asocket* socket) {
    355     device_tracker* tracker = (device_tracker*)socket;
    356     asocket* peer = socket->peer;
    357 
    358     D("device tracker %p removed", tracker);
    359     if (peer) {
    360         peer->peer = NULL;
    361         peer->close(peer);
    362     }
    363     device_tracker_remove(tracker);
    364     free(tracker);
    365 }
    366 
    367 static int device_tracker_enqueue(asocket* socket, apacket* p) {
    368     /* you can't read from a device tracker, close immediately */
    369     put_apacket(p);
    370     device_tracker_close(socket);
    371     return -1;
    372 }
    373 
    374 static int device_tracker_send(device_tracker* tracker, const std::string& string) {
    375     apacket* p = get_apacket();
    376     asocket* peer = tracker->socket.peer;
    377 
    378     snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size()));
    379     memcpy(&p->data[4], string.data(), string.size());
    380     p->len = 4 + string.size();
    381     return peer->enqueue(peer, p);
    382 }
    383 
    384 static void device_tracker_ready(asocket* socket) {
    385     device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
    386 
    387     // We want to send the device list when the tracker connects
    388     // for the first time, even if no update occurred.
    389     if (tracker->update_needed > 0) {
    390         tracker->update_needed = 0;
    391 
    392         std::string transports = list_transports(false);
    393         device_tracker_send(tracker, transports);
    394     }
    395 }
    396 
    397 asocket* create_device_tracker(void) {
    398     device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
    399     if (tracker == nullptr) fatal("cannot allocate device tracker");
    400 
    401     D("device tracker %p created", tracker);
    402 
    403     tracker->socket.enqueue = device_tracker_enqueue;
    404     tracker->socket.ready = device_tracker_ready;
    405     tracker->socket.close = device_tracker_close;
    406     tracker->update_needed = 1;
    407 
    408     tracker->next = device_tracker_list;
    409     device_tracker_list = tracker;
    410 
    411     return &tracker->socket;
    412 }
    413 
    414 // Check if all of the USB transports are connected.
    415 bool iterate_transports(std::function<bool(const atransport*)> fn) {
    416     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    417     for (const auto& t : transport_list) {
    418         if (!fn(t)) {
    419             return false;
    420         }
    421     }
    422     for (const auto& t : pending_list) {
    423         if (!fn(t)) {
    424             return false;
    425         }
    426     }
    427     return true;
    428 }
    429 
    430 // Call this function each time the transport list has changed.
    431 void update_transports() {
    432     update_transport_status();
    433 
    434     // Notify `adb track-devices` clients.
    435     std::string transports = list_transports(false);
    436 
    437     device_tracker* tracker = device_tracker_list;
    438     while (tracker != nullptr) {
    439         device_tracker* next = tracker->next;
    440         // This may destroy the tracker if the connection is closed.
    441         device_tracker_send(tracker, transports);
    442         tracker = next;
    443     }
    444 }
    445 
    446 #else
    447 
    448 void update_transports() {
    449     // Nothing to do on the device side.
    450 }
    451 
    452 #endif  // ADB_HOST
    453 
    454 struct tmsg {
    455     atransport* transport;
    456     int action;
    457 };
    458 
    459 static int transport_read_action(int fd, struct tmsg* m) {
    460     char* p = (char*)m;
    461     int len = sizeof(*m);
    462     int r;
    463 
    464     while (len > 0) {
    465         r = adb_read(fd, p, len);
    466         if (r > 0) {
    467             len -= r;
    468             p += r;
    469         } else {
    470             D("transport_read_action: on fd %d: %s", fd, strerror(errno));
    471             return -1;
    472         }
    473     }
    474     return 0;
    475 }
    476 
    477 static int transport_write_action(int fd, struct tmsg* m) {
    478     char* p = (char*)m;
    479     int len = sizeof(*m);
    480     int r;
    481 
    482     while (len > 0) {
    483         r = adb_write(fd, p, len);
    484         if (r > 0) {
    485             len -= r;
    486             p += r;
    487         } else {
    488             D("transport_write_action: on fd %d: %s", fd, strerror(errno));
    489             return -1;
    490         }
    491     }
    492     return 0;
    493 }
    494 
    495 static void transport_registration_func(int _fd, unsigned ev, void* data) {
    496     tmsg m;
    497     int s[2];
    498     atransport* t;
    499 
    500     if (!(ev & FDE_READ)) {
    501         return;
    502     }
    503 
    504     if (transport_read_action(_fd, &m)) {
    505         fatal_errno("cannot read transport registration socket");
    506     }
    507 
    508     t = m.transport;
    509 
    510     if (m.action == 0) {
    511         D("transport: %s removing and free'ing %d", t->serial, t->transport_socket);
    512 
    513         /* IMPORTANT: the remove closes one half of the
    514         ** socket pair.  The close closes the other half.
    515         */
    516         fdevent_remove(&(t->transport_fde));
    517         adb_close(t->fd);
    518 
    519         {
    520             std::lock_guard<std::recursive_mutex> lock(transport_lock);
    521             transport_list.remove(t);
    522         }
    523 
    524         if (t->product) free(t->product);
    525         if (t->serial) free(t->serial);
    526         if (t->model) free(t->model);
    527         if (t->device) free(t->device);
    528         if (t->devpath) free(t->devpath);
    529 
    530         delete t;
    531 
    532         update_transports();
    533         return;
    534     }
    535 
    536     /* don't create transport threads for inaccessible devices */
    537     if (t->GetConnectionState() != kCsNoPerm) {
    538         /* initial references are the two threads */
    539         t->ref_count = 2;
    540 
    541         if (adb_socketpair(s)) {
    542             fatal_errno("cannot open transport socketpair");
    543         }
    544 
    545         D("transport: %s socketpair: (%d,%d) starting", t->serial, s[0], s[1]);
    546 
    547         t->transport_socket = s[0];
    548         t->fd = s[1];
    549 
    550         fdevent_install(&(t->transport_fde), t->transport_socket, transport_socket_events, t);
    551 
    552         fdevent_set(&(t->transport_fde), FDE_READ);
    553 
    554         std::thread(write_transport_thread, t).detach();
    555         std::thread(read_transport_thread, t).detach();
    556     }
    557 
    558     {
    559         std::lock_guard<std::recursive_mutex> lock(transport_lock);
    560         pending_list.remove(t);
    561         transport_list.push_front(t);
    562     }
    563 
    564     update_transports();
    565 }
    566 
    567 void init_transport_registration(void) {
    568     int s[2];
    569 
    570     if (adb_socketpair(s)) {
    571         fatal_errno("cannot open transport registration socketpair");
    572     }
    573     D("socketpair: (%d,%d)", s[0], s[1]);
    574 
    575     transport_registration_send = s[0];
    576     transport_registration_recv = s[1];
    577 
    578     fdevent_install(&transport_registration_fde, transport_registration_recv,
    579                     transport_registration_func, 0);
    580 
    581     fdevent_set(&transport_registration_fde, FDE_READ);
    582 }
    583 
    584 void kick_all_transports() {
    585     // To avoid only writing part of a packet to a transport after exit, kick all transports.
    586     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    587     for (auto t : transport_list) {
    588         t->Kick();
    589     }
    590 }
    591 
    592 /* the fdevent select pump is single threaded */
    593 static void register_transport(atransport* transport) {
    594     tmsg m;
    595     m.transport = transport;
    596     m.action = 1;
    597     D("transport: %s registered", transport->serial);
    598     if (transport_write_action(transport_registration_send, &m)) {
    599         fatal_errno("cannot write transport registration socket\n");
    600     }
    601 }
    602 
    603 static void remove_transport(atransport* transport) {
    604     tmsg m;
    605     m.transport = transport;
    606     m.action = 0;
    607     D("transport: %s removed", transport->serial);
    608     if (transport_write_action(transport_registration_send, &m)) {
    609         fatal_errno("cannot write transport registration socket\n");
    610     }
    611 }
    612 
    613 static void transport_unref(atransport* t) {
    614     CHECK(t != nullptr);
    615 
    616     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    617     CHECK_GT(t->ref_count, 0u);
    618     t->ref_count--;
    619     if (t->ref_count == 0) {
    620         D("transport: %s unref (kicking and closing)", t->serial);
    621         t->close(t);
    622         remove_transport(t);
    623     } else {
    624         D("transport: %s unref (count=%zu)", t->serial, t->ref_count);
    625     }
    626 }
    627 
    628 static int qual_match(const char* to_test, const char* prefix, const char* qual,
    629                       bool sanitize_qual) {
    630     if (!to_test || !*to_test) /* Return true if both the qual and to_test are null strings. */
    631         return !qual || !*qual;
    632 
    633     if (!qual) return 0;
    634 
    635     if (prefix) {
    636         while (*prefix) {
    637             if (*prefix++ != *to_test++) return 0;
    638         }
    639     }
    640 
    641     while (*qual) {
    642         char ch = *qual++;
    643         if (sanitize_qual && !isalnum(ch)) ch = '_';
    644         if (ch != *to_test++) return 0;
    645     }
    646 
    647     /* Everything matched so far.  Return true if *to_test is a NUL. */
    648     return !*to_test;
    649 }
    650 
    651 atransport* acquire_one_transport(TransportType type, const char* serial, TransportId transport_id,
    652                                   bool* is_ambiguous, std::string* error_out,
    653                                   bool accept_any_state) {
    654     atransport* result = nullptr;
    655 
    656     if (transport_id != 0) {
    657         *error_out =
    658             android::base::StringPrintf("no device with transport id '%" PRIu64 "'", transport_id);
    659     } else if (serial) {
    660         *error_out = android::base::StringPrintf("device '%s' not found", serial);
    661     } else if (type == kTransportLocal) {
    662         *error_out = "no emulators found";
    663     } else if (type == kTransportAny) {
    664         *error_out = "no devices/emulators found";
    665     } else {
    666         *error_out = "no devices found";
    667     }
    668 
    669     std::unique_lock<std::recursive_mutex> lock(transport_lock);
    670     for (const auto& t : transport_list) {
    671         if (t->GetConnectionState() == kCsNoPerm) {
    672 #if ADB_HOST
    673             *error_out = UsbNoPermissionsLongHelpText();
    674 #endif
    675             continue;
    676         }
    677 
    678         if (transport_id) {
    679             if (t->id == transport_id) {
    680                 result = t;
    681                 break;
    682             }
    683         } else if (serial) {
    684             if (t->MatchesTarget(serial)) {
    685                 if (result) {
    686                     *error_out = "more than one device";
    687                     if (is_ambiguous) *is_ambiguous = true;
    688                     result = nullptr;
    689                     break;
    690                 }
    691                 result = t;
    692             }
    693         } else {
    694             if (type == kTransportUsb && t->type == kTransportUsb) {
    695                 if (result) {
    696                     *error_out = "more than one device";
    697                     if (is_ambiguous) *is_ambiguous = true;
    698                     result = nullptr;
    699                     break;
    700                 }
    701                 result = t;
    702             } else if (type == kTransportLocal && t->type == kTransportLocal) {
    703                 if (result) {
    704                     *error_out = "more than one emulator";
    705                     if (is_ambiguous) *is_ambiguous = true;
    706                     result = nullptr;
    707                     break;
    708                 }
    709                 result = t;
    710             } else if (type == kTransportAny) {
    711                 if (result) {
    712                     *error_out = "more than one device/emulator";
    713                     if (is_ambiguous) *is_ambiguous = true;
    714                     result = nullptr;
    715                     break;
    716                 }
    717                 result = t;
    718             }
    719         }
    720     }
    721     lock.unlock();
    722 
    723     // Don't return unauthorized devices; the caller can't do anything with them.
    724     if (result && result->GetConnectionState() == kCsUnauthorized && !accept_any_state) {
    725         *error_out = "device unauthorized.\n";
    726         char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
    727         *error_out += "This adb server's $ADB_VENDOR_KEYS is ";
    728         *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
    729         *error_out += "\n";
    730         *error_out += "Try 'adb kill-server' if that seems wrong.\n";
    731         *error_out += "Otherwise check for a confirmation dialog on your device.";
    732         result = nullptr;
    733     }
    734 
    735     // Don't return offline devices; the caller can't do anything with them.
    736     if (result && result->GetConnectionState() == kCsOffline && !accept_any_state) {
    737         *error_out = "device offline";
    738         result = nullptr;
    739     }
    740 
    741     if (result) {
    742         *error_out = "success";
    743     }
    744 
    745     return result;
    746 }
    747 
    748 int atransport::Write(apacket* p) {
    749     return write_func_(p, this);
    750 }
    751 
    752 void atransport::Kick() {
    753     if (!kicked_) {
    754         kicked_ = true;
    755         CHECK(kick_func_ != nullptr);
    756         kick_func_(this);
    757     }
    758 }
    759 
    760 ConnectionState atransport::GetConnectionState() const {
    761     return connection_state_;
    762 }
    763 
    764 void atransport::SetConnectionState(ConnectionState state) {
    765     check_main_thread();
    766     connection_state_ = state;
    767 }
    768 
    769 const std::string atransport::connection_state_name() const {
    770     ConnectionState state = GetConnectionState();
    771     switch (state) {
    772         case kCsOffline:
    773             return "offline";
    774         case kCsBootloader:
    775             return "bootloader";
    776         case kCsDevice:
    777             return "device";
    778         case kCsHost:
    779             return "host";
    780         case kCsRecovery:
    781             return "recovery";
    782         case kCsNoPerm:
    783             return UsbNoPermissionsShortHelpText();
    784         case kCsSideload:
    785             return "sideload";
    786         case kCsUnauthorized:
    787             return "unauthorized";
    788         default:
    789             return "unknown";
    790     }
    791 }
    792 
    793 void atransport::update_version(int version, size_t payload) {
    794     protocol_version = std::min(version, A_VERSION);
    795     max_payload = std::min(payload, MAX_PAYLOAD);
    796 }
    797 
    798 int atransport::get_protocol_version() const {
    799     return protocol_version;
    800 }
    801 
    802 size_t atransport::get_max_payload() const {
    803     return max_payload;
    804 }
    805 
    806 namespace {
    807 
    808 constexpr char kFeatureStringDelimiter = ',';
    809 
    810 }  // namespace
    811 
    812 const FeatureSet& supported_features() {
    813     // Local static allocation to avoid global non-POD variables.
    814     static const FeatureSet* features = new FeatureSet{
    815         kFeatureShell2, kFeatureCmd, kFeatureStat2,
    816         // Increment ADB_SERVER_VERSION whenever the feature list changes to
    817         // make sure that the adb client and server features stay in sync
    818         // (http://b/24370690).
    819     };
    820 
    821     return *features;
    822 }
    823 
    824 std::string FeatureSetToString(const FeatureSet& features) {
    825     return android::base::Join(features, kFeatureStringDelimiter);
    826 }
    827 
    828 FeatureSet StringToFeatureSet(const std::string& features_string) {
    829     if (features_string.empty()) {
    830         return FeatureSet();
    831     }
    832 
    833     auto names = android::base::Split(features_string, {kFeatureStringDelimiter});
    834     return FeatureSet(names.begin(), names.end());
    835 }
    836 
    837 bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
    838     return feature_set.count(feature) > 0 && supported_features().count(feature) > 0;
    839 }
    840 
    841 bool atransport::has_feature(const std::string& feature) const {
    842     return features_.count(feature) > 0;
    843 }
    844 
    845 void atransport::SetFeatures(const std::string& features_string) {
    846     features_ = StringToFeatureSet(features_string);
    847 }
    848 
    849 void atransport::AddDisconnect(adisconnect* disconnect) {
    850     disconnects_.push_back(disconnect);
    851 }
    852 
    853 void atransport::RemoveDisconnect(adisconnect* disconnect) {
    854     disconnects_.remove(disconnect);
    855 }
    856 
    857 void atransport::RunDisconnects() {
    858     for (const auto& disconnect : disconnects_) {
    859         disconnect->func(disconnect->opaque, this);
    860     }
    861     disconnects_.clear();
    862 }
    863 
    864 bool atransport::MatchesTarget(const std::string& target) const {
    865     if (serial) {
    866         if (target == serial) {
    867             return true;
    868         } else if (type == kTransportLocal) {
    869             // Local transports can match [tcp:|udp:]<hostname>[:port].
    870             const char* local_target_ptr = target.c_str();
    871 
    872             // For fastboot compatibility, ignore protocol prefixes.
    873             if (android::base::StartsWith(target, "tcp:") ||
    874                 android::base::StartsWith(target, "udp:")) {
    875                 local_target_ptr += 4;
    876             }
    877 
    878             // Parse our |serial| and the given |target| to check if the hostnames and ports match.
    879             std::string serial_host, error;
    880             int serial_port = -1;
    881             if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) {
    882                 // |target| may omit the port to default to ours.
    883                 std::string target_host;
    884                 int target_port = serial_port;
    885                 if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port,
    886                                                    nullptr, &error) &&
    887                     serial_host == target_host && serial_port == target_port) {
    888                     return true;
    889                 }
    890             }
    891         }
    892     }
    893 
    894     return (devpath && target == devpath) ||
    895            qual_match(target.c_str(), "product:", product, false) ||
    896            qual_match(target.c_str(), "model:", model, true) ||
    897            qual_match(target.c_str(), "device:", device, false);
    898 }
    899 
    900 #if ADB_HOST
    901 
    902 // We use newline as our delimiter, make sure to never output it.
    903 static std::string sanitize(std::string str, bool alphanumeric) {
    904     auto pred = alphanumeric ? [](const char c) { return !isalnum(c); }
    905                              : [](const char c) { return c == '\n'; };
    906     std::replace_if(str.begin(), str.end(), pred, '_');
    907     return str;
    908 }
    909 
    910 static void append_transport_info(std::string* result, const char* key, const char* value,
    911                                   bool alphanumeric) {
    912     if (value == nullptr || *value == '\0') {
    913         return;
    914     }
    915 
    916     *result += ' ';
    917     *result += key;
    918     *result += sanitize(value, alphanumeric);
    919 }
    920 
    921 static void append_transport(const atransport* t, std::string* result, bool long_listing) {
    922     const char* serial = t->serial;
    923     if (!serial || !serial[0]) {
    924         serial = "(no serial number)";
    925     }
    926 
    927     if (!long_listing) {
    928         *result += serial;
    929         *result += '\t';
    930         *result += t->connection_state_name();
    931     } else {
    932         android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name().c_str());
    933 
    934         append_transport_info(result, "", t->devpath, false);
    935         append_transport_info(result, "product:", t->product, false);
    936         append_transport_info(result, "model:", t->model, true);
    937         append_transport_info(result, "device:", t->device, false);
    938 
    939         // Put id at the end, so that anyone parsing the output here can always find it by scanning
    940         // backwards from newlines, even with hypothetical devices named 'transport_id:1'.
    941         *result += " transport_id:";
    942         *result += std::to_string(t->id);
    943     }
    944     *result += '\n';
    945 }
    946 
    947 std::string list_transports(bool long_listing) {
    948     std::string result;
    949 
    950     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    951     for (const auto& t : transport_list) {
    952         append_transport(t, &result, long_listing);
    953     }
    954     return result;
    955 }
    956 
    957 void close_usb_devices(std::function<bool(const atransport*)> predicate) {
    958     std::lock_guard<std::recursive_mutex> lock(transport_lock);
    959     for (auto& t : transport_list) {
    960         if (predicate(t)) {
    961             t->Kick();
    962         }
    963     }
    964 }
    965 
    966 /* hack for osx */
    967 void close_usb_devices() {
    968     close_usb_devices([](const atransport*) { return true; });
    969 }
    970 #endif  // ADB_HOST
    971 
    972 int register_socket_transport(int s, const char* serial, int port, int local) {
    973     atransport* t = new atransport();
    974 
    975     if (!serial) {
    976         char buf[32];
    977         snprintf(buf, sizeof(buf), "T-%p", t);
    978         serial = buf;
    979     }
    980 
    981     D("transport: %s init'ing for socket %d, on port %d", serial, s, port);
    982     if (init_socket_transport(t, s, port, local) < 0) {
    983         delete t;
    984         return -1;
    985     }
    986 
    987     std::unique_lock<std::recursive_mutex> lock(transport_lock);
    988     for (const auto& transport : pending_list) {
    989         if (transport->serial && strcmp(serial, transport->serial) == 0) {
    990             VLOG(TRANSPORT) << "socket transport " << transport->serial
    991                             << " is already in pending_list and fails to register";
    992             delete t;
    993             return -1;
    994         }
    995     }
    996 
    997     for (const auto& transport : transport_list) {
    998         if (transport->serial && strcmp(serial, transport->serial) == 0) {
    999             VLOG(TRANSPORT) << "socket transport " << transport->serial
   1000                             << " is already in transport_list and fails to register";
   1001             delete t;
   1002             return -1;
   1003         }
   1004     }
   1005 
   1006     pending_list.push_front(t);
   1007     t->serial = strdup(serial);
   1008 
   1009     lock.unlock();
   1010 
   1011     register_transport(t);
   1012     return 0;
   1013 }
   1014 
   1015 #if ADB_HOST
   1016 atransport* find_transport(const char* serial) {
   1017     atransport* result = nullptr;
   1018 
   1019     std::lock_guard<std::recursive_mutex> lock(transport_lock);
   1020     for (auto& t : transport_list) {
   1021         if (t->serial && strcmp(serial, t->serial) == 0) {
   1022             result = t;
   1023             break;
   1024         }
   1025     }
   1026 
   1027     return result;
   1028 }
   1029 
   1030 void kick_all_tcp_devices() {
   1031     std::lock_guard<std::recursive_mutex> lock(transport_lock);
   1032     for (auto& t : transport_list) {
   1033         if (t->IsTcpDevice()) {
   1034             // Kicking breaks the read_transport thread of this transport out of any read, then
   1035             // the read_transport thread will notify the main thread to make this transport
   1036             // offline. Then the main thread will notify the write_transport thread to exit.
   1037             // Finally, this transport will be closed and freed in the main thread.
   1038             t->Kick();
   1039         }
   1040     }
   1041 }
   1042 
   1043 #endif
   1044 
   1045 void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath,
   1046                             unsigned writeable) {
   1047     atransport* t = new atransport((writeable ? kCsOffline : kCsNoPerm));
   1048 
   1049     D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : "");
   1050     init_usb_transport(t, usb);
   1051     if (serial) {
   1052         t->serial = strdup(serial);
   1053     }
   1054 
   1055     if (devpath) {
   1056         t->devpath = strdup(devpath);
   1057     }
   1058 
   1059     {
   1060         std::lock_guard<std::recursive_mutex> lock(transport_lock);
   1061         pending_list.push_front(t);
   1062     }
   1063 
   1064     register_transport(t);
   1065 }
   1066 
   1067 // This should only be used for transports with connection_state == kCsNoPerm.
   1068 void unregister_usb_transport(usb_handle* usb) {
   1069     std::lock_guard<std::recursive_mutex> lock(transport_lock);
   1070     transport_list.remove_if(
   1071         [usb](atransport* t) { return t->usb == usb && t->GetConnectionState() == kCsNoPerm; });
   1072 }
   1073 
   1074 bool check_header(apacket* p, atransport* t) {
   1075     if (p->msg.magic != (p->msg.command ^ 0xffffffff)) {
   1076         VLOG(RWX) << "check_header(): invalid magic command = " << std::hex << p->msg.command
   1077                   << ", magic = " << p->msg.magic;
   1078         return false;
   1079     }
   1080 
   1081     if (p->msg.data_length > t->get_max_payload()) {
   1082         VLOG(RWX) << "check_header(): " << p->msg.data_length
   1083                   << " atransport::max_payload = " << t->get_max_payload();
   1084         return false;
   1085     }
   1086 
   1087     return true;
   1088 }
   1089 
   1090 bool check_data(apacket* p) {
   1091     return calculate_apacket_checksum(p) == p->msg.data_check;
   1092 }
   1093 
   1094 #if ADB_HOST
   1095 std::shared_ptr<RSA> atransport::NextKey() {
   1096     if (keys_.empty()) keys_ = adb_auth_get_private_keys();
   1097 
   1098     std::shared_ptr<RSA> result = keys_[0];
   1099     keys_.pop_front();
   1100     return result;
   1101 }
   1102 #endif
   1103