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