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