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