transport.c revision 3fef581bc7a513defe48329973d14bec722f1293
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->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 661void 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 */ 681static 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 692static 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 704static 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 720static 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 729void 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 739void 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 747atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out) 748{ 749 atransport *t; 750 atransport *result = NULL; 751 int ambiguous = 0; 752 753retry: 754 if (error_out) 755 *error_out = "device not found"; 756 757 adb_mutex_lock(&transport_lock); 758 for (t = transport_list.next; t != &transport_list; t = t->next) { 759 if (t->connection_state == CS_NOPERM) { 760 if (error_out) 761 *error_out = "insufficient permissions for device"; 762 continue; 763 } 764 765 /* check for matching serial number */ 766 if (serial) { 767 if (t->serial && !strcmp(serial, t->serial)) { 768 result = t; 769 break; 770 } 771 if (t->devpath && !strcmp(serial, t->devpath)) { 772 result = t; 773 break; 774 } 775 } else { 776 if (ttype == kTransportUsb && t->type == kTransportUsb) { 777 if (result) { 778 if (error_out) 779 *error_out = "more than one device"; 780 ambiguous = 1; 781 result = NULL; 782 break; 783 } 784 result = t; 785 } else if (ttype == kTransportLocal && t->type == kTransportLocal) { 786 if (result) { 787 if (error_out) 788 *error_out = "more than one emulator"; 789 ambiguous = 1; 790 result = NULL; 791 break; 792 } 793 result = t; 794 } else if (ttype == kTransportAny) { 795 if (result) { 796 if (error_out) 797 *error_out = "more than one device and emulator"; 798 ambiguous = 1; 799 result = NULL; 800 break; 801 } 802 result = t; 803 } 804 } 805 } 806 adb_mutex_unlock(&transport_lock); 807 808 if (result) { 809 /* offline devices are ignored -- they are either being born or dying */ 810 if (result && result->connection_state == CS_OFFLINE) { 811 if (error_out) 812 *error_out = "device offline"; 813 result = NULL; 814 } 815 /* check for required connection state */ 816 if (result && state != CS_ANY && result->connection_state != state) { 817 if (error_out) 818 *error_out = "invalid device state"; 819 result = NULL; 820 } 821 } 822 823 if (result) { 824 /* found one that we can take */ 825 if (error_out) 826 *error_out = NULL; 827 } else if (state != CS_ANY && (serial || !ambiguous)) { 828 adb_sleep_ms(1000); 829 goto retry; 830 } 831 832 return result; 833} 834 835#if ADB_HOST 836static const char *statename(atransport *t) 837{ 838 switch(t->connection_state){ 839 case CS_OFFLINE: return "offline"; 840 case CS_BOOTLOADER: return "bootloader"; 841 case CS_DEVICE: return "device"; 842 case CS_HOST: return "host"; 843 case CS_RECOVERY: return "recovery"; 844 case CS_SIDELOAD: return "sideload"; 845 case CS_NOPERM: return "no permissions"; 846 default: return "unknown"; 847 } 848} 849 850int list_transports(char *buf, size_t bufsize, int show_devpath) 851{ 852 char* p = buf; 853 char* end = buf + bufsize; 854 int len; 855 atransport *t; 856 857 /* XXX OVERRUN PROBLEMS XXX */ 858 adb_mutex_lock(&transport_lock); 859 for(t = transport_list.next; t != &transport_list; t = t->next) { 860 const char* serial = t->serial; 861 if (!serial || !serial[0]) 862 serial = "????????????"; 863 if (show_devpath) { 864 const char* devpath = t->devpath; 865 if (!devpath || !devpath[0]) 866 devpath = "????????????"; 867 len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, devpath, statename(t)); 868 } else 869 len = snprintf(p, end - p, "%s\t%s\n", serial, statename(t)); 870 871 if (p + len >= end) { 872 /* discard last line if buffer is too short */ 873 break; 874 } 875 p += len; 876 } 877 p[0] = 0; 878 adb_mutex_unlock(&transport_lock); 879 return p - buf; 880} 881 882 883/* hack for osx */ 884void close_usb_devices() 885{ 886 atransport *t; 887 888 adb_mutex_lock(&transport_lock); 889 for(t = transport_list.next; t != &transport_list; t = t->next) { 890 if ( !t->kicked ) { 891 t->kicked = 1; 892 t->kick(t); 893 } 894 } 895 adb_mutex_unlock(&transport_lock); 896} 897#endif // ADB_HOST 898 899void register_socket_transport(int s, const char *serial, int port, int local) 900{ 901 atransport *t = calloc(1, sizeof(atransport)); 902 char buff[32]; 903 904 if (!serial) { 905 snprintf(buff, sizeof buff, "T-%p", t); 906 serial = buff; 907 } 908 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port); 909 if ( init_socket_transport(t, s, port, local) < 0 ) { 910 adb_close(s); 911 free(t); 912 return; 913 } 914 if(serial) { 915 t->serial = strdup(serial); 916 } 917 register_transport(t); 918} 919 920#if ADB_HOST 921atransport *find_transport(const char *serial) 922{ 923 atransport *t; 924 925 adb_mutex_lock(&transport_lock); 926 for(t = transport_list.next; t != &transport_list; t = t->next) { 927 if (t->serial && !strcmp(serial, t->serial)) { 928 break; 929 } 930 } 931 adb_mutex_unlock(&transport_lock); 932 933 if (t != &transport_list) 934 return t; 935 else 936 return 0; 937} 938 939void unregister_transport(atransport *t) 940{ 941 adb_mutex_lock(&transport_lock); 942 t->next->prev = t->prev; 943 t->prev->next = t->next; 944 adb_mutex_unlock(&transport_lock); 945 946 kick_transport(t); 947 transport_unref(t); 948} 949 950// unregisters all non-emulator TCP transports 951void unregister_all_tcp_transports() 952{ 953 atransport *t, *next; 954 adb_mutex_lock(&transport_lock); 955 for (t = transport_list.next; t != &transport_list; t = next) { 956 next = t->next; 957 if (t->type == kTransportLocal && t->adb_port == 0) { 958 t->next->prev = t->prev; 959 t->prev->next = next; 960 // we cannot call kick_transport when holding transport_lock 961 if (!t->kicked) 962 { 963 t->kicked = 1; 964 t->kick(t); 965 } 966 transport_unref_locked(t); 967 } 968 } 969 970 adb_mutex_unlock(&transport_lock); 971} 972 973#endif 974 975void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable) 976{ 977 atransport *t = calloc(1, sizeof(atransport)); 978 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb, 979 serial ? serial : ""); 980 init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM)); 981 if(serial) { 982 t->serial = strdup(serial); 983 } 984 if(devpath) { 985 t->devpath = strdup(devpath); 986 } 987 register_transport(t); 988} 989 990/* this should only be used for transports with connection_state == CS_NOPERM */ 991void unregister_usb_transport(usb_handle *usb) 992{ 993 atransport *t; 994 adb_mutex_lock(&transport_lock); 995 for(t = transport_list.next; t != &transport_list; t = t->next) { 996 if (t->usb == usb && t->connection_state == CS_NOPERM) { 997 t->next->prev = t->prev; 998 t->prev->next = t->next; 999 break; 1000 } 1001 } 1002 adb_mutex_unlock(&transport_lock); 1003} 1004 1005#undef TRACE_TAG 1006#define TRACE_TAG TRACE_RWX 1007 1008int readx(int fd, void *ptr, size_t len) 1009{ 1010 char *p = ptr; 1011 int r; 1012#if ADB_TRACE 1013 int len0 = len; 1014#endif 1015 D("readx: fd=%d wanted=%d\n", fd, (int)len); 1016 while(len > 0) { 1017 r = adb_read(fd, p, len); 1018 if(r > 0) { 1019 len -= r; 1020 p += r; 1021 } else { 1022 if (r < 0) { 1023 D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1024 if (errno == EINTR) 1025 continue; 1026 } else { 1027 D("readx: fd=%d disconnected\n", fd); 1028 } 1029 return -1; 1030 } 1031 } 1032 1033#if ADB_TRACE 1034 D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len); 1035 dump_hex( ptr, len0 ); 1036#endif 1037 return 0; 1038} 1039 1040int writex(int fd, const void *ptr, size_t len) 1041{ 1042 char *p = (char*) ptr; 1043 int r; 1044 1045#if ADB_TRACE 1046 D("writex: fd=%d len=%d: ", fd, (int)len); 1047 dump_hex( ptr, len ); 1048#endif 1049 while(len > 0) { 1050 r = adb_write(fd, p, len); 1051 if(r > 0) { 1052 len -= r; 1053 p += r; 1054 } else { 1055 if (r < 0) { 1056 D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno)); 1057 if (errno == EINTR) 1058 continue; 1059 } else { 1060 D("writex: fd=%d disconnected\n", fd); 1061 } 1062 return -1; 1063 } 1064 } 1065 return 0; 1066} 1067 1068int check_header(apacket *p) 1069{ 1070 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) { 1071 D("check_header(): invalid magic\n"); 1072 return -1; 1073 } 1074 1075 if(p->msg.data_length > MAX_PAYLOAD) { 1076 D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length); 1077 return -1; 1078 } 1079 1080 return 0; 1081} 1082 1083int check_data(apacket *p) 1084{ 1085 unsigned count, sum; 1086 unsigned char *x; 1087 1088 count = p->msg.data_length; 1089 x = p->data; 1090 sum = 0; 1091 while(count-- > 0) { 1092 sum += *x++; 1093 } 1094 1095 if(sum != p->msg.data_check) { 1096 return -1; 1097 } else { 1098 return 0; 1099 } 1100} 1101