transport.c revision 3608d832425ca3a6d00c4040f3bb979c5aa49899
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 28static void transport_unref(atransport *t); 29 30static atransport transport_list = { 31 .next = &transport_list, 32 .prev = &transport_list, 33}; 34 35ADB_MUTEX_DEFINE( transport_lock ); 36 37#if ADB_TRACE 38#define MAX_DUMP_HEX_LEN 16 39static 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 65void 66kick_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 83void 84run_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 97static void 98dump_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 136static int 137read_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 167static int 168write_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 198static 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 212void 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 255static 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 303oops: 304 D("%s: transport output thread is exiting\n", t->serial); 305 kick_transport(t); 306 transport_unref(t); 307 return 0; 308} 309 310static 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 362static int transport_registration_send = -1; 363static int transport_registration_recv = -1; 364static fdevent transport_registration_fde; 365 366 367#if ADB_HOST 368static 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 */ 385typedef struct device_tracker device_tracker; 386struct device_tracker { 387 asocket socket; 388 int update_needed; 389 device_tracker* next; 390}; 391 392/* linked list of all device trackers */ 393static device_tracker* device_tracker_list; 394 395static void 396device_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 413static void 414device_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 428static int 429device_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 437static int 438device_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 451static void 452device_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 470asocket* 471create_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 */ 492void 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 509void update_transports(void) 510{ 511 // nothing to do on the device side 512} 513#endif // ADB_HOST 514 515typedef struct tmsg tmsg; 516struct tmsg 517{ 518 atransport *transport; 519 int action; 520}; 521 522static int 523transport_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 544static int 545transport_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 566static 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->devpath) 605 free(t->devpath); 606 607 memset(t,0xee,sizeof(atransport)); 608 free(t); 609 610 update_transports(); 611 return; 612 } 613 614 /* don't create transport threads for inaccessible devices */ 615 if (t->connection_state != CS_NOPERM) { 616 /* initial references are the two threads */ 617 t->ref_count = 2; 618 619 if(adb_socketpair(s)) { 620 fatal_errno("cannot open transport socketpair"); 621 } 622 623 D("transport: %s (%d,%d) starting\n", t->serial, s[0], s[1]); 624 625 t->transport_socket = s[0]; 626 t->fd = s[1]; 627 628 fdevent_install(&(t->transport_fde), 629 t->transport_socket, 630 transport_socket_events, 631 t); 632 633 fdevent_set(&(t->transport_fde), FDE_READ); 634 635 if(adb_thread_create(&input_thread_ptr, input_thread, t)){ 636 fatal_errno("cannot create input thread"); 637 } 638 639 if(adb_thread_create(&output_thread_ptr, output_thread, t)){ 640 fatal_errno("cannot create output thread"); 641 } 642 } 643 644 /* put us on the master device list */ 645 adb_mutex_lock(&transport_lock); 646 t->next = &transport_list; 647 t->prev = transport_list.prev; 648 t->next->prev = t; 649 t->prev->next = t; 650 adb_mutex_unlock(&transport_lock); 651 652 t->disconnects.next = t->disconnects.prev = &t->disconnects; 653 654 update_transports(); 655} 656 657void init_transport_registration(void) 658{ 659 int s[2]; 660 661 if(adb_socketpair(s)){ 662 fatal_errno("cannot open transport registration socketpair"); 663 } 664 665 transport_registration_send = s[0]; 666 transport_registration_recv = s[1]; 667 668 fdevent_install(&transport_registration_fde, 669 transport_registration_recv, 670 transport_registration_func, 671 0); 672 673 fdevent_set(&transport_registration_fde, FDE_READ); 674} 675 676/* the fdevent select pump is single threaded */ 677static void register_transport(atransport *transport) 678{ 679 tmsg m; 680 m.transport = transport; 681 m.action = 1; 682 D("transport: %s registered\n", transport->serial); 683 if(transport_write_action(transport_registration_send, &m)) { 684 fatal_errno("cannot write transport registration socket\n"); 685 } 686} 687 688static void remove_transport(atransport *transport) 689{ 690 tmsg m; 691 m.transport = transport; 692 m.action = 0; 693 D("transport: %s removed\n", transport->serial); 694 if(transport_write_action(transport_registration_send, &m)) { 695 fatal_errno("cannot write transport registration socket\n"); 696 } 697} 698 699 700static void transport_unref_locked(atransport *t) 701{ 702 t->ref_count--; 703 if (t->ref_count == 0) { 704 D("transport: %s unref (kicking and closing)\n", t->serial); 705 if (!t->kicked) { 706 t->kicked = 1; 707 t->kick(t); 708 } 709 t->close(t); 710 remove_transport(t); 711 } else { 712 D("transport: %s unref (count=%d)\n", t->serial, t->ref_count); 713 } 714} 715 716static void transport_unref(atransport *t) 717{ 718 if (t) { 719 adb_mutex_lock(&transport_lock); 720 transport_unref_locked(t); 721 adb_mutex_unlock(&transport_lock); 722 } 723} 724 725void add_transport_disconnect(atransport* t, adisconnect* dis) 726{ 727 adb_mutex_lock(&transport_lock); 728 dis->next = &t->disconnects; 729 dis->prev = dis->next->prev; 730 dis->prev->next = dis; 731 dis->next->prev = dis; 732 adb_mutex_unlock(&transport_lock); 733} 734 735void remove_transport_disconnect(atransport* t, adisconnect* dis) 736{ 737 dis->prev->next = dis->next; 738 dis->next->prev = dis->prev; 739 dis->next = dis->prev = dis; 740} 741 742 743atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out) 744{ 745 atransport *t; 746 atransport *result = NULL; 747 int ambiguous = 0; 748 749retry: 750 if (error_out) 751 *error_out = "device not found"; 752 753 adb_mutex_lock(&transport_lock); 754 for (t = transport_list.next; t != &transport_list; t = t->next) { 755 if (t->connection_state == CS_NOPERM) { 756 if (error_out) 757 *error_out = "insufficient permissions for device"; 758 continue; 759 } 760 761 /* check for matching serial number */ 762 if (serial) { 763 if (t->serial && !strcmp(serial, t->serial)) { 764 result = t; 765 break; 766 } 767 if (t->devpath && !strcmp(serial, t->devpath)) { 768 result = t; 769 break; 770 } 771 } else { 772 if (ttype == kTransportUsb && t->type == kTransportUsb) { 773 if (result) { 774 if (error_out) 775 *error_out = "more than one device"; 776 ambiguous = 1; 777 result = NULL; 778 break; 779 } 780 result = t; 781 } else if (ttype == kTransportLocal && t->type == kTransportLocal) { 782 if (result) { 783 if (error_out) 784 *error_out = "more than one emulator"; 785 ambiguous = 1; 786 result = NULL; 787 break; 788 } 789 result = t; 790 } else if (ttype == kTransportAny) { 791 if (result) { 792 if (error_out) 793 *error_out = "more than one device and emulator"; 794 ambiguous = 1; 795 result = NULL; 796 break; 797 } 798 result = t; 799 } 800 } 801 } 802 adb_mutex_unlock(&transport_lock); 803 804 if (result) { 805 /* offline devices are ignored -- they are either being born or dying */ 806 if (result && result->connection_state == CS_OFFLINE) { 807 if (error_out) 808 *error_out = "device offline"; 809 result = NULL; 810 } 811 /* check for required connection state */ 812 if (result && state != CS_ANY && result->connection_state != state) { 813 if (error_out) 814 *error_out = "invalid device state"; 815 result = NULL; 816 } 817 } 818 819 if (result) { 820 /* found one that we can take */ 821 if (error_out) 822 *error_out = NULL; 823 } else if (state != CS_ANY && (serial || !ambiguous)) { 824 adb_sleep_ms(1000); 825 goto retry; 826 } 827 828 return result; 829} 830 831#if ADB_HOST 832static const char *statename(atransport *t) 833{ 834 switch(t->connection_state){ 835 case CS_OFFLINE: return "offline"; 836 case CS_BOOTLOADER: return "bootloader"; 837 case CS_DEVICE: return "device"; 838 case CS_HOST: return "host"; 839 case CS_RECOVERY: return "recovery"; 840 case CS_NOPERM: return "no permissions"; 841 default: return "unknown"; 842 } 843} 844 845int list_transports(char *buf, size_t bufsize, int show_devpath) 846{ 847 char* p = buf; 848 char* end = buf + bufsize; 849 int len; 850 atransport *t; 851 852 /* XXX OVERRUN PROBLEMS XXX */ 853 adb_mutex_lock(&transport_lock); 854 for(t = transport_list.next; t != &transport_list; t = t->next) { 855 const char* serial = t->serial; 856 if (!serial || !serial[0]) 857 serial = "????????????"; 858 if (show_devpath) { 859 const char* devpath = t->devpath; 860 if (!devpath || !devpath[0]) 861 devpath = "????????????"; 862 len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, devpath, statename(t)); 863 } else 864 len = snprintf(p, end - p, "%s\t%s\n", serial, statename(t)); 865 866 if (p + len >= end) { 867 /* discard last line if buffer is too short */ 868 break; 869 } 870 p += len; 871 } 872 p[0] = 0; 873 adb_mutex_unlock(&transport_lock); 874 return p - buf; 875} 876 877 878/* hack for osx */ 879void close_usb_devices() 880{ 881 atransport *t; 882 883 adb_mutex_lock(&transport_lock); 884 for(t = transport_list.next; t != &transport_list; t = t->next) { 885 if ( !t->kicked ) { 886 t->kicked = 1; 887 t->kick(t); 888 } 889 } 890 adb_mutex_unlock(&transport_lock); 891} 892#endif // ADB_HOST 893 894void register_socket_transport(int s, const char *serial, int port, int local) 895{ 896 atransport *t = calloc(1, sizeof(atransport)); 897 char buff[32]; 898 899 if (!serial) { 900 snprintf(buff, sizeof buff, "T-%p", t); 901 serial = buff; 902 } 903 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port); 904 if ( init_socket_transport(t, s, port, local) < 0 ) { 905 adb_close(s); 906 free(t); 907 return; 908 } 909 if(serial) { 910 t->serial = strdup(serial); 911 } 912 register_transport(t); 913} 914 915#if ADB_HOST 916atransport *find_transport(const char *serial) 917{ 918 atransport *t; 919 920 adb_mutex_lock(&transport_lock); 921 for(t = transport_list.next; t != &transport_list; t = t->next) { 922 if (t->serial && !strcmp(serial, t->serial)) { 923 break; 924 } 925 } 926 adb_mutex_unlock(&transport_lock); 927 928 if (t != &transport_list) 929 return t; 930 else 931 return 0; 932} 933 934void unregister_transport(atransport *t) 935{ 936 adb_mutex_lock(&transport_lock); 937 t->next->prev = t->prev; 938 t->prev->next = t->next; 939 adb_mutex_unlock(&transport_lock); 940 941 kick_transport(t); 942 transport_unref(t); 943} 944 945// unregisters all non-emulator TCP transports 946void unregister_all_tcp_transports() 947{ 948 atransport *t, *next; 949 adb_mutex_lock(&transport_lock); 950 for (t = transport_list.next; t != &transport_list; t = next) { 951 next = t->next; 952 if (t->type == kTransportLocal && t->adb_port == 0) { 953 t->next->prev = t->prev; 954 t->prev->next = next; 955 // we cannot call kick_transport when holding transport_lock 956 if (!t->kicked) 957 { 958 t->kicked = 1; 959 t->kick(t); 960 } 961 transport_unref_locked(t); 962 } 963 } 964 965 adb_mutex_unlock(&transport_lock); 966} 967 968#endif 969 970void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable) 971{ 972 atransport *t = calloc(1, sizeof(atransport)); 973 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb, 974 serial ? serial : ""); 975 init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM)); 976 if(serial) { 977 t->serial = strdup(serial); 978 } 979 if(devpath) { 980 t->devpath = strdup(devpath); 981 } 982 register_transport(t); 983} 984 985/* this should only be used for transports with connection_state == CS_NOPERM */ 986void unregister_usb_transport(usb_handle *usb) 987{ 988 atransport *t; 989 adb_mutex_lock(&transport_lock); 990 for(t = transport_list.next; t != &transport_list; t = t->next) { 991 if (t->usb == usb && t->connection_state == CS_NOPERM) { 992 t->next->prev = t->prev; 993 t->prev->next = t->next; 994 break; 995 } 996 } 997 adb_mutex_unlock(&transport_lock); 998} 999 1000#undef TRACE_TAG 1001#define TRACE_TAG TRACE_RWX 1002 1003int readx(int fd, void *ptr, size_t len) 1004{ 1005 char *p = ptr; 1006 int r; 1007#if ADB_TRACE 1008 int len0 = len; 1009#endif 1010 D("readx: fd=%d wanted=%d\n", fd, (int)len); 1011 while(len > 0) { 1012 r = adb_read(fd, p, len); 1013 if(r > 0) { 1014 len -= r; 1015 p += r; 1016 } else { 1017 if (r < 0) { 1018 D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1019 if (errno == EINTR) 1020 continue; 1021 } else { 1022 D("readx: fd=%d disconnected\n", fd); 1023 } 1024 return -1; 1025 } 1026 } 1027 1028#if ADB_TRACE 1029 D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len); 1030 dump_hex( ptr, len0 ); 1031#endif 1032 return 0; 1033} 1034 1035int writex(int fd, const void *ptr, size_t len) 1036{ 1037 char *p = (char*) ptr; 1038 int r; 1039 1040#if ADB_TRACE 1041 D("writex: fd=%d len=%d: ", fd, (int)len); 1042 dump_hex( ptr, len ); 1043#endif 1044 while(len > 0) { 1045 r = adb_write(fd, p, len); 1046 if(r > 0) { 1047 len -= r; 1048 p += r; 1049 } else { 1050 if (r < 0) { 1051 D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1052 if (errno == EINTR) 1053 continue; 1054 } else { 1055 D("writex: fd=%d disconnected\n", fd); 1056 } 1057 return -1; 1058 } 1059 } 1060 return 0; 1061} 1062 1063int check_header(apacket *p) 1064{ 1065 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) { 1066 D("check_header(): invalid magic\n"); 1067 return -1; 1068 } 1069 1070 if(p->msg.data_length > MAX_PAYLOAD) { 1071 D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length); 1072 return -1; 1073 } 1074 1075 return 0; 1076} 1077 1078int check_data(apacket *p) 1079{ 1080 unsigned count, sum; 1081 unsigned char *x; 1082 1083 count = p->msg.data_length; 1084 x = p->data; 1085 sum = 0; 1086 while(count-- > 0) { 1087 sum += *x++; 1088 } 1089 1090 if(sum != p->msg.data_check) { 1091 return -1; 1092 } else { 1093 return 0; 1094 } 1095} 1096