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