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 /* offline devices are ignored -- they are either being born or dying */ 855 if (result && result->connection_state == CS_OFFLINE) { 856 if (error_out) 857 *error_out = "device offline"; 858 result = NULL; 859 } 860 /* check for required connection state */ 861 if (result && state != CS_ANY && result->connection_state != state) { 862 if (error_out) 863 *error_out = "invalid device state"; 864 result = NULL; 865 } 866 } 867 868 if (result) { 869 /* found one that we can take */ 870 if (error_out) 871 *error_out = NULL; 872 } else if (state != CS_ANY && (serial || !ambiguous)) { 873 adb_sleep_ms(1000); 874 goto retry; 875 } 876 877 return result; 878 } 879 880 #if ADB_HOST 881 static const char *statename(atransport *t) 882 { 883 switch(t->connection_state){ 884 case CS_OFFLINE: return "offline"; 885 case CS_BOOTLOADER: return "bootloader"; 886 case CS_DEVICE: return "device"; 887 case CS_HOST: return "host"; 888 case CS_RECOVERY: return "recovery"; 889 case CS_SIDELOAD: return "sideload"; 890 case CS_NOPERM: return "no permissions"; 891 default: return "unknown"; 892 } 893 } 894 895 static void add_qual(char **buf, size_t *buf_size, 896 const char *prefix, const char *qual, int sanitize_qual) 897 { 898 size_t len; 899 int prefix_len; 900 901 if (!buf || !*buf || !buf_size || !*buf_size || !qual || !*qual) 902 return; 903 904 len = snprintf(*buf, *buf_size, "%s%n%s", prefix, &prefix_len, qual); 905 906 if (sanitize_qual) { 907 char *cp; 908 for (cp = *buf + prefix_len; cp < *buf + len; cp++) { 909 if (qual_char_is_invalid(*cp)) 910 *cp = '_'; 911 } 912 } 913 914 *buf_size -= len; 915 *buf += len; 916 } 917 918 static size_t format_transport(atransport *t, char *buf, size_t bufsize, 919 int long_listing) 920 { 921 const char* serial = t->serial; 922 if (!serial || !serial[0]) 923 serial = "????????????"; 924 925 if (!long_listing) { 926 return snprintf(buf, bufsize, "%s\t%s\n", serial, statename(t)); 927 } else { 928 size_t len, remaining = bufsize; 929 930 len = snprintf(buf, remaining, "%-22s %s", serial, statename(t)); 931 remaining -= len; 932 buf += len; 933 934 add_qual(&buf, &remaining, " ", t->devpath, 0); 935 add_qual(&buf, &remaining, " product:", t->product, 0); 936 add_qual(&buf, &remaining, " model:", t->model, 1); 937 add_qual(&buf, &remaining, " device:", t->device, 0); 938 939 len = snprintf(buf, remaining, "\n"); 940 remaining -= len; 941 942 return bufsize - remaining; 943 } 944 } 945 946 int list_transports(char *buf, size_t bufsize, int long_listing) 947 { 948 char* p = buf; 949 char* end = buf + bufsize; 950 int len; 951 atransport *t; 952 953 /* XXX OVERRUN PROBLEMS XXX */ 954 adb_mutex_lock(&transport_lock); 955 for(t = transport_list.next; t != &transport_list; t = t->next) { 956 len = format_transport(t, p, end - p, long_listing); 957 if (p + len >= end) { 958 /* discard last line if buffer is too short */ 959 break; 960 } 961 p += len; 962 } 963 p[0] = 0; 964 adb_mutex_unlock(&transport_lock); 965 return p - buf; 966 } 967 968 969 /* hack for osx */ 970 void close_usb_devices() 971 { 972 atransport *t; 973 974 adb_mutex_lock(&transport_lock); 975 for(t = transport_list.next; t != &transport_list; t = t->next) { 976 if ( !t->kicked ) { 977 t->kicked = 1; 978 t->kick(t); 979 } 980 } 981 adb_mutex_unlock(&transport_lock); 982 } 983 #endif // ADB_HOST 984 985 void register_socket_transport(int s, const char *serial, int port, int local) 986 { 987 atransport *t = calloc(1, sizeof(atransport)); 988 char buff[32]; 989 990 if (!serial) { 991 snprintf(buff, sizeof buff, "T-%p", t); 992 serial = buff; 993 } 994 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port); 995 if ( init_socket_transport(t, s, port, local) < 0 ) { 996 adb_close(s); 997 free(t); 998 return; 999 } 1000 if(serial) { 1001 t->serial = strdup(serial); 1002 } 1003 register_transport(t); 1004 } 1005 1006 #if ADB_HOST 1007 atransport *find_transport(const char *serial) 1008 { 1009 atransport *t; 1010 1011 adb_mutex_lock(&transport_lock); 1012 for(t = transport_list.next; t != &transport_list; t = t->next) { 1013 if (t->serial && !strcmp(serial, t->serial)) { 1014 break; 1015 } 1016 } 1017 adb_mutex_unlock(&transport_lock); 1018 1019 if (t != &transport_list) 1020 return t; 1021 else 1022 return 0; 1023 } 1024 1025 void unregister_transport(atransport *t) 1026 { 1027 adb_mutex_lock(&transport_lock); 1028 t->next->prev = t->prev; 1029 t->prev->next = t->next; 1030 adb_mutex_unlock(&transport_lock); 1031 1032 kick_transport(t); 1033 transport_unref(t); 1034 } 1035 1036 // unregisters all non-emulator TCP transports 1037 void unregister_all_tcp_transports() 1038 { 1039 atransport *t, *next; 1040 adb_mutex_lock(&transport_lock); 1041 for (t = transport_list.next; t != &transport_list; t = next) { 1042 next = t->next; 1043 if (t->type == kTransportLocal && t->adb_port == 0) { 1044 t->next->prev = t->prev; 1045 t->prev->next = next; 1046 // we cannot call kick_transport when holding transport_lock 1047 if (!t->kicked) 1048 { 1049 t->kicked = 1; 1050 t->kick(t); 1051 } 1052 transport_unref_locked(t); 1053 } 1054 } 1055 1056 adb_mutex_unlock(&transport_lock); 1057 } 1058 1059 #endif 1060 1061 void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable) 1062 { 1063 atransport *t = calloc(1, sizeof(atransport)); 1064 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb, 1065 serial ? serial : ""); 1066 init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM)); 1067 if(serial) { 1068 t->serial = strdup(serial); 1069 } 1070 if(devpath) { 1071 t->devpath = strdup(devpath); 1072 } 1073 register_transport(t); 1074 } 1075 1076 /* this should only be used for transports with connection_state == CS_NOPERM */ 1077 void unregister_usb_transport(usb_handle *usb) 1078 { 1079 atransport *t; 1080 adb_mutex_lock(&transport_lock); 1081 for(t = transport_list.next; t != &transport_list; t = t->next) { 1082 if (t->usb == usb && t->connection_state == CS_NOPERM) { 1083 t->next->prev = t->prev; 1084 t->prev->next = t->next; 1085 break; 1086 } 1087 } 1088 adb_mutex_unlock(&transport_lock); 1089 } 1090 1091 #undef TRACE_TAG 1092 #define TRACE_TAG TRACE_RWX 1093 1094 int readx(int fd, void *ptr, size_t len) 1095 { 1096 char *p = ptr; 1097 int r; 1098 #if ADB_TRACE 1099 int len0 = len; 1100 #endif 1101 D("readx: fd=%d wanted=%d\n", fd, (int)len); 1102 while(len > 0) { 1103 r = adb_read(fd, p, len); 1104 if(r > 0) { 1105 len -= r; 1106 p += r; 1107 } else { 1108 if (r < 0) { 1109 D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1110 if (errno == EINTR) 1111 continue; 1112 } else { 1113 D("readx: fd=%d disconnected\n", fd); 1114 } 1115 return -1; 1116 } 1117 } 1118 1119 #if ADB_TRACE 1120 D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len); 1121 dump_hex( ptr, len0 ); 1122 #endif 1123 return 0; 1124 } 1125 1126 int writex(int fd, const void *ptr, size_t len) 1127 { 1128 char *p = (char*) ptr; 1129 int r; 1130 1131 #if ADB_TRACE 1132 D("writex: fd=%d len=%d: ", fd, (int)len); 1133 dump_hex( ptr, len ); 1134 #endif 1135 while(len > 0) { 1136 r = adb_write(fd, p, len); 1137 if(r > 0) { 1138 len -= r; 1139 p += r; 1140 } else { 1141 if (r < 0) { 1142 D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1143 if (errno == EINTR) 1144 continue; 1145 } else { 1146 D("writex: fd=%d disconnected\n", fd); 1147 } 1148 return -1; 1149 } 1150 } 1151 return 0; 1152 } 1153 1154 int check_header(apacket *p) 1155 { 1156 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) { 1157 D("check_header(): invalid magic\n"); 1158 return -1; 1159 } 1160 1161 if(p->msg.data_length > MAX_PAYLOAD) { 1162 D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length); 1163 return -1; 1164 } 1165 1166 return 0; 1167 } 1168 1169 int check_data(apacket *p) 1170 { 1171 unsigned count, sum; 1172 unsigned char *x; 1173 1174 count = p->msg.data_length; 1175 x = p->data; 1176 sum = 0; 1177 while(count-- > 0) { 1178 sum += *x++; 1179 } 1180 1181 if(sum != p->msg.data_check) { 1182 return -1; 1183 } else { 1184 return 0; 1185 } 1186 } 1187