transport.cpp revision 802c54ebb79453256a8c7fd3c3cab88acc8a84e8
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 41static void transport_unref(atransport *t); 42 43static auto& transport_list = *new std::list<atransport*>(); 44static auto& pending_list = *new std::list<atransport*>(); 45 46ADB_MUTEX_DEFINE( transport_lock ); 47 48const char* const kFeatureShell2 = "shell_v2"; 49const char* const kFeatureCmd = "cmd"; 50 51static 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 88static int 89read_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 113static int 114write_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 137static 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 151void 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(). 194static 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 243oops: 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). 251static 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 298static void kick_transport_locked(atransport* t) { 299 CHECK(t != nullptr); 300 if (!t->kicked) { 301 t->kicked = true; 302 t->kick(t); 303 } 304} 305 306void kick_transport(atransport* t) { 307 adb_mutex_lock(&transport_lock); 308 kick_transport_locked(t); 309 adb_mutex_unlock(&transport_lock); 310} 311 312static int transport_registration_send = -1; 313static int transport_registration_recv = -1; 314static fdevent transport_registration_fde; 315 316 317#if ADB_HOST 318 319/* this adds support required by the 'track-devices' service. 320 * this is used to send the content of "list_transport" to any 321 * number of client connections that want it through a single 322 * live TCP connection 323 */ 324struct device_tracker { 325 asocket socket; 326 int update_needed; 327 device_tracker* next; 328}; 329 330/* linked list of all device trackers */ 331static device_tracker* device_tracker_list; 332 333static void 334device_tracker_remove( device_tracker* tracker ) 335{ 336 device_tracker** pnode = &device_tracker_list; 337 device_tracker* node = *pnode; 338 339 adb_mutex_lock( &transport_lock ); 340 while (node) { 341 if (node == tracker) { 342 *pnode = node->next; 343 break; 344 } 345 pnode = &node->next; 346 node = *pnode; 347 } 348 adb_mutex_unlock( &transport_lock ); 349} 350 351static void 352device_tracker_close( asocket* socket ) 353{ 354 device_tracker* tracker = (device_tracker*) socket; 355 asocket* peer = socket->peer; 356 357 D( "device tracker %p removed", tracker); 358 if (peer) { 359 peer->peer = NULL; 360 peer->close(peer); 361 } 362 device_tracker_remove(tracker); 363 free(tracker); 364} 365 366static int 367device_tracker_enqueue( asocket* socket, apacket* p ) 368{ 369 /* you can't read from a device tracker, close immediately */ 370 put_apacket(p); 371 device_tracker_close(socket); 372 return -1; 373} 374 375static int device_tracker_send(device_tracker* tracker, const std::string& string) { 376 apacket* p = get_apacket(); 377 asocket* peer = tracker->socket.peer; 378 379 snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size())); 380 memcpy(&p->data[4], string.data(), string.size()); 381 p->len = 4 + string.size(); 382 return peer->enqueue(peer, p); 383} 384 385static void device_tracker_ready(asocket* socket) { 386 device_tracker* tracker = reinterpret_cast<device_tracker*>(socket); 387 388 // We want to send the device list when the tracker connects 389 // for the first time, even if no update occurred. 390 if (tracker->update_needed > 0) { 391 tracker->update_needed = 0; 392 393 std::string transports = list_transports(false); 394 device_tracker_send(tracker, transports); 395 } 396} 397 398asocket* 399create_device_tracker(void) 400{ 401 device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker))); 402 if (tracker == nullptr) fatal("cannot allocate device tracker"); 403 404 D( "device tracker %p created", tracker); 405 406 tracker->socket.enqueue = device_tracker_enqueue; 407 tracker->socket.ready = device_tracker_ready; 408 tracker->socket.close = device_tracker_close; 409 tracker->update_needed = 1; 410 411 tracker->next = device_tracker_list; 412 device_tracker_list = tracker; 413 414 return &tracker->socket; 415} 416 417 418// Call this function each time the transport list has changed. 419void update_transports() { 420 std::string transports = list_transports(false); 421 422 device_tracker* tracker = device_tracker_list; 423 while (tracker != nullptr) { 424 device_tracker* next = tracker->next; 425 // This may destroy the tracker if the connection is closed. 426 device_tracker_send(tracker, transports); 427 tracker = next; 428 } 429} 430 431#else 432 433void update_transports() { 434 // Nothing to do on the device side. 435} 436 437#endif // ADB_HOST 438 439struct tmsg 440{ 441 atransport *transport; 442 int action; 443}; 444 445static int 446transport_read_action(int fd, struct tmsg* m) 447{ 448 char *p = (char*)m; 449 int len = sizeof(*m); 450 int r; 451 452 while(len > 0) { 453 r = adb_read(fd, p, len); 454 if(r > 0) { 455 len -= r; 456 p += r; 457 } else { 458 D("transport_read_action: on fd %d: %s", fd, strerror(errno)); 459 return -1; 460 } 461 } 462 return 0; 463} 464 465static int 466transport_write_action(int fd, struct tmsg* m) 467{ 468 char *p = (char*)m; 469 int len = sizeof(*m); 470 int r; 471 472 while(len > 0) { 473 r = adb_write(fd, p, len); 474 if(r > 0) { 475 len -= r; 476 p += r; 477 } else { 478 D("transport_write_action: on fd %d: %s", fd, strerror(errno)); 479 return -1; 480 } 481 } 482 return 0; 483} 484 485static void transport_registration_func(int _fd, unsigned ev, void *data) 486{ 487 tmsg m; 488 int s[2]; 489 atransport *t; 490 491 if(!(ev & FDE_READ)) { 492 return; 493 } 494 495 if(transport_read_action(_fd, &m)) { 496 fatal_errno("cannot read transport registration socket"); 497 } 498 499 t = m.transport; 500 501 if (m.action == 0) { 502 D("transport: %s removing and free'ing %d", t->serial, t->transport_socket); 503 504 /* IMPORTANT: the remove closes one half of the 505 ** socket pair. The close closes the other half. 506 */ 507 fdevent_remove(&(t->transport_fde)); 508 adb_close(t->fd); 509 510 adb_mutex_lock(&transport_lock); 511 transport_list.remove(t); 512 adb_mutex_unlock(&transport_lock); 513 514 if (t->product) 515 free(t->product); 516 if (t->serial) 517 free(t->serial); 518 if (t->model) 519 free(t->model); 520 if (t->device) 521 free(t->device); 522 if (t->devpath) 523 free(t->devpath); 524 525 delete t; 526 527 update_transports(); 528 return; 529 } 530 531 /* don't create transport threads for inaccessible devices */ 532 if (t->connection_state != kCsNoPerm) { 533 /* initial references are the two threads */ 534 t->ref_count = 2; 535 536 if (adb_socketpair(s)) { 537 fatal_errno("cannot open transport socketpair"); 538 } 539 540 D("transport: %s socketpair: (%d,%d) starting", t->serial, s[0], s[1]); 541 542 t->transport_socket = s[0]; 543 t->fd = s[1]; 544 545 fdevent_install(&(t->transport_fde), 546 t->transport_socket, 547 transport_socket_events, 548 t); 549 550 fdevent_set(&(t->transport_fde), FDE_READ); 551 552 if (!adb_thread_create(write_transport_thread, t)) { 553 fatal_errno("cannot create write_transport thread"); 554 } 555 556 if (!adb_thread_create(read_transport_thread, t)) { 557 fatal_errno("cannot create read_transport thread"); 558 } 559 } 560 561 adb_mutex_lock(&transport_lock); 562 pending_list.remove(t); 563 transport_list.push_front(t); 564 adb_mutex_unlock(&transport_lock); 565 566 update_transports(); 567} 568 569void init_transport_registration(void) 570{ 571 int s[2]; 572 573 if(adb_socketpair(s)){ 574 fatal_errno("cannot open transport registration socketpair"); 575 } 576 D("socketpair: (%d,%d)", s[0], s[1]); 577 578 transport_registration_send = s[0]; 579 transport_registration_recv = s[1]; 580 581 fdevent_install(&transport_registration_fde, 582 transport_registration_recv, 583 transport_registration_func, 584 0); 585 586 fdevent_set(&transport_registration_fde, FDE_READ); 587} 588 589/* the fdevent select pump is single threaded */ 590static void register_transport(atransport *transport) 591{ 592 tmsg m; 593 m.transport = transport; 594 m.action = 1; 595 D("transport: %s registered", transport->serial); 596 if(transport_write_action(transport_registration_send, &m)) { 597 fatal_errno("cannot write transport registration socket\n"); 598 } 599} 600 601static void remove_transport(atransport *transport) 602{ 603 tmsg m; 604 m.transport = transport; 605 m.action = 0; 606 D("transport: %s removed", transport->serial); 607 if(transport_write_action(transport_registration_send, &m)) { 608 fatal_errno("cannot write transport registration socket\n"); 609 } 610} 611 612 613static void transport_unref(atransport* t) { 614 CHECK(t != nullptr); 615 adb_mutex_lock(&transport_lock); 616 CHECK_GT(t->ref_count, 0u); 617 t->ref_count--; 618 if (t->ref_count == 0) { 619 D("transport: %s unref (kicking and closing)", t->serial); 620 kick_transport_locked(t); 621 t->close(t); 622 remove_transport(t); 623 } else { 624 D("transport: %s unref (count=%zu)", t->serial, t->ref_count); 625 } 626 adb_mutex_unlock(&transport_lock); 627} 628 629static int qual_match(const char *to_test, 630 const char *prefix, const char *qual, bool sanitize_qual) 631{ 632 if (!to_test || !*to_test) 633 /* Return true if both the qual and to_test are null strings. */ 634 return !qual || !*qual; 635 636 if (!qual) 637 return 0; 638 639 if (prefix) { 640 while (*prefix) { 641 if (*prefix++ != *to_test++) 642 return 0; 643 } 644 } 645 646 while (*qual) { 647 char ch = *qual++; 648 if (sanitize_qual && !isalnum(ch)) 649 ch = '_'; 650 if (ch != *to_test++) 651 return 0; 652 } 653 654 /* Everything matched so far. Return true if *to_test is a NUL. */ 655 return !*to_test; 656} 657 658atransport* acquire_one_transport(TransportType type, const char* serial, 659 bool* is_ambiguous, std::string* error_out) { 660 atransport* result = nullptr; 661 662 if (serial) { 663 *error_out = android::base::StringPrintf("device '%s' not found", serial); 664 } else if (type == kTransportLocal) { 665 *error_out = "no emulators found"; 666 } else if (type == kTransportAny) { 667 *error_out = "no devices/emulators found"; 668 } else { 669 *error_out = "no devices found"; 670 } 671 672 adb_mutex_lock(&transport_lock); 673 for (const auto& t : transport_list) { 674 if (t->connection_state == kCsNoPerm) { 675#if ADB_HOST 676 *error_out = UsbNoPermissionsLongHelpText(); 677#endif 678 continue; 679 } 680 681 // Check for matching serial number. 682 if (serial) { 683 if (t->MatchesTarget(serial)) { 684 if (result) { 685 *error_out = "more than one device"; 686 if (is_ambiguous) *is_ambiguous = true; 687 result = nullptr; 688 break; 689 } 690 result = t; 691 } 692 } else { 693 if (type == kTransportUsb && t->type == kTransportUsb) { 694 if (result) { 695 *error_out = "more than one device"; 696 if (is_ambiguous) *is_ambiguous = true; 697 result = nullptr; 698 break; 699 } 700 result = t; 701 } else if (type == kTransportLocal && t->type == kTransportLocal) { 702 if (result) { 703 *error_out = "more than one emulator"; 704 if (is_ambiguous) *is_ambiguous = true; 705 result = nullptr; 706 break; 707 } 708 result = t; 709 } else if (type == kTransportAny) { 710 if (result) { 711 *error_out = "more than one device/emulator"; 712 if (is_ambiguous) *is_ambiguous = true; 713 result = nullptr; 714 break; 715 } 716 result = t; 717 } 718 } 719 } 720 adb_mutex_unlock(&transport_lock); 721 722 // Don't return unauthorized devices; the caller can't do anything with them. 723 if (result && result->connection_state == kCsUnauthorized) { 724 *error_out = "device unauthorized.\n"; 725 char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS"); 726 *error_out += "This adb server's $ADB_VENDOR_KEYS is "; 727 *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set"; 728 *error_out += "\n"; 729 *error_out += "Try 'adb kill-server' if that seems wrong.\n"; 730 *error_out += "Otherwise check for a confirmation dialog on your device."; 731 result = nullptr; 732 } 733 734 // Don't return offline devices; the caller can't do anything with them. 735 if (result && result->connection_state == kCsOffline) { 736 *error_out = "device offline"; 737 result = nullptr; 738 } 739 740 if (result) { 741 *error_out = "success"; 742 } 743 744 return result; 745} 746 747const std::string atransport::connection_state_name() const { 748 switch (connection_state) { 749 case kCsOffline: return "offline"; 750 case kCsBootloader: return "bootloader"; 751 case kCsDevice: return "device"; 752 case kCsHost: return "host"; 753 case kCsRecovery: return "recovery"; 754 case kCsNoPerm: return UsbNoPermissionsShortHelpText(); 755 case kCsSideload: return "sideload"; 756 case kCsUnauthorized: return "unauthorized"; 757 default: return "unknown"; 758 } 759} 760 761void atransport::update_version(int version, size_t payload) { 762 protocol_version = std::min(version, A_VERSION); 763 max_payload = std::min(payload, MAX_PAYLOAD); 764} 765 766int atransport::get_protocol_version() const { 767 return protocol_version; 768} 769 770size_t atransport::get_max_payload() const { 771 return max_payload; 772} 773 774namespace { 775 776constexpr char kFeatureStringDelimiter = ','; 777 778} // namespace 779 780const FeatureSet& supported_features() { 781 // Local static allocation to avoid global non-POD variables. 782 static const FeatureSet* features = new FeatureSet{ 783 kFeatureShell2, 784 kFeatureCmd 785 // Increment ADB_SERVER_VERSION whenever the feature list changes to 786 // make sure that the adb client and server features stay in sync 787 // (http://b/24370690). 788 }; 789 790 return *features; 791} 792 793std::string FeatureSetToString(const FeatureSet& features) { 794 return android::base::Join(features, kFeatureStringDelimiter); 795} 796 797FeatureSet StringToFeatureSet(const std::string& features_string) { 798 if (features_string.empty()) { 799 return FeatureSet(); 800 } 801 802 auto names = android::base::Split(features_string, 803 {kFeatureStringDelimiter}); 804 return FeatureSet(names.begin(), names.end()); 805} 806 807bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) { 808 return feature_set.count(feature) > 0 && 809 supported_features().count(feature) > 0; 810} 811 812bool atransport::has_feature(const std::string& feature) const { 813 return features_.count(feature) > 0; 814} 815 816void atransport::SetFeatures(const std::string& features_string) { 817 features_ = StringToFeatureSet(features_string); 818} 819 820void atransport::AddDisconnect(adisconnect* disconnect) { 821 disconnects_.push_back(disconnect); 822} 823 824void atransport::RemoveDisconnect(adisconnect* disconnect) { 825 disconnects_.remove(disconnect); 826} 827 828void atransport::RunDisconnects() { 829 for (const auto& disconnect : disconnects_) { 830 disconnect->func(disconnect->opaque, this); 831 } 832 disconnects_.clear(); 833} 834 835bool atransport::MatchesTarget(const std::string& target) const { 836 if (serial) { 837 if (target == serial) { 838 return true; 839 } else if (type == kTransportLocal) { 840 // Local transports can match [tcp:|udp:]<hostname>[:port]. 841 const char* local_target_ptr = target.c_str(); 842 843 // For fastboot compatibility, ignore protocol prefixes. 844 if (android::base::StartsWith(target, "tcp:") || 845 android::base::StartsWith(target, "udp:")) { 846 local_target_ptr += 4; 847 } 848 849 // Parse our |serial| and the given |target| to check if the hostnames and ports match. 850 std::string serial_host, error; 851 int serial_port = -1; 852 if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, 853 &error)) { 854 // |target| may omit the port to default to ours. 855 std::string target_host; 856 int target_port = serial_port; 857 if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port, 858 nullptr, &error) && 859 serial_host == target_host && serial_port == target_port) { 860 return true; 861 } 862 } 863 } 864 } 865 866 return (devpath && target == devpath) || 867 qual_match(target.c_str(), "product:", product, false) || 868 qual_match(target.c_str(), "model:", model, true) || 869 qual_match(target.c_str(), "device:", device, false); 870} 871 872#if ADB_HOST 873 874static void append_transport_info(std::string* result, const char* key, 875 const char* value, bool sanitize) { 876 if (value == nullptr || *value == '\0') { 877 return; 878 } 879 880 *result += ' '; 881 *result += key; 882 883 for (const char* p = value; *p; ++p) { 884 result->push_back((!sanitize || isalnum(*p)) ? *p : '_'); 885 } 886} 887 888static void append_transport(const atransport* t, std::string* result, 889 bool long_listing) { 890 const char* serial = t->serial; 891 if (!serial || !serial[0]) { 892 serial = "(no serial number)"; 893 } 894 895 if (!long_listing) { 896 *result += serial; 897 *result += '\t'; 898 *result += t->connection_state_name(); 899 } else { 900 android::base::StringAppendF(result, "%-22s %s", serial, 901 t->connection_state_name().c_str()); 902 903 append_transport_info(result, "", t->devpath, false); 904 append_transport_info(result, "product:", t->product, false); 905 append_transport_info(result, "model:", t->model, true); 906 append_transport_info(result, "device:", t->device, false); 907 } 908 *result += '\n'; 909} 910 911std::string list_transports(bool long_listing) { 912 std::string result; 913 adb_mutex_lock(&transport_lock); 914 for (const auto& t : transport_list) { 915 append_transport(t, &result, long_listing); 916 } 917 adb_mutex_unlock(&transport_lock); 918 return result; 919} 920 921/* hack for osx */ 922void close_usb_devices() { 923 adb_mutex_lock(&transport_lock); 924 for (const auto& t : transport_list) { 925 if (!t->kicked) { 926 t->kicked = 1; 927 t->kick(t); 928 } 929 } 930 adb_mutex_unlock(&transport_lock); 931} 932#endif // ADB_HOST 933 934int 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 975atransport *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 990void 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 kick_transport_locked(t); 1000 } 1001 } 1002 adb_mutex_unlock(&transport_lock); 1003} 1004 1005#endif 1006 1007void 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. 1030void 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 1038int 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 1054int 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