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