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 <string.h> 20 #include <errno.h> 21 #include <unistd.h> 22 #include <limits.h> 23 #include <stdarg.h> 24 #include <sys/types.h> 25 #include <sys/stat.h> 26 #include <ctype.h> 27 #include <assert.h> 28 29 #include "sysdeps.h" 30 31 #ifdef HAVE_TERMIO_H 32 #include <termios.h> 33 #endif 34 35 #define TRACE_TAG TRACE_ADB 36 #include "adb.h" 37 #include "adb_client.h" 38 #include "file_sync_service.h" 39 40 enum { 41 IGNORE_DATA, 42 WIPE_DATA, 43 FLASH_DATA 44 }; 45 46 static int do_cmd(transport_type ttype, char* serial, char *cmd, ...); 47 48 void get_my_path(char *s, size_t maxLen); 49 int find_sync_dirs(const char *srcarg, 50 char **android_srcdir_out, char **data_srcdir_out); 51 int install_app(transport_type transport, char* serial, int argc, char** argv); 52 int uninstall_app(transport_type transport, char* serial, int argc, char** argv); 53 54 static const char *gProductOutPath = NULL; 55 56 static char *product_file(const char *extra) 57 { 58 int n; 59 char *x; 60 61 if (gProductOutPath == NULL) { 62 fprintf(stderr, "adb: Product directory not specified; " 63 "use -p or define ANDROID_PRODUCT_OUT\n"); 64 exit(1); 65 } 66 67 n = strlen(gProductOutPath) + strlen(extra) + 2; 68 x = malloc(n); 69 if (x == 0) { 70 fprintf(stderr, "adb: Out of memory (product_file())\n"); 71 exit(1); 72 } 73 74 snprintf(x, (size_t)n, "%s" OS_PATH_SEPARATOR_STR "%s", gProductOutPath, extra); 75 return x; 76 } 77 78 void version(FILE * out) { 79 fprintf(out, "Android Debug Bridge version %d.%d.%d\n", 80 ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION); 81 } 82 83 void help() 84 { 85 version(stderr); 86 87 fprintf(stderr, 88 "\n" 89 " -d - directs command to the only connected USB device\n" 90 " returns an error if more than one USB device is present.\n" 91 " -e - directs command to the only running emulator.\n" 92 " returns an error if more than one emulator is running.\n" 93 " -s <serial number> - directs command to the USB device or emulator with\n" 94 " the given serial number. Overrides ANDROID_SERIAL\n" 95 " environment variable.\n" 96 " -p <product name or path> - simple product name like 'sooner', or\n" 97 " a relative/absolute path to a product\n" 98 " out directory like 'out/target/product/sooner'.\n" 99 " If -p is not specified, the ANDROID_PRODUCT_OUT\n" 100 " environment variable is used, which must\n" 101 " be an absolute path.\n" 102 " devices - list all connected devices\n" 103 " connect <host>[:<port>] - connect to a device via TCP/IP\n" 104 " Port 5555 is used by default if no port number is specified.\n" 105 " disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.\n" 106 " Port 5555 is used by default if no port number is specified.\n" 107 " Using this ocmmand with no additional arguments\n" 108 " will disconnect from all connected TCP/IP devices.\n" 109 "\n" 110 "device commands:\n" 111 " adb push <local> <remote> - copy file/dir to device\n" 112 " adb pull <remote> [<local>] - copy file/dir from device\n" 113 " adb sync [ <directory> ] - copy host->device only if changed\n" 114 " (-l means list but don't copy)\n" 115 " (see 'adb help all')\n" 116 " adb shell - run remote shell interactively\n" 117 " adb shell <command> - run remote shell command\n" 118 " adb emu <command> - run emulator console command\n" 119 " adb logcat [ <filter-spec> ] - View device log\n" 120 " adb forward <local> <remote> - forward socket connections\n" 121 " forward specs are one of: \n" 122 " tcp:<port>\n" 123 " localabstract:<unix domain socket name>\n" 124 " localreserved:<unix domain socket name>\n" 125 " localfilesystem:<unix domain socket name>\n" 126 " dev:<character device name>\n" 127 " jdwp:<process pid> (remote only)\n" 128 " adb jdwp - list PIDs of processes hosting a JDWP transport\n" 129 " adb install [-l] [-r] [-s] <file> - push this package file to the device and install it\n" 130 " ('-l' means forward-lock the app)\n" 131 " ('-r' means reinstall the app, keeping its data)\n" 132 " ('-s' means install on SD card instead of internal storage)\n" 133 " adb uninstall [-k] <package> - remove this app package from the device\n" 134 " ('-k' means keep the data and cache directories)\n" 135 " adb bugreport - return all information from the device\n" 136 " that should be included in a bug report.\n" 137 "\n" 138 " adb help - show this help message\n" 139 " adb version - show version num\n" 140 "\n" 141 "DATAOPTS:\n" 142 " (no option) - don't touch the data partition\n" 143 " -w - wipe the data partition\n" 144 " -d - flash the data partition\n" 145 "\n" 146 "scripting:\n" 147 " adb wait-for-device - block until device is online\n" 148 " adb start-server - ensure that there is a server running\n" 149 " adb kill-server - kill the server if it is running\n" 150 " adb get-state - prints: offline | bootloader | device\n" 151 " adb get-serialno - prints: <serial-number>\n" 152 " adb status-window - continuously print device status for a specified device\n" 153 " adb remount - remounts the /system partition on the device read-write\n" 154 " adb reboot [bootloader|recovery] - reboots the device, optionally into the bootloader or recovery program\n" 155 " adb reboot-bootloader - reboots the device into the bootloader\n" 156 " adb root - restarts the adbd daemon with root permissions\n" 157 " adb usb - restarts the adbd daemon listening on USB\n" 158 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port" 159 "\n" 160 "networking:\n" 161 " adb ppp <tty> [parameters] - Run PPP over USB.\n" 162 " Note: you should not automatically start a PPP connection.\n" 163 " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n" 164 " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n" 165 "\n" 166 "adb sync notes: adb sync [ <directory> ]\n" 167 " <localdir> can be interpreted in several ways:\n" 168 "\n" 169 " - If <directory> is not specified, both /system and /data partitions will be updated.\n" 170 "\n" 171 " - If it is \"system\" or \"data\", only the corresponding partition\n" 172 " is updated.\n" 173 "\n" 174 "environmental variables:\n" 175 " ADB_TRACE - Print debug information. A comma separated list of the following values\n" 176 " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n" 177 " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n" 178 " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n" 179 ); 180 } 181 182 int usage() 183 { 184 help(); 185 return 1; 186 } 187 188 #ifdef HAVE_TERMIO_H 189 static struct termios tio_save; 190 191 static void stdin_raw_init(int fd) 192 { 193 struct termios tio; 194 195 if(tcgetattr(fd, &tio)) return; 196 if(tcgetattr(fd, &tio_save)) return; 197 198 tio.c_lflag = 0; /* disable CANON, ECHO*, etc */ 199 200 /* no timeout but request at least one character per read */ 201 tio.c_cc[VTIME] = 0; 202 tio.c_cc[VMIN] = 1; 203 204 tcsetattr(fd, TCSANOW, &tio); 205 tcflush(fd, TCIFLUSH); 206 } 207 208 static void stdin_raw_restore(int fd) 209 { 210 tcsetattr(fd, TCSANOW, &tio_save); 211 tcflush(fd, TCIFLUSH); 212 } 213 #endif 214 215 static void read_and_dump(int fd) 216 { 217 char buf[4096]; 218 int len; 219 220 while(fd >= 0) { 221 len = adb_read(fd, buf, 4096); 222 if(len == 0) { 223 break; 224 } 225 226 if(len < 0) { 227 if(errno == EINTR) continue; 228 break; 229 } 230 fwrite(buf, 1, len, stdout); 231 fflush(stdout); 232 } 233 } 234 235 static void *stdin_read_thread(void *x) 236 { 237 int fd, fdi; 238 unsigned char buf[1024]; 239 int r, n; 240 int state = 0; 241 242 int *fds = (int*) x; 243 fd = fds[0]; 244 fdi = fds[1]; 245 free(fds); 246 247 for(;;) { 248 /* fdi is really the client's stdin, so use read, not adb_read here */ 249 r = unix_read(fdi, buf, 1024); 250 if(r == 0) break; 251 if(r < 0) { 252 if(errno == EINTR) continue; 253 break; 254 } 255 for(n = 0; n < r; n++){ 256 switch(buf[n]) { 257 case '\n': 258 state = 1; 259 break; 260 case '\r': 261 state = 1; 262 break; 263 case '~': 264 if(state == 1) state++; 265 break; 266 case '.': 267 if(state == 2) { 268 fprintf(stderr,"\n* disconnect *\n"); 269 #ifdef HAVE_TERMIO_H 270 stdin_raw_restore(fdi); 271 #endif 272 exit(0); 273 } 274 default: 275 state = 0; 276 } 277 } 278 r = adb_write(fd, buf, r); 279 if(r <= 0) { 280 break; 281 } 282 } 283 return 0; 284 } 285 286 int interactive_shell(void) 287 { 288 adb_thread_t thr; 289 int fdi, fd; 290 int *fds; 291 292 fd = adb_connect("shell:"); 293 if(fd < 0) { 294 fprintf(stderr,"error: %s\n", adb_error()); 295 return 1; 296 } 297 fdi = 0; //dup(0); 298 299 fds = malloc(sizeof(int) * 2); 300 fds[0] = fd; 301 fds[1] = fdi; 302 303 #ifdef HAVE_TERMIO_H 304 stdin_raw_init(fdi); 305 #endif 306 adb_thread_create(&thr, stdin_read_thread, fds); 307 read_and_dump(fd); 308 #ifdef HAVE_TERMIO_H 309 stdin_raw_restore(fdi); 310 #endif 311 return 0; 312 } 313 314 315 static void format_host_command(char* buffer, size_t buflen, const char* command, transport_type ttype, const char* serial) 316 { 317 if (serial) { 318 snprintf(buffer, buflen, "host-serial:%s:%s", serial, command); 319 } else { 320 const char* prefix = "host"; 321 if (ttype == kTransportUsb) 322 prefix = "host-usb"; 323 else if (ttype == kTransportLocal) 324 prefix = "host-local"; 325 326 snprintf(buffer, buflen, "%s:%s", prefix, command); 327 } 328 } 329 330 static void status_window(transport_type ttype, const char* serial) 331 { 332 char command[4096]; 333 char *state = 0; 334 char *laststate = 0; 335 336 /* silence stderr */ 337 #ifdef _WIN32 338 /* XXX: TODO */ 339 #else 340 int fd; 341 fd = unix_open("/dev/null", O_WRONLY); 342 dup2(fd, 2); 343 adb_close(fd); 344 #endif 345 346 format_host_command(command, sizeof command, "get-state", ttype, serial); 347 348 for(;;) { 349 adb_sleep_ms(250); 350 351 if(state) { 352 free(state); 353 state = 0; 354 } 355 356 state = adb_query(command); 357 358 if(state) { 359 if(laststate && !strcmp(state,laststate)){ 360 continue; 361 } else { 362 if(laststate) free(laststate); 363 laststate = strdup(state); 364 } 365 } 366 367 printf("%c[2J%c[2H", 27, 27); 368 printf("Android Debug Bridge\n"); 369 printf("State: %s\n", state ? state : "offline"); 370 fflush(stdout); 371 } 372 } 373 374 /** duplicate string and quote all \ " ( ) chars + space character. */ 375 static char * 376 dupAndQuote(const char *s) 377 { 378 const char *ts; 379 size_t alloc_len; 380 char *ret; 381 char *dest; 382 383 ts = s; 384 385 alloc_len = 0; 386 387 for( ;*ts != '\0'; ts++) { 388 alloc_len++; 389 if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') { 390 alloc_len++; 391 } 392 } 393 394 ret = (char *)malloc(alloc_len + 1); 395 396 ts = s; 397 dest = ret; 398 399 for ( ;*ts != '\0'; ts++) { 400 if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') { 401 *dest++ = '\\'; 402 } 403 404 *dest++ = *ts; 405 } 406 407 *dest++ = '\0'; 408 409 return ret; 410 } 411 412 /** 413 * Run ppp in "notty" mode against a resource listed as the first parameter 414 * eg: 415 * 416 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 417 * 418 */ 419 int ppp(int argc, char **argv) 420 { 421 #ifdef HAVE_WIN32_PROC 422 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 423 return -1; 424 #else 425 char *adb_service_name; 426 pid_t pid; 427 int fd; 428 429 if (argc < 2) { 430 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 431 argv[0]); 432 433 return 1; 434 } 435 436 adb_service_name = argv[1]; 437 438 fd = adb_connect(adb_service_name); 439 440 if(fd < 0) { 441 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 442 adb_service_name, adb_error()); 443 return 1; 444 } 445 446 pid = fork(); 447 448 if (pid < 0) { 449 perror("from fork()"); 450 return 1; 451 } else if (pid == 0) { 452 int err; 453 int i; 454 const char **ppp_args; 455 456 // copy args 457 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 458 ppp_args[0] = "pppd"; 459 for (i = 2 ; i < argc ; i++) { 460 //argv[2] and beyond become ppp_args[1] and beyond 461 ppp_args[i - 1] = argv[i]; 462 } 463 ppp_args[i-1] = NULL; 464 465 // child side 466 467 dup2(fd, STDIN_FILENO); 468 dup2(fd, STDOUT_FILENO); 469 adb_close(STDERR_FILENO); 470 adb_close(fd); 471 472 err = execvp("pppd", (char * const *)ppp_args); 473 474 if (err < 0) { 475 perror("execing pppd"); 476 } 477 exit(-1); 478 } else { 479 // parent side 480 481 adb_close(fd); 482 return 0; 483 } 484 #endif /* !HAVE_WIN32_PROC */ 485 } 486 487 static int send_shellcommand(transport_type transport, char* serial, char* buf) 488 { 489 int fd, ret; 490 491 for(;;) { 492 fd = adb_connect(buf); 493 if(fd >= 0) 494 break; 495 fprintf(stderr,"- waiting for device -\n"); 496 adb_sleep_ms(1000); 497 do_cmd(transport, serial, "wait-for-device", 0); 498 } 499 500 read_and_dump(fd); 501 ret = adb_close(fd); 502 if (ret) 503 perror("close"); 504 505 return ret; 506 } 507 508 static int logcat(transport_type transport, char* serial, int argc, char **argv) 509 { 510 char buf[4096]; 511 512 char *log_tags; 513 char *quoted_log_tags; 514 515 log_tags = getenv("ANDROID_LOG_TAGS"); 516 quoted_log_tags = dupAndQuote(log_tags == NULL ? "" : log_tags); 517 518 snprintf(buf, sizeof(buf), 519 "shell:export ANDROID_LOG_TAGS=\"\%s\" ; exec logcat", 520 quoted_log_tags); 521 522 free(quoted_log_tags); 523 524 argc -= 1; 525 argv += 1; 526 while(argc-- > 0) { 527 char *quoted; 528 529 quoted = dupAndQuote (*argv++); 530 531 strncat(buf, " ", sizeof(buf)-1); 532 strncat(buf, quoted, sizeof(buf)-1); 533 free(quoted); 534 } 535 536 send_shellcommand(transport, serial, buf); 537 return 0; 538 } 539 540 #define SENTINEL_FILE "config" OS_PATH_SEPARATOR_STR "envsetup.make" 541 static int top_works(const char *top) 542 { 543 if (top != NULL && adb_is_absolute_host_path(top)) { 544 char path_buf[PATH_MAX]; 545 snprintf(path_buf, sizeof(path_buf), 546 "%s" OS_PATH_SEPARATOR_STR SENTINEL_FILE, top); 547 return access(path_buf, F_OK) == 0; 548 } 549 return 0; 550 } 551 552 static char *find_top_from(const char *indir, char path_buf[PATH_MAX]) 553 { 554 strcpy(path_buf, indir); 555 while (1) { 556 if (top_works(path_buf)) { 557 return path_buf; 558 } 559 char *s = adb_dirstop(path_buf); 560 if (s != NULL) { 561 *s = '\0'; 562 } else { 563 path_buf[0] = '\0'; 564 return NULL; 565 } 566 } 567 } 568 569 static char *find_top(char path_buf[PATH_MAX]) 570 { 571 char *top = getenv("ANDROID_BUILD_TOP"); 572 if (top != NULL && top[0] != '\0') { 573 if (!top_works(top)) { 574 fprintf(stderr, "adb: bad ANDROID_BUILD_TOP value \"%s\"\n", top); 575 return NULL; 576 } 577 } else { 578 top = getenv("TOP"); 579 if (top != NULL && top[0] != '\0') { 580 if (!top_works(top)) { 581 fprintf(stderr, "adb: bad TOP value \"%s\"\n", top); 582 return NULL; 583 } 584 } else { 585 top = NULL; 586 } 587 } 588 589 if (top != NULL) { 590 /* The environment pointed to a top directory that works. 591 */ 592 strcpy(path_buf, top); 593 return path_buf; 594 } 595 596 /* The environment didn't help. Walk up the tree from the CWD 597 * to see if we can find the top. 598 */ 599 char dir[PATH_MAX]; 600 top = find_top_from(getcwd(dir, sizeof(dir)), path_buf); 601 if (top == NULL) { 602 /* If the CWD isn't under a good-looking top, see if the 603 * executable is. 604 */ 605 get_my_path(dir, PATH_MAX); 606 top = find_top_from(dir, path_buf); 607 } 608 return top; 609 } 610 611 /* <hint> may be: 612 * - A simple product name 613 * e.g., "sooner" 614 TODO: debug? sooner-debug, sooner:debug? 615 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 616 * e.g., "out/target/product/sooner" 617 * - An absolute path to the PRODUCT_OUT dir 618 * e.g., "/src/device/out/target/product/sooner" 619 * 620 * Given <hint>, try to construct an absolute path to the 621 * ANDROID_PRODUCT_OUT dir. 622 */ 623 static const char *find_product_out_path(const char *hint) 624 { 625 static char path_buf[PATH_MAX]; 626 627 if (hint == NULL || hint[0] == '\0') { 628 return NULL; 629 } 630 631 /* If it's already absolute, don't bother doing any work. 632 */ 633 if (adb_is_absolute_host_path(hint)) { 634 strcpy(path_buf, hint); 635 return path_buf; 636 } 637 638 /* If there are any slashes in it, assume it's a relative path; 639 * make it absolute. 640 */ 641 if (adb_dirstart(hint) != NULL) { 642 if (getcwd(path_buf, sizeof(path_buf)) == NULL) { 643 fprintf(stderr, "adb: Couldn't get CWD: %s\n", strerror(errno)); 644 return NULL; 645 } 646 if (strlen(path_buf) + 1 + strlen(hint) >= sizeof(path_buf)) { 647 fprintf(stderr, "adb: Couldn't assemble path\n"); 648 return NULL; 649 } 650 strcat(path_buf, OS_PATH_SEPARATOR_STR); 651 strcat(path_buf, hint); 652 return path_buf; 653 } 654 655 /* It's a string without any slashes. Try to do something with it. 656 * 657 * Try to find the root of the build tree, and build a PRODUCT_OUT 658 * path from there. 659 */ 660 char top_buf[PATH_MAX]; 661 const char *top = find_top(top_buf); 662 if (top == NULL) { 663 fprintf(stderr, "adb: Couldn't find top of build tree\n"); 664 return NULL; 665 } 666 //TODO: if we have a way to indicate debug, look in out/debug/target/... 667 snprintf(path_buf, sizeof(path_buf), 668 "%s" OS_PATH_SEPARATOR_STR 669 "out" OS_PATH_SEPARATOR_STR 670 "target" OS_PATH_SEPARATOR_STR 671 "product" OS_PATH_SEPARATOR_STR 672 "%s", top_buf, hint); 673 if (access(path_buf, F_OK) < 0) { 674 fprintf(stderr, "adb: Couldn't find a product dir " 675 "based on \"-p %s\"; \"%s\" doesn't exist\n", hint, path_buf); 676 return NULL; 677 } 678 return path_buf; 679 } 680 681 int adb_commandline(int argc, char **argv) 682 { 683 char buf[4096]; 684 int no_daemon = 0; 685 int is_daemon = 0; 686 int persist = 0; 687 int r; 688 int quote; 689 transport_type ttype = kTransportAny; 690 char* serial = NULL; 691 char* server_port_str = NULL; 692 693 /* If defined, this should be an absolute path to 694 * the directory containing all of the various system images 695 * for a particular product. If not defined, and the adb 696 * command requires this information, then the user must 697 * specify the path using "-p". 698 */ 699 gProductOutPath = getenv("ANDROID_PRODUCT_OUT"); 700 if (gProductOutPath == NULL || gProductOutPath[0] == '\0') { 701 gProductOutPath = NULL; 702 } 703 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 704 705 serial = getenv("ANDROID_SERIAL"); 706 707 /* Validate and assign the server port */ 708 server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 709 int server_port = DEFAULT_ADB_PORT; 710 if (server_port_str && strlen(server_port_str) > 0) { 711 server_port = (int) strtol(server_port_str, NULL, 0); 712 if (server_port <= 0) { 713 fprintf(stderr, 714 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number. Got \"%s\"\n", 715 server_port_str); 716 return usage(); 717 } 718 } 719 720 /* modifiers and flags */ 721 while(argc > 0) { 722 if(!strcmp(argv[0],"nodaemon")) { 723 no_daemon = 1; 724 } else if (!strcmp(argv[0], "fork-server")) { 725 /* this is a special flag used only when the ADB client launches the ADB Server */ 726 is_daemon = 1; 727 } else if(!strcmp(argv[0],"persist")) { 728 persist = 1; 729 } else if(!strncmp(argv[0], "-p", 2)) { 730 const char *product = NULL; 731 if (argv[0][2] == '\0') { 732 if (argc < 2) return usage(); 733 product = argv[1]; 734 argc--; 735 argv++; 736 } else { 737 product = argv[1] + 2; 738 } 739 gProductOutPath = find_product_out_path(product); 740 if (gProductOutPath == NULL) { 741 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", 742 product); 743 return usage(); 744 } 745 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 746 if (isdigit(argv[0][2])) { 747 serial = argv[0] + 2; 748 } else { 749 if(argc < 2 || argv[0][2] != '\0') return usage(); 750 serial = argv[1]; 751 argc--; 752 argv++; 753 } 754 } else if (!strcmp(argv[0],"-d")) { 755 ttype = kTransportUsb; 756 } else if (!strcmp(argv[0],"-e")) { 757 ttype = kTransportLocal; 758 } else { 759 /* out of recognized modifiers and flags */ 760 break; 761 } 762 argc--; 763 argv++; 764 } 765 766 adb_set_transport(ttype, serial); 767 adb_set_tcp_specifics(server_port); 768 769 if ((argc > 0) && (!strcmp(argv[0],"server"))) { 770 if (no_daemon || is_daemon) { 771 r = adb_main(is_daemon, server_port); 772 } else { 773 r = launch_server(server_port); 774 } 775 if(r) { 776 fprintf(stderr,"* could not start server *\n"); 777 } 778 return r; 779 } 780 781 top: 782 if(argc == 0) { 783 return usage(); 784 } 785 786 /* adb_connect() commands */ 787 788 if(!strcmp(argv[0], "devices")) { 789 char *tmp; 790 snprintf(buf, sizeof buf, "host:%s", argv[0]); 791 tmp = adb_query(buf); 792 if(tmp) { 793 printf("List of devices attached \n"); 794 printf("%s\n", tmp); 795 return 0; 796 } else { 797 return 1; 798 } 799 } 800 801 if(!strcmp(argv[0], "connect")) { 802 char *tmp; 803 if (argc != 2) { 804 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 805 return 1; 806 } 807 snprintf(buf, sizeof buf, "host:connect:%s", argv[1]); 808 tmp = adb_query(buf); 809 if(tmp) { 810 printf("%s\n", tmp); 811 return 0; 812 } else { 813 return 1; 814 } 815 } 816 817 if(!strcmp(argv[0], "disconnect")) { 818 char *tmp; 819 if (argc > 2) { 820 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 821 return 1; 822 } 823 if (argc == 2) { 824 snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]); 825 } else { 826 snprintf(buf, sizeof buf, "host:disconnect:"); 827 } 828 tmp = adb_query(buf); 829 if(tmp) { 830 printf("%s\n", tmp); 831 return 0; 832 } else { 833 return 1; 834 } 835 } 836 837 if (!strcmp(argv[0], "emu")) { 838 return adb_send_emulator_command(argc, argv); 839 } 840 841 if(!strcmp(argv[0], "shell")) { 842 int r; 843 int fd; 844 845 if(argc < 2) { 846 return interactive_shell(); 847 } 848 849 snprintf(buf, sizeof buf, "shell:%s", argv[1]); 850 argc -= 2; 851 argv += 2; 852 while(argc-- > 0) { 853 strcat(buf, " "); 854 855 /* quote empty strings and strings with spaces */ 856 quote = (**argv == 0 || strchr(*argv, ' ')); 857 if (quote) 858 strcat(buf, "\""); 859 strcat(buf, *argv++); 860 if (quote) 861 strcat(buf, "\""); 862 } 863 864 for(;;) { 865 fd = adb_connect(buf); 866 if(fd >= 0) { 867 read_and_dump(fd); 868 adb_close(fd); 869 r = 0; 870 } else { 871 fprintf(stderr,"error: %s\n", adb_error()); 872 r = -1; 873 } 874 875 if(persist) { 876 fprintf(stderr,"\n- waiting for device -\n"); 877 adb_sleep_ms(1000); 878 do_cmd(ttype, serial, "wait-for-device", 0); 879 } else { 880 return r; 881 } 882 } 883 } 884 885 if(!strcmp(argv[0], "kill-server")) { 886 int fd; 887 fd = _adb_connect("host:kill"); 888 if(fd == -1) { 889 fprintf(stderr,"* server not running *\n"); 890 return 1; 891 } 892 return 0; 893 } 894 895 if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot") 896 || !strcmp(argv[0], "reboot-bootloader") 897 || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb") 898 || !strcmp(argv[0], "root")) { 899 char command[100]; 900 if (!strcmp(argv[0], "reboot-bootloader")) 901 snprintf(command, sizeof(command), "reboot:bootloader"); 902 else if (argc > 1) 903 snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]); 904 else 905 snprintf(command, sizeof(command), "%s:", argv[0]); 906 int fd = adb_connect(command); 907 if(fd >= 0) { 908 read_and_dump(fd); 909 adb_close(fd); 910 return 0; 911 } 912 fprintf(stderr,"error: %s\n", adb_error()); 913 return 1; 914 } 915 916 if(!strcmp(argv[0], "bugreport")) { 917 if (argc != 1) return usage(); 918 do_cmd(ttype, serial, "shell", "bugreport", 0); 919 return 0; 920 } 921 922 /* adb_command() wrapper commands */ 923 924 if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 925 char* service = argv[0]; 926 if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) { 927 if (ttype == kTransportUsb) { 928 service = "wait-for-usb"; 929 } else if (ttype == kTransportLocal) { 930 service = "wait-for-local"; 931 } else { 932 service = "wait-for-any"; 933 } 934 } 935 936 format_host_command(buf, sizeof buf, service, ttype, serial); 937 938 if (adb_command(buf)) { 939 D("failure: %s *\n",adb_error()); 940 fprintf(stderr,"error: %s\n", adb_error()); 941 return 1; 942 } 943 944 /* Allow a command to be run after wait-for-device, 945 * e.g. 'adb wait-for-device shell'. 946 */ 947 if(argc > 1) { 948 argc--; 949 argv++; 950 goto top; 951 } 952 return 0; 953 } 954 955 if(!strcmp(argv[0], "forward")) { 956 if(argc != 3) return usage(); 957 if (serial) { 958 snprintf(buf, sizeof buf, "host-serial:%s:forward:%s;%s",serial, argv[1], argv[2]); 959 } else if (ttype == kTransportUsb) { 960 snprintf(buf, sizeof buf, "host-usb:forward:%s;%s", argv[1], argv[2]); 961 } else if (ttype == kTransportLocal) { 962 snprintf(buf, sizeof buf, "host-local:forward:%s;%s", argv[1], argv[2]); 963 } else { 964 snprintf(buf, sizeof buf, "host:forward:%s;%s", argv[1], argv[2]); 965 } 966 if(adb_command(buf)) { 967 fprintf(stderr,"error: %s\n", adb_error()); 968 return 1; 969 } 970 return 0; 971 } 972 973 /* do_sync_*() commands */ 974 975 if(!strcmp(argv[0], "ls")) { 976 if(argc != 2) return usage(); 977 return do_sync_ls(argv[1]); 978 } 979 980 if(!strcmp(argv[0], "push")) { 981 if(argc != 3) return usage(); 982 return do_sync_push(argv[1], argv[2], 0 /* no verify APK */); 983 } 984 985 if(!strcmp(argv[0], "pull")) { 986 if (argc == 2) { 987 return do_sync_pull(argv[1], "."); 988 } else if (argc == 3) { 989 return do_sync_pull(argv[1], argv[2]); 990 } else { 991 return usage(); 992 } 993 } 994 995 if(!strcmp(argv[0], "install")) { 996 if (argc < 2) return usage(); 997 return install_app(ttype, serial, argc, argv); 998 } 999 1000 if(!strcmp(argv[0], "uninstall")) { 1001 if (argc < 2) return usage(); 1002 return uninstall_app(ttype, serial, argc, argv); 1003 } 1004 1005 if(!strcmp(argv[0], "sync")) { 1006 char *srcarg, *android_srcpath, *data_srcpath; 1007 int listonly = 0; 1008 1009 int ret; 1010 if(argc < 2) { 1011 /* No local path was specified. */ 1012 srcarg = NULL; 1013 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1014 listonly = 1; 1015 if (argc == 3) { 1016 srcarg = argv[2]; 1017 } else { 1018 srcarg = NULL; 1019 } 1020 } else if(argc == 2) { 1021 /* A local path or "android"/"data" arg was specified. */ 1022 srcarg = argv[1]; 1023 } else { 1024 return usage(); 1025 } 1026 ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath); 1027 if(ret != 0) return usage(); 1028 1029 if(android_srcpath != NULL) 1030 ret = do_sync_sync(android_srcpath, "/system", listonly); 1031 if(ret == 0 && data_srcpath != NULL) 1032 ret = do_sync_sync(data_srcpath, "/data", listonly); 1033 1034 free(android_srcpath); 1035 free(data_srcpath); 1036 return ret; 1037 } 1038 1039 /* passthrough commands */ 1040 1041 if(!strcmp(argv[0],"get-state") || 1042 !strcmp(argv[0],"get-serialno")) 1043 { 1044 char *tmp; 1045 1046 format_host_command(buf, sizeof buf, argv[0], ttype, serial); 1047 tmp = adb_query(buf); 1048 if(tmp) { 1049 printf("%s\n", tmp); 1050 return 0; 1051 } else { 1052 return 1; 1053 } 1054 } 1055 1056 /* other commands */ 1057 1058 if(!strcmp(argv[0],"status-window")) { 1059 status_window(ttype, serial); 1060 return 0; 1061 } 1062 1063 if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat")) { 1064 return logcat(ttype, serial, argc, argv); 1065 } 1066 1067 if(!strcmp(argv[0],"ppp")) { 1068 return ppp(argc, argv); 1069 } 1070 1071 if (!strcmp(argv[0], "start-server")) { 1072 return adb_connect("host:start-server"); 1073 } 1074 1075 if (!strcmp(argv[0], "jdwp")) { 1076 int fd = adb_connect("jdwp"); 1077 if (fd >= 0) { 1078 read_and_dump(fd); 1079 adb_close(fd); 1080 return 0; 1081 } else { 1082 fprintf(stderr, "error: %s\n", adb_error()); 1083 return -1; 1084 } 1085 } 1086 1087 /* "adb /?" is a common idiom under Windows */ 1088 if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1089 help(); 1090 return 0; 1091 } 1092 1093 if(!strcmp(argv[0], "version")) { 1094 version(stdout); 1095 return 0; 1096 } 1097 1098 usage(); 1099 return 1; 1100 } 1101 1102 static int do_cmd(transport_type ttype, char* serial, char *cmd, ...) 1103 { 1104 char *argv[16]; 1105 int argc; 1106 va_list ap; 1107 1108 va_start(ap, cmd); 1109 argc = 0; 1110 1111 if (serial) { 1112 argv[argc++] = "-s"; 1113 argv[argc++] = serial; 1114 } else if (ttype == kTransportUsb) { 1115 argv[argc++] = "-d"; 1116 } else if (ttype == kTransportLocal) { 1117 argv[argc++] = "-e"; 1118 } 1119 1120 argv[argc++] = cmd; 1121 while((argv[argc] = va_arg(ap, char*)) != 0) argc++; 1122 va_end(ap); 1123 1124 #if 0 1125 int n; 1126 fprintf(stderr,"argc = %d\n",argc); 1127 for(n = 0; n < argc; n++) { 1128 fprintf(stderr,"argv[%d] = \"%s\"\n", n, argv[n]); 1129 } 1130 #endif 1131 1132 return adb_commandline(argc, argv); 1133 } 1134 1135 int find_sync_dirs(const char *srcarg, 1136 char **android_srcdir_out, char **data_srcdir_out) 1137 { 1138 char *android_srcdir, *data_srcdir; 1139 1140 if(srcarg == NULL) { 1141 android_srcdir = product_file("system"); 1142 data_srcdir = product_file("data"); 1143 } else { 1144 /* srcarg may be "data", "system" or NULL. 1145 * if srcarg is NULL, then both data and system are synced 1146 */ 1147 if(strcmp(srcarg, "system") == 0) { 1148 android_srcdir = product_file("system"); 1149 data_srcdir = NULL; 1150 } else if(strcmp(srcarg, "data") == 0) { 1151 android_srcdir = NULL; 1152 data_srcdir = product_file("data"); 1153 } else { 1154 /* It's not "system" or "data". 1155 */ 1156 return 1; 1157 } 1158 } 1159 1160 if(android_srcdir_out != NULL) 1161 *android_srcdir_out = android_srcdir; 1162 else 1163 free(android_srcdir); 1164 1165 if(data_srcdir_out != NULL) 1166 *data_srcdir_out = data_srcdir; 1167 else 1168 free(data_srcdir); 1169 1170 return 0; 1171 } 1172 1173 static int pm_command(transport_type transport, char* serial, 1174 int argc, char** argv) 1175 { 1176 char buf[4096]; 1177 1178 snprintf(buf, sizeof(buf), "shell:pm"); 1179 1180 while(argc-- > 0) { 1181 char *quoted; 1182 1183 quoted = dupAndQuote(*argv++); 1184 1185 strncat(buf, " ", sizeof(buf)-1); 1186 strncat(buf, quoted, sizeof(buf)-1); 1187 free(quoted); 1188 } 1189 1190 send_shellcommand(transport, serial, buf); 1191 return 0; 1192 } 1193 1194 int uninstall_app(transport_type transport, char* serial, int argc, char** argv) 1195 { 1196 /* if the user choose the -k option, we refuse to do it until devices are 1197 out with the option to uninstall the remaining data somehow (adb/ui) */ 1198 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1199 { 1200 printf( 1201 "The -k option uninstalls the application while retaining the data/cache.\n" 1202 "At the moment, there is no way to remove the remaining data.\n" 1203 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1204 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1205 return -1; 1206 } 1207 1208 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1209 return pm_command(transport, serial, argc, argv); 1210 } 1211 1212 static int delete_file(transport_type transport, char* serial, char* filename) 1213 { 1214 char buf[4096]; 1215 char* quoted; 1216 1217 snprintf(buf, sizeof(buf), "shell:rm "); 1218 quoted = dupAndQuote(filename); 1219 strncat(buf, quoted, sizeof(buf)-1); 1220 free(quoted); 1221 1222 send_shellcommand(transport, serial, buf); 1223 return 0; 1224 } 1225 1226 int install_app(transport_type transport, char* serial, int argc, char** argv) 1227 { 1228 struct stat st; 1229 int err; 1230 const char *const DATA_DEST = "/data/local/tmp/%s"; 1231 const char *const SD_DEST = "/sdcard/tmp/%s"; 1232 const char* where = DATA_DEST; 1233 char to[PATH_MAX]; 1234 char* filename = argv[argc - 1]; 1235 const char* p; 1236 int i; 1237 1238 for (i = 0; i < argc; i++) { 1239 if (!strcmp(argv[i], "-s")) 1240 where = SD_DEST; 1241 } 1242 1243 p = adb_dirstop(filename); 1244 if (p) { 1245 p++; 1246 snprintf(to, sizeof to, where, p); 1247 } else { 1248 snprintf(to, sizeof to, where, filename); 1249 } 1250 if (p[0] == '\0') { 1251 } 1252 1253 err = stat(filename, &st); 1254 if (err != 0) { 1255 fprintf(stderr, "can't find '%s' to install\n", filename); 1256 return 1; 1257 } 1258 if (!S_ISREG(st.st_mode)) { 1259 fprintf(stderr, "can't install '%s' because it's not a file\n", 1260 filename); 1261 return 1; 1262 } 1263 1264 if (!(err = do_sync_push(filename, to, 1 /* verify APK */))) { 1265 /* file in place; tell the Package Manager to install it */ 1266 argv[argc - 1] = to; /* destination name, not source location */ 1267 pm_command(transport, serial, argc, argv); 1268 delete_file(transport, serial, to); 1269 } 1270 1271 return err; 1272 } 1273
