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