adb.c revision 252586941934d23073a8d167ec240b221062505f
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#define TRACE_TAG TRACE_ADB 18 19#include <stdio.h> 20#include <stdlib.h> 21#include <ctype.h> 22#include <stdarg.h> 23#include <errno.h> 24#include <stddef.h> 25#include <string.h> 26#include <time.h> 27#include <sys/time.h> 28#include <stdint.h> 29 30#include "sysdeps.h" 31#include "adb.h" 32#include "adb_auth.h" 33 34#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 35 36#if !ADB_HOST 37#include <cutils/properties.h> 38#include <private/android_filesystem_config.h> 39#include <sys/capability.h> 40#include <linux/prctl.h> 41#include <sys/mount.h> 42#include <getopt.h> 43#include <selinux/selinux.h> 44#else 45#include "usb_vendors.h" 46#endif 47 48#if ADB_TRACE 49ADB_MUTEX_DEFINE( D_lock ); 50#endif 51 52int HOST = 0; 53int gListenAll = 0; 54 55static int auth_enabled = 0; 56 57#if !ADB_HOST 58static const char *adb_device_banner = "device"; 59static const char *root_seclabel = NULL; 60#endif 61 62void fatal(const char *fmt, ...) 63{ 64 va_list ap; 65 va_start(ap, fmt); 66 fprintf(stderr, "error: "); 67 vfprintf(stderr, fmt, ap); 68 fprintf(stderr, "\n"); 69 va_end(ap); 70 exit(-1); 71} 72 73void fatal_errno(const char *fmt, ...) 74{ 75 va_list ap; 76 va_start(ap, fmt); 77 fprintf(stderr, "error: %s: ", strerror(errno)); 78 vfprintf(stderr, fmt, ap); 79 fprintf(stderr, "\n"); 80 va_end(ap); 81 exit(-1); 82} 83 84int adb_trace_mask; 85 86/* read a comma/space/colum/semi-column separated list of tags 87 * from the ADB_TRACE environment variable and build the trace 88 * mask from it. note that '1' and 'all' are special cases to 89 * enable all tracing 90 */ 91void adb_trace_init(void) 92{ 93 const char* p = getenv("ADB_TRACE"); 94 const char* q; 95 96 static const struct { 97 const char* tag; 98 int flag; 99 } tags[] = { 100 { "1", 0 }, 101 { "all", 0 }, 102 { "adb", TRACE_ADB }, 103 { "sockets", TRACE_SOCKETS }, 104 { "packets", TRACE_PACKETS }, 105 { "rwx", TRACE_RWX }, 106 { "usb", TRACE_USB }, 107 { "sync", TRACE_SYNC }, 108 { "sysdeps", TRACE_SYSDEPS }, 109 { "transport", TRACE_TRANSPORT }, 110 { "jdwp", TRACE_JDWP }, 111 { "services", TRACE_SERVICES }, 112 { "auth", TRACE_AUTH }, 113 { NULL, 0 } 114 }; 115 116 if (p == NULL) 117 return; 118 119 /* use a comma/column/semi-colum/space separated list */ 120 while (*p) { 121 int len, tagn; 122 123 q = strpbrk(p, " ,:;"); 124 if (q == NULL) { 125 q = p + strlen(p); 126 } 127 len = q - p; 128 129 for (tagn = 0; tags[tagn].tag != NULL; tagn++) 130 { 131 int taglen = strlen(tags[tagn].tag); 132 133 if (len == taglen && !memcmp(tags[tagn].tag, p, len) ) 134 { 135 int flag = tags[tagn].flag; 136 if (flag == 0) { 137 adb_trace_mask = ~0; 138 return; 139 } 140 adb_trace_mask |= (1 << flag); 141 break; 142 } 143 } 144 p = q; 145 if (*p) 146 p++; 147 } 148} 149 150#if !ADB_HOST 151/* 152 * Implements ADB tracing inside the emulator. 153 */ 154 155#include <stdarg.h> 156 157/* 158 * Redefine open and write for qemu_pipe.h that contains inlined references 159 * to those routines. We will redifine them back after qemu_pipe.h inclusion. 160 */ 161 162#undef open 163#undef write 164#define open adb_open 165#define write adb_write 166#include <hardware/qemu_pipe.h> 167#undef open 168#undef write 169#define open ___xxx_open 170#define write ___xxx_write 171 172/* A handle to adb-debug qemud service in the emulator. */ 173int adb_debug_qemu = -1; 174 175/* Initializes connection with the adb-debug qemud service in the emulator. */ 176static int adb_qemu_trace_init(void) 177{ 178 char con_name[32]; 179 180 if (adb_debug_qemu >= 0) { 181 return 0; 182 } 183 184 /* adb debugging QEMUD service connection request. */ 185 snprintf(con_name, sizeof(con_name), "qemud:adb-debug"); 186 adb_debug_qemu = qemu_pipe_open(con_name); 187 return (adb_debug_qemu >= 0) ? 0 : -1; 188} 189 190void adb_qemu_trace(const char* fmt, ...) 191{ 192 va_list args; 193 va_start(args, fmt); 194 char msg[1024]; 195 196 if (adb_debug_qemu >= 0) { 197 vsnprintf(msg, sizeof(msg), fmt, args); 198 adb_write(adb_debug_qemu, msg, strlen(msg)); 199 } 200} 201#endif /* !ADB_HOST */ 202 203apacket *get_apacket(void) 204{ 205 apacket *p = malloc(sizeof(apacket)); 206 if(p == 0) fatal("failed to allocate an apacket"); 207 memset(p, 0, sizeof(apacket) - MAX_PAYLOAD); 208 return p; 209} 210 211void put_apacket(apacket *p) 212{ 213 free(p); 214} 215 216void handle_online(atransport *t) 217{ 218 D("adb: online\n"); 219 t->online = 1; 220} 221 222void handle_offline(atransport *t) 223{ 224 D("adb: offline\n"); 225 //Close the associated usb 226 t->online = 0; 227 run_transport_disconnects(t); 228} 229 230#if DEBUG_PACKETS 231#define DUMPMAX 32 232void print_packet(const char *label, apacket *p) 233{ 234 char *tag; 235 char *x; 236 unsigned count; 237 238 switch(p->msg.command){ 239 case A_SYNC: tag = "SYNC"; break; 240 case A_CNXN: tag = "CNXN" ; break; 241 case A_OPEN: tag = "OPEN"; break; 242 case A_OKAY: tag = "OKAY"; break; 243 case A_CLSE: tag = "CLSE"; break; 244 case A_WRTE: tag = "WRTE"; break; 245 case A_AUTH: tag = "AUTH"; break; 246 default: tag = "????"; break; 247 } 248 249 fprintf(stderr, "%s: %s %08x %08x %04x \"", 250 label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length); 251 count = p->msg.data_length; 252 x = (char*) p->data; 253 if(count > DUMPMAX) { 254 count = DUMPMAX; 255 tag = "\n"; 256 } else { 257 tag = "\"\n"; 258 } 259 while(count-- > 0){ 260 if((*x >= ' ') && (*x < 127)) { 261 fputc(*x, stderr); 262 } else { 263 fputc('.', stderr); 264 } 265 x++; 266 } 267 fputs(tag, stderr); 268} 269#endif 270 271static void send_ready(unsigned local, unsigned remote, atransport *t) 272{ 273 D("Calling send_ready \n"); 274 apacket *p = get_apacket(); 275 p->msg.command = A_OKAY; 276 p->msg.arg0 = local; 277 p->msg.arg1 = remote; 278 send_packet(p, t); 279} 280 281static void send_close(unsigned local, unsigned remote, atransport *t) 282{ 283 D("Calling send_close \n"); 284 apacket *p = get_apacket(); 285 p->msg.command = A_CLSE; 286 p->msg.arg0 = local; 287 p->msg.arg1 = remote; 288 send_packet(p, t); 289} 290 291static size_t fill_connect_data(char *buf, size_t bufsize) 292{ 293#if ADB_HOST 294 return snprintf(buf, bufsize, "host::") + 1; 295#else 296 static const char *cnxn_props[] = { 297 "ro.product.name", 298 "ro.product.model", 299 "ro.product.device", 300 }; 301 static const int num_cnxn_props = ARRAY_SIZE(cnxn_props); 302 int i; 303 size_t remaining = bufsize; 304 size_t len; 305 306 len = snprintf(buf, remaining, "%s::", adb_device_banner); 307 remaining -= len; 308 buf += len; 309 for (i = 0; i < num_cnxn_props; i++) { 310 char value[PROPERTY_VALUE_MAX]; 311 property_get(cnxn_props[i], value, ""); 312 len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i], value); 313 remaining -= len; 314 buf += len; 315 } 316 317 return bufsize - remaining + 1; 318#endif 319} 320 321#if !ADB_HOST 322static void send_msg_with_header(int fd, const char* msg, size_t msglen) { 323 char header[5]; 324 if (msglen > 0xffff) 325 msglen = 0xffff; 326 snprintf(header, sizeof(header), "%04x", (unsigned)msglen); 327 writex(fd, header, 4); 328 writex(fd, msg, msglen); 329} 330#endif 331 332static void send_msg_with_okay(int fd, const char* msg, size_t msglen) { 333 char header[9]; 334 if (msglen > 0xffff) 335 msglen = 0xffff; 336 snprintf(header, sizeof(header), "OKAY%04x", (unsigned)msglen); 337 writex(fd, header, 8); 338 writex(fd, msg, msglen); 339} 340 341static void send_connect(atransport *t) 342{ 343 D("Calling send_connect \n"); 344 apacket *cp = get_apacket(); 345 cp->msg.command = A_CNXN; 346 cp->msg.arg0 = A_VERSION; 347 cp->msg.arg1 = MAX_PAYLOAD; 348 cp->msg.data_length = fill_connect_data((char *)cp->data, 349 sizeof(cp->data)); 350 send_packet(cp, t); 351} 352 353void send_auth_request(atransport *t) 354{ 355 D("Calling send_auth_request\n"); 356 apacket *p; 357 int ret; 358 359 ret = adb_auth_generate_token(t->token, sizeof(t->token)); 360 if (ret != sizeof(t->token)) { 361 D("Error generating token ret=%d\n", ret); 362 return; 363 } 364 365 p = get_apacket(); 366 memcpy(p->data, t->token, ret); 367 p->msg.command = A_AUTH; 368 p->msg.arg0 = ADB_AUTH_TOKEN; 369 p->msg.data_length = ret; 370 send_packet(p, t); 371} 372 373static void send_auth_response(uint8_t *token, size_t token_size, atransport *t) 374{ 375 D("Calling send_auth_response\n"); 376 apacket *p = get_apacket(); 377 int ret; 378 379 ret = adb_auth_sign(t->key, token, token_size, p->data); 380 if (!ret) { 381 D("Error signing the token\n"); 382 put_apacket(p); 383 return; 384 } 385 386 p->msg.command = A_AUTH; 387 p->msg.arg0 = ADB_AUTH_SIGNATURE; 388 p->msg.data_length = ret; 389 send_packet(p, t); 390} 391 392static void send_auth_publickey(atransport *t) 393{ 394 D("Calling send_auth_publickey\n"); 395 apacket *p = get_apacket(); 396 int ret; 397 398 ret = adb_auth_get_userkey(p->data, sizeof(p->data)); 399 if (!ret) { 400 D("Failed to get user public key\n"); 401 put_apacket(p); 402 return; 403 } 404 405 p->msg.command = A_AUTH; 406 p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY; 407 p->msg.data_length = ret; 408 send_packet(p, t); 409} 410 411void adb_auth_verified(atransport *t) 412{ 413 handle_online(t); 414 send_connect(t); 415} 416 417static char *connection_state_name(atransport *t) 418{ 419 if (t == NULL) { 420 return "unknown"; 421 } 422 423 switch(t->connection_state) { 424 case CS_BOOTLOADER: 425 return "bootloader"; 426 case CS_DEVICE: 427 return "device"; 428 case CS_RECOVERY: 429 return "recovery"; 430 case CS_SIDELOAD: 431 return "sideload"; 432 case CS_OFFLINE: 433 return "offline"; 434 case CS_UNAUTHORIZED: 435 return "unauthorized"; 436 default: 437 return "unknown"; 438 } 439} 440 441/* qual_overwrite is used to overwrite a qualifier string. dst is a 442 * pointer to a char pointer. It is assumed that if *dst is non-NULL, it 443 * was malloc'ed and needs to freed. *dst will be set to a dup of src. 444 */ 445static void qual_overwrite(char **dst, const char *src) 446{ 447 if (!dst) 448 return; 449 450 free(*dst); 451 *dst = NULL; 452 453 if (!src || !*src) 454 return; 455 456 *dst = strdup(src); 457} 458 459void parse_banner(char *banner, atransport *t) 460{ 461 static const char *prop_seps = ";"; 462 static const char key_val_sep = '='; 463 char *cp; 464 char *type; 465 466 D("parse_banner: %s\n", banner); 467 type = banner; 468 cp = strchr(type, ':'); 469 if (cp) { 470 *cp++ = 0; 471 /* Nothing is done with second field. */ 472 cp = strchr(cp, ':'); 473 if (cp) { 474 char *save; 475 char *key; 476 key = adb_strtok_r(cp + 1, prop_seps, &save); 477 while (key) { 478 cp = strchr(key, key_val_sep); 479 if (cp) { 480 *cp++ = '\0'; 481 if (!strcmp(key, "ro.product.name")) 482 qual_overwrite(&t->product, cp); 483 else if (!strcmp(key, "ro.product.model")) 484 qual_overwrite(&t->model, cp); 485 else if (!strcmp(key, "ro.product.device")) 486 qual_overwrite(&t->device, cp); 487 } 488 key = adb_strtok_r(NULL, prop_seps, &save); 489 } 490 } 491 } 492 493 if(!strcmp(type, "bootloader")){ 494 D("setting connection_state to CS_BOOTLOADER\n"); 495 t->connection_state = CS_BOOTLOADER; 496 update_transports(); 497 return; 498 } 499 500 if(!strcmp(type, "device")) { 501 D("setting connection_state to CS_DEVICE\n"); 502 t->connection_state = CS_DEVICE; 503 update_transports(); 504 return; 505 } 506 507 if(!strcmp(type, "recovery")) { 508 D("setting connection_state to CS_RECOVERY\n"); 509 t->connection_state = CS_RECOVERY; 510 update_transports(); 511 return; 512 } 513 514 if(!strcmp(type, "sideload")) { 515 D("setting connection_state to CS_SIDELOAD\n"); 516 t->connection_state = CS_SIDELOAD; 517 update_transports(); 518 return; 519 } 520 521 t->connection_state = CS_HOST; 522} 523 524void handle_packet(apacket *p, atransport *t) 525{ 526 asocket *s; 527 528 D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0], 529 ((char*) (&(p->msg.command)))[1], 530 ((char*) (&(p->msg.command)))[2], 531 ((char*) (&(p->msg.command)))[3]); 532 print_packet("recv", p); 533 534 switch(p->msg.command){ 535 case A_SYNC: 536 if(p->msg.arg0){ 537 send_packet(p, t); 538 if(HOST) send_connect(t); 539 } else { 540 t->connection_state = CS_OFFLINE; 541 handle_offline(t); 542 send_packet(p, t); 543 } 544 return; 545 546 case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */ 547 /* XXX verify version, etc */ 548 if(t->connection_state != CS_OFFLINE) { 549 t->connection_state = CS_OFFLINE; 550 handle_offline(t); 551 } 552 553 parse_banner((char*) p->data, t); 554 555 if (HOST || !auth_enabled) { 556 handle_online(t); 557 if(!HOST) send_connect(t); 558 } else { 559 send_auth_request(t); 560 } 561 break; 562 563 case A_AUTH: 564 if (p->msg.arg0 == ADB_AUTH_TOKEN) { 565 t->connection_state = CS_UNAUTHORIZED; 566 t->key = adb_auth_nextkey(t->key); 567 if (t->key) { 568 send_auth_response(p->data, p->msg.data_length, t); 569 } else { 570 /* No more private keys to try, send the public key */ 571 send_auth_publickey(t); 572 } 573 } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) { 574 if (adb_auth_verify(t->token, p->data, p->msg.data_length)) { 575 adb_auth_verified(t); 576 t->failed_auth_attempts = 0; 577 } else { 578 if (t->failed_auth_attempts++ > 10) 579 adb_sleep_ms(1000); 580 send_auth_request(t); 581 } 582 } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) { 583 adb_auth_confirm_key(p->data, p->msg.data_length, t); 584 } 585 break; 586 587 case A_OPEN: /* OPEN(local-id, 0, "destination") */ 588 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) { 589 char *name = (char*) p->data; 590 name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0; 591 s = create_local_service_socket(name); 592 if(s == 0) { 593 send_close(0, p->msg.arg0, t); 594 } else { 595 s->peer = create_remote_socket(p->msg.arg0, t); 596 s->peer->peer = s; 597 send_ready(s->id, s->peer->id, t); 598 s->ready(s); 599 } 600 } 601 break; 602 603 case A_OKAY: /* READY(local-id, remote-id, "") */ 604 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { 605 if((s = find_local_socket(p->msg.arg1, 0))) { 606 if(s->peer == 0) { 607 /* On first READY message, create the connection. */ 608 s->peer = create_remote_socket(p->msg.arg0, t); 609 s->peer->peer = s; 610 s->ready(s); 611 } else if (s->peer->id == p->msg.arg0) { 612 /* Other READY messages must use the same local-id */ 613 s->ready(s); 614 } else { 615 D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s\n", 616 p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial); 617 } 618 } 619 } 620 break; 621 622 case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */ 623 if (t->online && p->msg.arg1 != 0) { 624 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { 625 /* According to protocol.txt, p->msg.arg0 might be 0 to indicate 626 * a failed OPEN only. However, due to a bug in previous ADB 627 * versions, CLOSE(0, remote-id, "") was also used for normal 628 * CLOSE() operations. 629 * 630 * This is bad because it means a compromised adbd could 631 * send packets to close connections between the host and 632 * other devices. To avoid this, only allow this if the local 633 * socket has a peer on the same transport. 634 */ 635 if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) { 636 D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s\n", 637 p->msg.arg1, t->serial, s->peer->transport->serial); 638 } else { 639 s->close(s); 640 } 641 } 642 } 643 break; 644 645 case A_WRTE: /* WRITE(local-id, remote-id, <data>) */ 646 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { 647 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { 648 unsigned rid = p->msg.arg0; 649 p->len = p->msg.data_length; 650 651 if(s->enqueue(s, p) == 0) { 652 D("Enqueue the socket\n"); 653 send_ready(s->id, rid, t); 654 } 655 return; 656 } 657 } 658 break; 659 660 default: 661 printf("handle_packet: what is %08x?!\n", p->msg.command); 662 } 663 664 put_apacket(p); 665} 666 667alistener listener_list = { 668 .next = &listener_list, 669 .prev = &listener_list, 670}; 671 672static void ss_listener_event_func(int _fd, unsigned ev, void *_l) 673{ 674 asocket *s; 675 676 if(ev & FDE_READ) { 677 struct sockaddr addr; 678 socklen_t alen; 679 int fd; 680 681 alen = sizeof(addr); 682 fd = adb_socket_accept(_fd, &addr, &alen); 683 if(fd < 0) return; 684 685 adb_socket_setbufsize(fd, CHUNK_SIZE); 686 687 s = create_local_socket(fd); 688 if(s) { 689 connect_to_smartsocket(s); 690 return; 691 } 692 693 adb_close(fd); 694 } 695} 696 697static void listener_event_func(int _fd, unsigned ev, void *_l) 698{ 699 alistener *l = _l; 700 asocket *s; 701 702 if(ev & FDE_READ) { 703 struct sockaddr addr; 704 socklen_t alen; 705 int fd; 706 707 alen = sizeof(addr); 708 fd = adb_socket_accept(_fd, &addr, &alen); 709 if(fd < 0) return; 710 711 s = create_local_socket(fd); 712 if(s) { 713 s->transport = l->transport; 714 connect_to_remote(s, l->connect_to); 715 return; 716 } 717 718 adb_close(fd); 719 } 720} 721 722static void free_listener(alistener* l) 723{ 724 if (l->next) { 725 l->next->prev = l->prev; 726 l->prev->next = l->next; 727 l->next = l->prev = l; 728 } 729 730 // closes the corresponding fd 731 fdevent_remove(&l->fde); 732 733 if (l->local_name) 734 free((char*)l->local_name); 735 736 if (l->connect_to) 737 free((char*)l->connect_to); 738 739 if (l->transport) { 740 remove_transport_disconnect(l->transport, &l->disconnect); 741 } 742 free(l); 743} 744 745static void listener_disconnect(void* _l, atransport* t) 746{ 747 alistener* l = _l; 748 749 free_listener(l); 750} 751 752int local_name_to_fd(const char *name) 753{ 754 int port; 755 756 if(!strncmp("tcp:", name, 4)){ 757 int ret; 758 port = atoi(name + 4); 759 760 if (gListenAll > 0) { 761 ret = socket_inaddr_any_server(port, SOCK_STREAM); 762 } else { 763 ret = socket_loopback_server(port, SOCK_STREAM); 764 } 765 766 return ret; 767 } 768#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */ 769 // It's non-sensical to support the "reserved" space on the adb host side 770 if(!strncmp(name, "local:", 6)) { 771 return socket_local_server(name + 6, 772 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); 773 } else if(!strncmp(name, "localabstract:", 14)) { 774 return socket_local_server(name + 14, 775 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); 776 } else if(!strncmp(name, "localfilesystem:", 16)) { 777 return socket_local_server(name + 16, 778 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM); 779 } 780 781#endif 782 printf("unknown local portname '%s'\n", name); 783 return -1; 784} 785 786// Write a single line describing a listener to a user-provided buffer. 787// Appends a trailing zero, even in case of truncation, but the function 788// returns the full line length. 789// If |buffer| is NULL, does not write but returns required size. 790static int format_listener(alistener* l, char* buffer, size_t buffer_len) { 791 // Format is simply: 792 // 793 // <device-serial> " " <local-name> " " <remote-name> "\n" 794 // 795 int local_len = strlen(l->local_name); 796 int connect_len = strlen(l->connect_to); 797 int serial_len = strlen(l->transport->serial); 798 799 if (buffer != NULL) { 800 snprintf(buffer, buffer_len, "%s %s %s\n", 801 l->transport->serial, l->local_name, l->connect_to); 802 } 803 // NOTE: snprintf() on Windows returns -1 in case of truncation, so 804 // return the computed line length instead. 805 return local_len + connect_len + serial_len + 3; 806} 807 808// Write the list of current listeners (network redirections) into a 809// user-provided buffer. Appends a trailing zero, even in case of 810// trunctaion, but return the full size in bytes. 811// If |buffer| is NULL, does not write but returns required size. 812static int format_listeners(char* buf, size_t buflen) 813{ 814 alistener* l; 815 int result = 0; 816 for (l = listener_list.next; l != &listener_list; l = l->next) { 817 // Ignore special listeners like those for *smartsocket* 818 if (l->connect_to[0] == '*') 819 continue; 820 int len = format_listener(l, buf, buflen); 821 // Ensure there is space for the trailing zero. 822 result += len; 823 if (buf != NULL) { 824 buf += len; 825 buflen -= len; 826 if (buflen <= 0) 827 break; 828 } 829 } 830 return result; 831} 832 833static int remove_listener(const char *local_name, atransport* transport) 834{ 835 alistener *l; 836 837 for (l = listener_list.next; l != &listener_list; l = l->next) { 838 if (!strcmp(local_name, l->local_name)) { 839 listener_disconnect(l, l->transport); 840 return 0; 841 } 842 } 843 return -1; 844} 845 846static void remove_all_listeners(void) 847{ 848 alistener *l, *l_next; 849 for (l = listener_list.next; l != &listener_list; l = l_next) { 850 l_next = l->next; 851 // Never remove smart sockets. 852 if (l->connect_to[0] == '*') 853 continue; 854 listener_disconnect(l, l->transport); 855 } 856} 857 858// error/status codes for install_listener. 859typedef enum { 860 INSTALL_STATUS_OK = 0, 861 INSTALL_STATUS_INTERNAL_ERROR = -1, 862 INSTALL_STATUS_CANNOT_BIND = -2, 863 INSTALL_STATUS_CANNOT_REBIND = -3, 864} install_status_t; 865 866static install_status_t install_listener(const char *local_name, 867 const char *connect_to, 868 atransport* transport, 869 int no_rebind) 870{ 871 alistener *l; 872 873 //printf("install_listener('%s','%s')\n", local_name, connect_to); 874 875 for(l = listener_list.next; l != &listener_list; l = l->next){ 876 if(strcmp(local_name, l->local_name) == 0) { 877 char *cto; 878 879 /* can't repurpose a smartsocket */ 880 if(l->connect_to[0] == '*') { 881 return INSTALL_STATUS_INTERNAL_ERROR; 882 } 883 884 /* can't repurpose a listener if 'no_rebind' is true */ 885 if (no_rebind) { 886 return INSTALL_STATUS_CANNOT_REBIND; 887 } 888 889 cto = strdup(connect_to); 890 if(cto == 0) { 891 return INSTALL_STATUS_INTERNAL_ERROR; 892 } 893 894 //printf("rebinding '%s' to '%s'\n", local_name, connect_to); 895 free((void*) l->connect_to); 896 l->connect_to = cto; 897 if (l->transport != transport) { 898 remove_transport_disconnect(l->transport, &l->disconnect); 899 l->transport = transport; 900 add_transport_disconnect(l->transport, &l->disconnect); 901 } 902 return INSTALL_STATUS_OK; 903 } 904 } 905 906 if((l = calloc(1, sizeof(alistener))) == 0) goto nomem; 907 if((l->local_name = strdup(local_name)) == 0) goto nomem; 908 if((l->connect_to = strdup(connect_to)) == 0) goto nomem; 909 910 911 l->fd = local_name_to_fd(local_name); 912 if(l->fd < 0) { 913 free((void*) l->local_name); 914 free((void*) l->connect_to); 915 free(l); 916 printf("cannot bind '%s'\n", local_name); 917 return -2; 918 } 919 920 close_on_exec(l->fd); 921 if(!strcmp(l->connect_to, "*smartsocket*")) { 922 fdevent_install(&l->fde, l->fd, ss_listener_event_func, l); 923 } else { 924 fdevent_install(&l->fde, l->fd, listener_event_func, l); 925 } 926 fdevent_set(&l->fde, FDE_READ); 927 928 l->next = &listener_list; 929 l->prev = listener_list.prev; 930 l->next->prev = l; 931 l->prev->next = l; 932 l->transport = transport; 933 934 if (transport) { 935 l->disconnect.opaque = l; 936 l->disconnect.func = listener_disconnect; 937 add_transport_disconnect(transport, &l->disconnect); 938 } 939 return INSTALL_STATUS_OK; 940 941nomem: 942 fatal("cannot allocate listener"); 943 return INSTALL_STATUS_INTERNAL_ERROR; 944} 945 946#ifdef HAVE_WIN32_PROC 947static BOOL WINAPI ctrlc_handler(DWORD type) 948{ 949 exit(STATUS_CONTROL_C_EXIT); 950 return TRUE; 951} 952#endif 953 954static void adb_cleanup(void) 955{ 956 usb_cleanup(); 957} 958 959void start_logging(void) 960{ 961#ifdef HAVE_WIN32_PROC 962 char temp[ MAX_PATH ]; 963 FILE* fnul; 964 FILE* flog; 965 966 GetTempPath( sizeof(temp) - 8, temp ); 967 strcat( temp, "adb.log" ); 968 969 /* Win32 specific redirections */ 970 fnul = fopen( "NUL", "rt" ); 971 if (fnul != NULL) 972 stdin[0] = fnul[0]; 973 974 flog = fopen( temp, "at" ); 975 if (flog == NULL) 976 flog = fnul; 977 978 setvbuf( flog, NULL, _IONBF, 0 ); 979 980 stdout[0] = flog[0]; 981 stderr[0] = flog[0]; 982 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid()); 983#else 984 int fd; 985 986 fd = unix_open("/dev/null", O_RDONLY); 987 dup2(fd, 0); 988 adb_close(fd); 989 990 fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640); 991 if(fd < 0) { 992 fd = unix_open("/dev/null", O_WRONLY); 993 } 994 dup2(fd, 1); 995 dup2(fd, 2); 996 adb_close(fd); 997 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid()); 998#endif 999} 1000 1001#if !ADB_HOST 1002void start_device_log(void) 1003{ 1004 int fd; 1005 char path[PATH_MAX]; 1006 struct tm now; 1007 time_t t; 1008 char value[PROPERTY_VALUE_MAX]; 1009 1010 // read the trace mask from persistent property persist.adb.trace_mask 1011 // give up if the property is not set or cannot be parsed 1012 property_get("persist.adb.trace_mask", value, ""); 1013 if (sscanf(value, "%x", &adb_trace_mask) != 1) 1014 return; 1015 1016 adb_mkdir("/data/adb", 0775); 1017 tzset(); 1018 time(&t); 1019 localtime_r(&t, &now); 1020 strftime(path, sizeof(path), 1021 "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt", 1022 &now); 1023 fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640); 1024 if (fd < 0) 1025 return; 1026 1027 // redirect stdout and stderr to the log file 1028 dup2(fd, 1); 1029 dup2(fd, 2); 1030 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid()); 1031 adb_close(fd); 1032 1033 fd = unix_open("/dev/null", O_RDONLY); 1034 dup2(fd, 0); 1035 adb_close(fd); 1036} 1037#endif 1038 1039#if ADB_HOST 1040 1041#ifdef WORKAROUND_BUG6558362 1042#include <sched.h> 1043#define AFFINITY_ENVVAR "ADB_CPU_AFFINITY_BUG6558362" 1044void adb_set_affinity(void) 1045{ 1046 cpu_set_t cpu_set; 1047 const char* cpunum_str = getenv(AFFINITY_ENVVAR); 1048 char* strtol_res; 1049 int cpu_num; 1050 1051 if (!cpunum_str || !*cpunum_str) 1052 return; 1053 cpu_num = strtol(cpunum_str, &strtol_res, 0); 1054 if (*strtol_res != '\0') 1055 fatal("bad number (%s) in env var %s. Expecting 0..n.\n", cpunum_str, AFFINITY_ENVVAR); 1056 1057 sched_getaffinity(0, sizeof(cpu_set), &cpu_set); 1058 D("orig cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]); 1059 CPU_ZERO(&cpu_set); 1060 CPU_SET(cpu_num, &cpu_set); 1061 sched_setaffinity(0, sizeof(cpu_set), &cpu_set); 1062 sched_getaffinity(0, sizeof(cpu_set), &cpu_set); 1063 D("new cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]); 1064} 1065#endif 1066 1067int launch_server(int server_port) 1068{ 1069#ifdef HAVE_WIN32_PROC 1070 /* we need to start the server in the background */ 1071 /* we create a PIPE that will be used to wait for the server's "OK" */ 1072 /* message since the pipe handles must be inheritable, we use a */ 1073 /* security attribute */ 1074 HANDLE pipe_read, pipe_write; 1075 HANDLE stdout_handle, stderr_handle; 1076 SECURITY_ATTRIBUTES sa; 1077 STARTUPINFO startup; 1078 PROCESS_INFORMATION pinfo; 1079 char program_path[ MAX_PATH ]; 1080 int ret; 1081 1082 sa.nLength = sizeof(sa); 1083 sa.lpSecurityDescriptor = NULL; 1084 sa.bInheritHandle = TRUE; 1085 1086 /* create pipe, and ensure its read handle isn't inheritable */ 1087 ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 ); 1088 if (!ret) { 1089 fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() ); 1090 return -1; 1091 } 1092 1093 SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 ); 1094 1095 /* Some programs want to launch an adb command and collect its output by 1096 * calling CreateProcess with inheritable stdout/stderr handles, then 1097 * using read() to get its output. When this happens, the stdout/stderr 1098 * handles passed to the adb client process will also be inheritable. 1099 * When starting the adb server here, care must be taken to reset them 1100 * to non-inheritable. 1101 * Otherwise, something bad happens: even if the adb command completes, 1102 * the calling process is stuck while read()-ing from the stdout/stderr 1103 * descriptors, because they're connected to corresponding handles in the 1104 * adb server process (even if the latter never uses/writes to them). 1105 */ 1106 stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE ); 1107 stderr_handle = GetStdHandle( STD_ERROR_HANDLE ); 1108 if (stdout_handle != INVALID_HANDLE_VALUE) { 1109 SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 ); 1110 } 1111 if (stderr_handle != INVALID_HANDLE_VALUE) { 1112 SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 ); 1113 } 1114 1115 ZeroMemory( &startup, sizeof(startup) ); 1116 startup.cb = sizeof(startup); 1117 startup.hStdInput = GetStdHandle( STD_INPUT_HANDLE ); 1118 startup.hStdOutput = pipe_write; 1119 startup.hStdError = GetStdHandle( STD_ERROR_HANDLE ); 1120 startup.dwFlags = STARTF_USESTDHANDLES; 1121 1122 ZeroMemory( &pinfo, sizeof(pinfo) ); 1123 1124 /* get path of current program */ 1125 GetModuleFileName( NULL, program_path, sizeof(program_path) ); 1126 1127 ret = CreateProcess( 1128 program_path, /* program path */ 1129 "adb fork-server server", 1130 /* the fork-server argument will set the 1131 debug = 2 in the child */ 1132 NULL, /* process handle is not inheritable */ 1133 NULL, /* thread handle is not inheritable */ 1134 TRUE, /* yes, inherit some handles */ 1135 DETACHED_PROCESS, /* the new process doesn't have a console */ 1136 NULL, /* use parent's environment block */ 1137 NULL, /* use parent's starting directory */ 1138 &startup, /* startup info, i.e. std handles */ 1139 &pinfo ); 1140 1141 CloseHandle( pipe_write ); 1142 1143 if (!ret) { 1144 fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() ); 1145 CloseHandle( pipe_read ); 1146 return -1; 1147 } 1148 1149 CloseHandle( pinfo.hProcess ); 1150 CloseHandle( pinfo.hThread ); 1151 1152 /* wait for the "OK\n" message */ 1153 { 1154 char temp[3]; 1155 DWORD count; 1156 1157 ret = ReadFile( pipe_read, temp, 3, &count, NULL ); 1158 CloseHandle( pipe_read ); 1159 if ( !ret ) { 1160 fprintf(stderr, "could not read ok from ADB Server, error = %ld\n", GetLastError() ); 1161 return -1; 1162 } 1163 if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { 1164 fprintf(stderr, "ADB server didn't ACK\n" ); 1165 return -1; 1166 } 1167 } 1168#elif defined(HAVE_FORKEXEC) 1169 char path[PATH_MAX]; 1170 int fd[2]; 1171 1172 // set up a pipe so the child can tell us when it is ready. 1173 // fd[0] will be parent's end, and fd[1] will get mapped to stderr in the child. 1174 if (pipe(fd)) { 1175 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno); 1176 return -1; 1177 } 1178 get_my_path(path, PATH_MAX); 1179 pid_t pid = fork(); 1180 if(pid < 0) return -1; 1181 1182 if (pid == 0) { 1183 // child side of the fork 1184 1185 // redirect stderr to the pipe 1186 // we use stderr instead of stdout due to stdout's buffering behavior. 1187 adb_close(fd[0]); 1188 dup2(fd[1], STDERR_FILENO); 1189 adb_close(fd[1]); 1190 1191 char str_port[30]; 1192 snprintf(str_port, sizeof(str_port), "%d", server_port); 1193 // child process 1194 int result = execl(path, "adb", "-P", str_port, "fork-server", "server", NULL); 1195 // this should not return 1196 fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno); 1197 } else { 1198 // parent side of the fork 1199 1200 char temp[3]; 1201 1202 temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C'; 1203 // wait for the "OK\n" message 1204 adb_close(fd[1]); 1205 int ret = adb_read(fd[0], temp, 3); 1206 int saved_errno = errno; 1207 adb_close(fd[0]); 1208 if (ret < 0) { 1209 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno); 1210 return -1; 1211 } 1212 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { 1213 fprintf(stderr, "ADB server didn't ACK\n" ); 1214 return -1; 1215 } 1216 1217 setsid(); 1218 } 1219#else 1220#error "cannot implement background server start on this platform" 1221#endif 1222 return 0; 1223} 1224#endif 1225 1226/* Constructs a local name of form tcp:port. 1227 * target_str points to the target string, it's content will be overwritten. 1228 * target_size is the capacity of the target string. 1229 * server_port is the port number to use for the local name. 1230 */ 1231void build_local_name(char* target_str, size_t target_size, int server_port) 1232{ 1233 snprintf(target_str, target_size, "tcp:%d", server_port); 1234} 1235 1236#if !ADB_HOST 1237 1238static void drop_capabilities_bounding_set_if_needed() { 1239#ifdef ALLOW_ADBD_ROOT 1240 char value[PROPERTY_VALUE_MAX]; 1241 property_get("ro.debuggable", value, ""); 1242 if (strcmp(value, "1") == 0) { 1243 return; 1244 } 1245#endif 1246 int i; 1247 for (i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) { 1248 if (i == CAP_SETUID || i == CAP_SETGID) { 1249 // CAP_SETUID CAP_SETGID needed by /system/bin/run-as 1250 continue; 1251 } 1252 int err = prctl(PR_CAPBSET_DROP, i, 0, 0, 0); 1253 1254 // Some kernels don't have file capabilities compiled in, and 1255 // prctl(PR_CAPBSET_DROP) returns EINVAL. Don't automatically 1256 // die when we see such misconfigured kernels. 1257 if ((err < 0) && (errno != EINVAL)) { 1258 exit(1); 1259 } 1260 } 1261} 1262 1263static int should_drop_privileges() { 1264#ifndef ALLOW_ADBD_ROOT 1265 return 1; 1266#else /* ALLOW_ADBD_ROOT */ 1267 int secure = 0; 1268 char value[PROPERTY_VALUE_MAX]; 1269 1270 /* run adbd in secure mode if ro.secure is set and 1271 ** we are not in the emulator 1272 */ 1273 property_get("ro.kernel.qemu", value, ""); 1274 if (strcmp(value, "1") != 0) { 1275 property_get("ro.secure", value, "1"); 1276 if (strcmp(value, "1") == 0) { 1277 // don't run as root if ro.secure is set... 1278 secure = 1; 1279 1280 // ... except we allow running as root in userdebug builds if the 1281 // service.adb.root property has been set by the "adb root" command 1282 property_get("ro.debuggable", value, ""); 1283 if (strcmp(value, "1") == 0) { 1284 property_get("service.adb.root", value, ""); 1285 if (strcmp(value, "1") == 0) { 1286 secure = 0; 1287 } 1288 } 1289 } 1290 } 1291 return secure; 1292#endif /* ALLOW_ADBD_ROOT */ 1293} 1294#endif /* !ADB_HOST */ 1295 1296int adb_main(int is_daemon, int server_port) 1297{ 1298#if !ADB_HOST 1299 int port; 1300 char value[PROPERTY_VALUE_MAX]; 1301 1302 umask(000); 1303#endif 1304 1305 atexit(adb_cleanup); 1306#ifdef HAVE_WIN32_PROC 1307 SetConsoleCtrlHandler( ctrlc_handler, TRUE ); 1308#elif defined(HAVE_FORKEXEC) 1309 // No SIGCHLD. Let the service subproc handle its children. 1310 signal(SIGPIPE, SIG_IGN); 1311#endif 1312 1313 init_transport_registration(); 1314 1315#if ADB_HOST 1316 HOST = 1; 1317 1318#ifdef WORKAROUND_BUG6558362 1319 if(is_daemon) adb_set_affinity(); 1320#endif 1321 usb_vendors_init(); 1322 usb_init(); 1323 local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT); 1324 adb_auth_init(); 1325 1326 char local_name[30]; 1327 build_local_name(local_name, sizeof(local_name), server_port); 1328 if(install_listener(local_name, "*smartsocket*", NULL, 0)) { 1329 exit(1); 1330 } 1331#else 1332 property_get("ro.adb.secure", value, "0"); 1333 auth_enabled = !strcmp(value, "1"); 1334 if (auth_enabled) 1335 adb_auth_init(); 1336 1337 // Our external storage path may be different than apps, since 1338 // we aren't able to bind mount after dropping root. 1339 const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE"); 1340 if (NULL != adb_external_storage) { 1341 setenv("EXTERNAL_STORAGE", adb_external_storage, 1); 1342 } else { 1343 D("Warning: ADB_EXTERNAL_STORAGE is not set. Leaving EXTERNAL_STORAGE" 1344 " unchanged.\n"); 1345 } 1346 1347 /* don't listen on a port (default 5037) if running in secure mode */ 1348 /* don't run as root if we are running in secure mode */ 1349 if (should_drop_privileges()) { 1350 drop_capabilities_bounding_set_if_needed(); 1351 1352 /* add extra groups: 1353 ** AID_ADB to access the USB driver 1354 ** AID_LOG to read system logs (adb logcat) 1355 ** AID_INPUT to diagnose input issues (getevent) 1356 ** AID_INET to diagnose network issues (netcfg, ping) 1357 ** AID_GRAPHICS to access the frame buffer 1358 ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump) 1359 ** AID_SDCARD_R to allow reading from the SD card 1360 ** AID_SDCARD_RW to allow writing to the SD card 1361 ** AID_MOUNT to allow unmounting the SD card before rebooting 1362 ** AID_NET_BW_STATS to read out qtaguid statistics 1363 */ 1364 gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS, 1365 AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW, 1366 AID_MOUNT, AID_NET_BW_STATS }; 1367 if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) { 1368 exit(1); 1369 } 1370 1371 /* then switch user and group to "shell" */ 1372 if (setgid(AID_SHELL) != 0) { 1373 exit(1); 1374 } 1375 if (setuid(AID_SHELL) != 0) { 1376 exit(1); 1377 } 1378 1379 D("Local port disabled\n"); 1380 } else { 1381 char local_name[30]; 1382 if ((root_seclabel != NULL) && (is_selinux_enabled() > 0)) { 1383 // b/12587913: fix setcon to allow const pointers 1384 if (setcon((char *)root_seclabel) < 0) { 1385 exit(1); 1386 } 1387 } 1388 build_local_name(local_name, sizeof(local_name), server_port); 1389 if(install_listener(local_name, "*smartsocket*", NULL, 0)) { 1390 exit(1); 1391 } 1392 } 1393 1394 int usb = 0; 1395 if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) { 1396 // listen on USB 1397 usb_init(); 1398 usb = 1; 1399 } 1400 1401 // If one of these properties is set, also listen on that port 1402 // If one of the properties isn't set and we couldn't listen on usb, 1403 // listen on the default port. 1404 property_get("service.adb.tcp.port", value, ""); 1405 if (!value[0]) { 1406 property_get("persist.adb.tcp.port", value, ""); 1407 } 1408 if (sscanf(value, "%d", &port) == 1 && port > 0) { 1409 printf("using port=%d\n", port); 1410 // listen on TCP port specified by service.adb.tcp.port property 1411 local_init(port); 1412 } else if (!usb) { 1413 // listen on default port 1414 local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT); 1415 } 1416 1417 D("adb_main(): pre init_jdwp()\n"); 1418 init_jdwp(); 1419 D("adb_main(): post init_jdwp()\n"); 1420#endif 1421 1422 if (is_daemon) 1423 { 1424 // inform our parent that we are up and running. 1425#ifdef HAVE_WIN32_PROC 1426 DWORD count; 1427 WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL ); 1428#elif defined(HAVE_FORKEXEC) 1429 fprintf(stderr, "OK\n"); 1430#endif 1431 start_logging(); 1432 } 1433 D("Event loop starting\n"); 1434 1435 fdevent_loop(); 1436 1437 usb_cleanup(); 1438 1439 return 0; 1440} 1441 1442// Try to handle a network forwarding request. 1443// This returns 1 on success, 0 on failure, and -1 to indicate this is not 1444// a forwarding-related request. 1445int handle_forward_request(const char* service, transport_type ttype, char* serial, int reply_fd) 1446{ 1447 if (!strcmp(service, "list-forward")) { 1448 // Create the list of forward redirections. 1449 int buffer_size = format_listeners(NULL, 0); 1450 // Add one byte for the trailing zero. 1451 char* buffer = malloc(buffer_size + 1); 1452 if (buffer == NULL) { 1453 sendfailmsg(reply_fd, "not enough memory"); 1454 return 1; 1455 } 1456 (void) format_listeners(buffer, buffer_size + 1); 1457#if ADB_HOST 1458 send_msg_with_okay(reply_fd, buffer, buffer_size); 1459#else 1460 send_msg_with_header(reply_fd, buffer, buffer_size); 1461#endif 1462 free(buffer); 1463 return 1; 1464 } 1465 1466 if (!strcmp(service, "killforward-all")) { 1467 remove_all_listeners(); 1468#if ADB_HOST 1469 /* On the host: 1st OKAY is connect, 2nd OKAY is status */ 1470 adb_write(reply_fd, "OKAY", 4); 1471#endif 1472 adb_write(reply_fd, "OKAY", 4); 1473 return 1; 1474 } 1475 1476 if (!strncmp(service, "forward:",8) || 1477 !strncmp(service, "killforward:",12)) { 1478 char *local, *remote, *err; 1479 int r; 1480 atransport *transport; 1481 1482 int createForward = strncmp(service, "kill", 4); 1483 int no_rebind = 0; 1484 1485 local = strchr(service, ':') + 1; 1486 1487 // Handle forward:norebind:<local>... here 1488 if (createForward && !strncmp(local, "norebind:", 9)) { 1489 no_rebind = 1; 1490 local = strchr(local, ':') + 1; 1491 } 1492 1493 remote = strchr(local,';'); 1494 1495 if (createForward) { 1496 // Check forward: parameter format: '<local>;<remote>' 1497 if(remote == 0) { 1498 sendfailmsg(reply_fd, "malformed forward spec"); 1499 return 1; 1500 } 1501 1502 *remote++ = 0; 1503 if((local[0] == 0) || (remote[0] == 0) || (remote[0] == '*')) { 1504 sendfailmsg(reply_fd, "malformed forward spec"); 1505 return 1; 1506 } 1507 } else { 1508 // Check killforward: parameter format: '<local>' 1509 if (local[0] == 0) { 1510 sendfailmsg(reply_fd, "malformed forward spec"); 1511 return 1; 1512 } 1513 } 1514 1515 transport = acquire_one_transport(CS_ANY, ttype, serial, &err); 1516 if (!transport) { 1517 sendfailmsg(reply_fd, err); 1518 return 1; 1519 } 1520 1521 if (createForward) { 1522 r = install_listener(local, remote, transport, no_rebind); 1523 } else { 1524 r = remove_listener(local, transport); 1525 } 1526 if(r == 0) { 1527#if ADB_HOST 1528 /* On the host: 1st OKAY is connect, 2nd OKAY is status */ 1529 writex(reply_fd, "OKAY", 4); 1530#endif 1531 writex(reply_fd, "OKAY", 4); 1532 return 1; 1533 } 1534 1535 if (createForward) { 1536 const char* message; 1537 switch (r) { 1538 case INSTALL_STATUS_CANNOT_BIND: 1539 message = "cannot bind to socket"; 1540 break; 1541 case INSTALL_STATUS_CANNOT_REBIND: 1542 message = "cannot rebind existing socket"; 1543 break; 1544 default: 1545 message = "internal error"; 1546 } 1547 sendfailmsg(reply_fd, message); 1548 } else { 1549 sendfailmsg(reply_fd, "cannot remove listener"); 1550 } 1551 return 1; 1552 } 1553 return 0; 1554} 1555 1556int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s) 1557{ 1558 atransport *transport = NULL; 1559 1560 if(!strcmp(service, "kill")) { 1561 fprintf(stderr,"adb server killed by remote request\n"); 1562 fflush(stdout); 1563 adb_write(reply_fd, "OKAY", 4); 1564 usb_cleanup(); 1565 exit(0); 1566 } 1567 1568#if ADB_HOST 1569 // "transport:" is used for switching transport with a specified serial number 1570 // "transport-usb:" is used for switching transport to the only USB transport 1571 // "transport-local:" is used for switching transport to the only local transport 1572 // "transport-any:" is used for switching transport to the only transport 1573 if (!strncmp(service, "transport", strlen("transport"))) { 1574 char* error_string = "unknown failure"; 1575 transport_type type = kTransportAny; 1576 1577 if (!strncmp(service, "transport-usb", strlen("transport-usb"))) { 1578 type = kTransportUsb; 1579 } else if (!strncmp(service, "transport-local", strlen("transport-local"))) { 1580 type = kTransportLocal; 1581 } else if (!strncmp(service, "transport-any", strlen("transport-any"))) { 1582 type = kTransportAny; 1583 } else if (!strncmp(service, "transport:", strlen("transport:"))) { 1584 service += strlen("transport:"); 1585 serial = service; 1586 } 1587 1588 transport = acquire_one_transport(CS_ANY, type, serial, &error_string); 1589 1590 if (transport) { 1591 s->transport = transport; 1592 adb_write(reply_fd, "OKAY", 4); 1593 } else { 1594 sendfailmsg(reply_fd, error_string); 1595 } 1596 return 1; 1597 } 1598 1599 // return a list of all connected devices 1600 if (!strncmp(service, "devices", 7)) { 1601 char buffer[4096]; 1602 int use_long = !strcmp(service+7, "-l"); 1603 if (use_long || service[7] == 0) { 1604 memset(buffer, 0, sizeof(buffer)); 1605 D("Getting device list \n"); 1606 list_transports(buffer, sizeof(buffer), use_long); 1607 D("Wrote device list \n"); 1608 send_msg_with_okay(reply_fd, buffer, strlen(buffer)); 1609 return 0; 1610 } 1611 } 1612 1613 // remove TCP transport 1614 if (!strncmp(service, "disconnect:", 11)) { 1615 char buffer[4096]; 1616 memset(buffer, 0, sizeof(buffer)); 1617 char* serial = service + 11; 1618 if (serial[0] == 0) { 1619 // disconnect from all TCP devices 1620 unregister_all_tcp_transports(); 1621 } else { 1622 char hostbuf[100]; 1623 // assume port 5555 if no port is specified 1624 if (!strchr(serial, ':')) { 1625 snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555", serial); 1626 serial = hostbuf; 1627 } 1628 atransport *t = find_transport(serial); 1629 1630 if (t) { 1631 unregister_transport(t); 1632 } else { 1633 snprintf(buffer, sizeof(buffer), "No such device %s", serial); 1634 } 1635 } 1636 1637 send_msg_with_okay(reply_fd, buffer, strlen(buffer)); 1638 return 0; 1639 } 1640 1641 // returns our value for ADB_SERVER_VERSION 1642 if (!strcmp(service, "version")) { 1643 char version[12]; 1644 snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION); 1645 send_msg_with_okay(reply_fd, version, strlen(version)); 1646 return 0; 1647 } 1648 1649 if(!strncmp(service,"get-serialno",strlen("get-serialno"))) { 1650 char *out = "unknown"; 1651 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL); 1652 if (transport && transport->serial) { 1653 out = transport->serial; 1654 } 1655 send_msg_with_okay(reply_fd, out, strlen(out)); 1656 return 0; 1657 } 1658 if(!strncmp(service,"get-devpath",strlen("get-devpath"))) { 1659 char *out = "unknown"; 1660 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL); 1661 if (transport && transport->devpath) { 1662 out = transport->devpath; 1663 } 1664 send_msg_with_okay(reply_fd, out, strlen(out)); 1665 return 0; 1666 } 1667 // indicates a new emulator instance has started 1668 if (!strncmp(service,"emulator:",9)) { 1669 int port = atoi(service+9); 1670 local_connect(port); 1671 /* we don't even need to send a reply */ 1672 return 0; 1673 } 1674#endif // ADB_HOST 1675 1676 int ret = handle_forward_request(service, ttype, serial, reply_fd); 1677 if (ret >= 0) 1678 return ret - 1; 1679 1680 if(!strncmp(service,"get-state",strlen("get-state"))) { 1681 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL); 1682 char *state = connection_state_name(transport); 1683 send_msg_with_okay(reply_fd, state, strlen(state)); 1684 return 0; 1685 } 1686 return -1; 1687} 1688 1689int main(int argc, char **argv) 1690{ 1691#if ADB_HOST 1692 adb_sysdeps_init(); 1693 adb_trace_init(); 1694 D("Handling commandline()\n"); 1695 return adb_commandline(argc - 1, argv + 1); 1696#else 1697 /* If adbd runs inside the emulator this will enable adb tracing via 1698 * adb-debug qemud service in the emulator. */ 1699 adb_qemu_trace_init(); 1700 while(1) { 1701 int c; 1702 int option_index = 0; 1703 static struct option opts[] = { 1704 {"root_seclabel", required_argument, 0, 's' }, 1705 {"device_banner", required_argument, 0, 'b' } 1706 }; 1707 c = getopt_long(argc, argv, "", opts, &option_index); 1708 if (c == -1) 1709 break; 1710 switch (c) { 1711 case 's': 1712 root_seclabel = optarg; 1713 break; 1714 case 'b': 1715 adb_device_banner = optarg; 1716 break; 1717 default: 1718 break; 1719 } 1720 } 1721 1722 start_device_log(); 1723 D("Handling main()\n"); 1724 return adb_main(0, DEFAULT_ADB_PORT); 1725#endif 1726} 1727