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