commandline.cpp revision ee5ce0d14f099e7295a0aed54accd9d952e6a6a1
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 "sysdeps.h" 20 21#include <assert.h> 22#include <ctype.h> 23#include <errno.h> 24#include <inttypes.h> 25#include <limits.h> 26#include <stdarg.h> 27#include <stdint.h> 28#include <stdio.h> 29#include <stdlib.h> 30#include <string.h> 31#include <sys/stat.h> 32#include <sys/types.h> 33 34#include <string> 35 36#include <base/stringprintf.h> 37 38#if !defined(_WIN32) 39#include <termios.h> 40#include <unistd.h> 41#endif 42 43#include "adb.h" 44#include "adb_auth.h" 45#include "adb_client.h" 46#include "adb_io.h" 47#include "adb_utils.h" 48#include "file_sync_service.h" 49 50static int install_app(TransportType t, const char* serial, int argc, const char** argv); 51static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv); 52static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv); 53 54static std::string gProductOutPath; 55extern int gListenAll; 56 57static std::string product_file(const char *extra) { 58 if (gProductOutPath.empty()) { 59 fprintf(stderr, "adb: Product directory not specified; " 60 "use -p or define ANDROID_PRODUCT_OUT\n"); 61 exit(1); 62 } 63 64 return android::base::StringPrintf("%s%s%s", 65 gProductOutPath.c_str(), OS_PATH_SEPARATOR_STR, extra); 66} 67 68static void version(FILE* out) { 69 fprintf(out, "Android Debug Bridge version %d.%d.%d\nRevision %s\n", 70 ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION, ADB_REVISION); 71} 72 73static void help() { 74 version(stderr); 75 76 fprintf(stderr, 77 "\n" 78 " -a - directs adb to listen on all interfaces for a connection\n" 79 " -d - directs command to the only connected USB device\n" 80 " returns an error if more than one USB device is present.\n" 81 " -e - directs command to the only running emulator.\n" 82 " returns an error if more than one emulator is running.\n" 83 " -s <specific device> - directs command to the device or emulator with the given\n" 84 " serial number or qualifier. Overrides ANDROID_SERIAL\n" 85 " environment variable.\n" 86 " -p <product name or path> - simple product name like 'sooner', or\n" 87 " a relative/absolute path to a product\n" 88 " out directory like 'out/target/product/sooner'.\n" 89 " If -p is not specified, the ANDROID_PRODUCT_OUT\n" 90 " environment variable is used, which must\n" 91 " be an absolute path.\n" 92 " -H - Name of adb server host (default: localhost)\n" 93 " -P - Port of adb server (default: 5037)\n" 94 " devices [-l] - list all connected devices\n" 95 " ('-l' will also list device qualifiers)\n" 96 " connect <host>[:<port>] - connect to a device via TCP/IP\n" 97 " Port 5555 is used by default if no port number is specified.\n" 98 " disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.\n" 99 " Port 5555 is used by default if no port number is specified.\n" 100 " Using this command with no additional arguments\n" 101 " will disconnect from all connected TCP/IP devices.\n" 102 "\n" 103 "device commands:\n" 104 " adb push [-p] <local> <remote>\n" 105 " - copy file/dir to device\n" 106 " ('-p' to display the transfer progress)\n" 107 " adb pull [-p] [-a] <remote> [<local>]\n" 108 " - copy file/dir from device\n" 109 " ('-p' to display the transfer progress)\n" 110 " ('-a' means copy timestamp and mode)\n" 111 " adb sync [ <directory> ] - copy host->device only if changed\n" 112 " (-l means list but don't copy)\n" 113 " (see 'adb help all')\n" 114 " adb shell - run remote shell interactively\n" 115 " adb shell <command> - run remote shell command\n" 116 " adb emu <command> - run emulator console command\n" 117 " adb logcat [ <filter-spec> ] - View device log\n" 118 " adb forward --list - list all forward socket connections.\n" 119 " the format is a list of lines with the following format:\n" 120 " <serial> \" \" <local> \" \" <remote> \"\\n\"\n" 121 " adb forward <local> <remote> - forward socket connections\n" 122 " forward specs are one of: \n" 123 " tcp:<port>\n" 124 " localabstract:<unix domain socket name>\n" 125 " localreserved:<unix domain socket name>\n" 126 " localfilesystem:<unix domain socket name>\n" 127 " dev:<character device name>\n" 128 " jdwp:<process pid> (remote only)\n" 129 " adb forward --no-rebind <local> <remote>\n" 130 " - same as 'adb forward <local> <remote>' but fails\n" 131 " if <local> is already forwarded\n" 132 " adb forward --remove <local> - remove a specific forward socket connection\n" 133 " adb forward --remove-all - remove all forward socket connections\n" 134 " adb reverse --list - list all reverse socket connections from device\n" 135 " adb reverse <remote> <local> - reverse socket connections\n" 136 " reverse specs are one of:\n" 137 " tcp:<port>\n" 138 " localabstract:<unix domain socket name>\n" 139 " localreserved:<unix domain socket name>\n" 140 " localfilesystem:<unix domain socket name>\n" 141 " adb reverse --norebind <remote> <local>\n" 142 " - same as 'adb reverse <remote> <local>' but fails\n" 143 " if <remote> is already reversed.\n" 144 " adb reverse --remove <remote>\n" 145 " - remove a specific reversed socket connection\n" 146 " adb reverse --remove-all - remove all reversed socket connections from device\n" 147 " adb jdwp - list PIDs of processes hosting a JDWP transport\n" 148 " adb install [-lrtsd] <file>\n" 149 " adb install-multiple [-lrtsdp] <file...>\n" 150 " - push this package file to the device and install it\n" 151 " (-l: forward lock application)\n" 152 " (-r: replace existing application)\n" 153 " (-t: allow test packages)\n" 154 " (-s: install application on sdcard)\n" 155 " (-d: allow version code downgrade)\n" 156 " (-p: partial application install)\n" 157 " adb uninstall [-k] <package> - remove this app package from the device\n" 158 " ('-k' means keep the data and cache directories)\n" 159 " adb bugreport - return all information from the device\n" 160 " that should be included in a bug report.\n" 161 "\n" 162 " adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n" 163 " - write an archive of the device's data to <file>.\n" 164 " If no -f option is supplied then the data is written\n" 165 " to \"backup.ab\" in the current directory.\n" 166 " (-apk|-noapk enable/disable backup of the .apks themselves\n" 167 " in the archive; the default is noapk.)\n" 168 " (-obb|-noobb enable/disable backup of any installed apk expansion\n" 169 " (aka .obb) files associated with each application; the default\n" 170 " is noobb.)\n" 171 " (-shared|-noshared enable/disable backup of the device's\n" 172 " shared storage / SD card contents; the default is noshared.)\n" 173 " (-all means to back up all installed applications)\n" 174 " (-system|-nosystem toggles whether -all automatically includes\n" 175 " system applications; the default is to include system apps)\n" 176 " (<packages...> is the list of applications to be backed up. If\n" 177 " the -all or -shared flags are passed, then the package\n" 178 " list is optional. Applications explicitly given on the\n" 179 " command line will be included even if -nosystem would\n" 180 " ordinarily cause them to be omitted.)\n" 181 "\n" 182 " adb restore <file> - restore device contents from the <file> backup archive\n" 183 "\n" 184 " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n" 185 " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n" 186 " adb keygen <file> - generate adb public/private key. The private key is stored in <file>,\n" 187 " and the public key is stored in <file>.pub. Any existing files\n" 188 " are overwritten.\n" 189 " adb help - show this help message\n" 190 " adb version - show version num\n" 191 "\n" 192 "scripting:\n" 193 " adb wait-for-device - block until device is online\n" 194 " adb start-server - ensure that there is a server running\n" 195 " adb kill-server - kill the server if it is running\n" 196 " adb get-state - prints: offline | bootloader | device\n" 197 " adb get-serialno - prints: <serial-number>\n" 198 " adb get-devpath - prints: <device-path>\n" 199 " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n" 200 " adb reboot [bootloader|recovery]\n" 201 " - reboots the device, optionally into the bootloader or recovery program.\n" 202 " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n" 203 " adb reboot sideload-auto-reboot\n" 204 " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n" 205 " adb reboot-bootloader - reboots the device into the bootloader\n" 206 " adb root - restarts the adbd daemon with root permissions\n" 207 " adb unroot - restarts the adbd daemon without root permissions\n" 208 " adb usb - restarts the adbd daemon listening on USB\n" 209 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port\n" 210 "networking:\n" 211 " adb ppp <tty> [parameters] - Run PPP over USB.\n" 212 " Note: you should not automatically start a PPP connection.\n" 213 " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n" 214 " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n" 215 "\n" 216 "adb sync notes: adb sync [ <directory> ]\n" 217 " <localdir> can be interpreted in several ways:\n" 218 "\n" 219 " - If <directory> is not specified, /system, /vendor (if present), /oem (if present) and /data partitions will be updated.\n" 220 "\n" 221 " - If it is \"system\", \"vendor\", \"oem\" or \"data\", only the corresponding partition\n" 222 " is updated.\n" 223 "\n" 224 "environmental variables:\n" 225 " ADB_TRACE - Print debug information. A comma separated list of the following values\n" 226 " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n" 227 " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n" 228 " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n" 229 ); 230} 231 232static int usage() { 233 help(); 234 return 1; 235} 236 237#if defined(_WIN32) 238 239// Implemented in sysdeps_win32.cpp. 240void stdin_raw_init(int fd); 241void stdin_raw_restore(int fd); 242 243#else 244static termios g_saved_terminal_state; 245 246static void stdin_raw_init(int fd) { 247 if (tcgetattr(fd, &g_saved_terminal_state)) return; 248 249 termios tio; 250 if (tcgetattr(fd, &tio)) return; 251 252 cfmakeraw(&tio); 253 254 // No timeout but request at least one character per read. 255 tio.c_cc[VTIME] = 0; 256 tio.c_cc[VMIN] = 1; 257 258 tcsetattr(fd, TCSAFLUSH, &tio); 259} 260 261static void stdin_raw_restore(int fd) { 262 tcsetattr(fd, TCSAFLUSH, &g_saved_terminal_state); 263} 264#endif 265 266static void read_and_dump(int fd) { 267 while (fd >= 0) { 268 D("read_and_dump(): pre adb_read(fd=%d)\n", fd); 269 char buf[BUFSIZ]; 270 int len = adb_read(fd, buf, sizeof(buf)); 271 D("read_and_dump(): post adb_read(fd=%d): len=%d\n", fd, len); 272 if (len <= 0) { 273 break; 274 } 275 276 fwrite(buf, 1, len, stdout); 277 fflush(stdout); 278 } 279} 280 281static void read_status_line(int fd, char* buf, size_t count) 282{ 283 count--; 284 while (count > 0) { 285 int len = adb_read(fd, buf, count); 286 if (len == 0) { 287 break; 288 } else if (len < 0) { 289 if (errno == EINTR) continue; 290 break; 291 } 292 293 buf += len; 294 count -= len; 295 } 296 *buf = '\0'; 297} 298 299static void copy_to_file(int inFd, int outFd) { 300 const size_t BUFSIZE = 32 * 1024; 301 char* buf = (char*) malloc(BUFSIZE); 302 if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file"); 303 int len; 304 long total = 0; 305 306 D("copy_to_file(%d -> %d)\n", inFd, outFd); 307 308 if (inFd == STDIN_FILENO) { 309 stdin_raw_init(STDIN_FILENO); 310 } 311 312 while (true) { 313 if (inFd == STDIN_FILENO) { 314 len = unix_read(inFd, buf, BUFSIZE); 315 } else { 316 len = adb_read(inFd, buf, BUFSIZE); 317 } 318 if (len == 0) { 319 D("copy_to_file() : read 0 bytes; exiting\n"); 320 break; 321 } 322 if (len < 0) { 323 if (errno == EINTR) { 324 D("copy_to_file() : EINTR, retrying\n"); 325 continue; 326 } 327 D("copy_to_file() : error %d\n", errno); 328 break; 329 } 330 if (outFd == STDOUT_FILENO) { 331 fwrite(buf, 1, len, stdout); 332 fflush(stdout); 333 } else { 334 adb_write(outFd, buf, len); 335 } 336 total += len; 337 } 338 339 if (inFd == STDIN_FILENO) { 340 stdin_raw_restore(STDIN_FILENO); 341 } 342 343 D("copy_to_file() finished after %lu bytes\n", total); 344 free(buf); 345} 346 347static void *stdin_read_thread(void *x) 348{ 349 int fd, fdi; 350 unsigned char buf[1024]; 351 int r, n; 352 int state = 0; 353 354 int *fds = (int*) x; 355 fd = fds[0]; 356 fdi = fds[1]; 357 free(fds); 358 359 for(;;) { 360 /* fdi is really the client's stdin, so use read, not adb_read here */ 361 D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi); 362 r = unix_read(fdi, buf, 1024); 363 D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi); 364 if(r == 0) break; 365 if(r < 0) { 366 if(errno == EINTR) continue; 367 break; 368 } 369 for(n = 0; n < r; n++){ 370 switch(buf[n]) { 371 case '\n': 372 state = 1; 373 break; 374 case '\r': 375 state = 1; 376 break; 377 case '~': 378 if(state == 1) state++; 379 break; 380 case '.': 381 if(state == 2) { 382 fprintf(stderr,"\n* disconnect *\n"); 383 stdin_raw_restore(fdi); 384 exit(0); 385 } 386 default: 387 state = 0; 388 } 389 } 390 r = adb_write(fd, buf, r); 391 if(r <= 0) { 392 break; 393 } 394 } 395 return 0; 396} 397 398static int interactive_shell() { 399 int fdi; 400 401 std::string error; 402 int fd = adb_connect("shell:", &error); 403 if (fd < 0) { 404 fprintf(stderr,"error: %s\n", error.c_str()); 405 return 1; 406 } 407 fdi = 0; //dup(0); 408 409 int* fds = reinterpret_cast<int*>(malloc(sizeof(int) * 2)); 410 if (fds == nullptr) { 411 fprintf(stderr, "couldn't allocate fds array: %s\n", strerror(errno)); 412 return 1; 413 } 414 415 fds[0] = fd; 416 fds[1] = fdi; 417 418 stdin_raw_init(fdi); 419 420 adb_thread_create(stdin_read_thread, fds); 421 read_and_dump(fd); 422 stdin_raw_restore(fdi); 423 return 0; 424} 425 426 427static std::string format_host_command(const char* command, TransportType type, const char* serial) { 428 if (serial) { 429 return android::base::StringPrintf("host-serial:%s:%s", serial, command); 430 } 431 432 const char* prefix = "host"; 433 if (type == kTransportUsb) { 434 prefix = "host-usb"; 435 } else if (type == kTransportLocal) { 436 prefix = "host-local"; 437 } 438 return android::base::StringPrintf("%s:%s", prefix, command); 439} 440 441static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 442 bool show_progress) 443{ 444 std::string error; 445 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 446 if (fd < 0) { 447 fprintf(stderr,"error: %s\n", error.c_str()); 448 return -1; 449 } 450 451 int opt = CHUNK_SIZE; 452 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 453 454 unsigned total = sz; 455 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 456 457 if (show_progress) { 458 char *x = strrchr(service, ':'); 459 if(x) service = x + 1; 460 } 461 462 while (sz > 0) { 463 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 464 if (!WriteFdExactly(fd, ptr, xfer)) { 465 std::string error; 466 adb_status(fd, &error); 467 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 468 return -1; 469 } 470 sz -= xfer; 471 ptr += xfer; 472 if (show_progress) { 473 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 474 fflush(stdout); 475 } 476 } 477 if (show_progress) { 478 printf("\n"); 479 } 480 481 if (!adb_status(fd, &error)) { 482 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 483 return -1; 484 } 485 486 adb_close(fd); 487 return 0; 488} 489 490#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 491 492/* 493 * The sideload-host protocol serves the data in a file (given on the 494 * command line) to the client, using a simple protocol: 495 * 496 * - The connect message includes the total number of bytes in the 497 * file and a block size chosen by us. 498 * 499 * - The other side sends the desired block number as eight decimal 500 * digits (eg "00000023" for block 23). Blocks are numbered from 501 * zero. 502 * 503 * - We send back the data of the requested block. The last block is 504 * likely to be partial; when the last block is requested we only 505 * send the part of the block that exists, it's not padded up to the 506 * block size. 507 * 508 * - When the other side sends "DONEDONE" instead of a block number, 509 * we hang up. 510 */ 511static int adb_sideload_host(const char* fn) { 512 unsigned sz; 513 size_t xfer = 0; 514 int status; 515 int last_percent = -1; 516 int opt = SIDELOAD_HOST_BLOCK_SIZE; 517 518 printf("loading: '%s'", fn); 519 fflush(stdout); 520 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 521 if (data == 0) { 522 printf("\n"); 523 fprintf(stderr, "* cannot read '%s' *\n", fn); 524 return -1; 525 } 526 527 std::string service = 528 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 529 std::string error; 530 int fd = adb_connect(service, &error); 531 if (fd < 0) { 532 // Try falling back to the older sideload method. Maybe this 533 // is an older device that doesn't support sideload-host. 534 printf("\n"); 535 status = adb_download_buffer("sideload", fn, data, sz, true); 536 goto done; 537 } 538 539 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 540 541 while (true) { 542 char buf[9]; 543 if (!ReadFdExactly(fd, buf, 8)) { 544 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 545 status = -1; 546 goto done; 547 } 548 buf[8] = '\0'; 549 550 if (strcmp("DONEDONE", buf) == 0) { 551 status = 0; 552 break; 553 } 554 555 int block = strtol(buf, NULL, 10); 556 557 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 558 if (offset >= sz) { 559 fprintf(stderr, "* attempt to read block %d past end\n", block); 560 status = -1; 561 goto done; 562 } 563 uint8_t* start = data + offset; 564 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 565 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 566 if (offset_end > sz) { 567 to_write = sz - offset; 568 } 569 570 if(!WriteFdExactly(fd, start, to_write)) { 571 adb_status(fd, &error); 572 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 573 status = -1; 574 goto done; 575 } 576 xfer += to_write; 577 578 // For normal OTA packages, we expect to transfer every byte 579 // twice, plus a bit of overhead (one read during 580 // verification, one read of each byte for installation, plus 581 // extra access to things like the zip central directory). 582 // This estimate of the completion becomes 100% when we've 583 // transferred ~2.13 (=100/47) times the package size. 584 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 585 if (percent != last_percent) { 586 printf("\rserving: '%s' (~%d%%) ", fn, percent); 587 fflush(stdout); 588 last_percent = percent; 589 } 590 } 591 592 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 593 594 done: 595 if (fd >= 0) adb_close(fd); 596 free(data); 597 return status; 598} 599 600/** 601 * Run ppp in "notty" mode against a resource listed as the first parameter 602 * eg: 603 * 604 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 605 * 606 */ 607static int ppp(int argc, const char** argv) { 608#if defined(_WIN32) 609 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 610 return -1; 611#else 612 if (argc < 2) { 613 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 614 argv[0]); 615 616 return 1; 617 } 618 619 const char* adb_service_name = argv[1]; 620 std::string error; 621 int fd = adb_connect(adb_service_name, &error); 622 if (fd < 0) { 623 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 624 adb_service_name, error.c_str()); 625 return 1; 626 } 627 628 pid_t pid = fork(); 629 630 if (pid < 0) { 631 perror("from fork()"); 632 return 1; 633 } else if (pid == 0) { 634 int err; 635 int i; 636 const char **ppp_args; 637 638 // copy args 639 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 640 ppp_args[0] = "pppd"; 641 for (i = 2 ; i < argc ; i++) { 642 //argv[2] and beyond become ppp_args[1] and beyond 643 ppp_args[i - 1] = argv[i]; 644 } 645 ppp_args[i-1] = NULL; 646 647 // child side 648 649 dup2(fd, STDIN_FILENO); 650 dup2(fd, STDOUT_FILENO); 651 adb_close(STDERR_FILENO); 652 adb_close(fd); 653 654 err = execvp("pppd", (char * const *)ppp_args); 655 656 if (err < 0) { 657 perror("execing pppd"); 658 } 659 exit(-1); 660 } else { 661 // parent side 662 663 adb_close(fd); 664 return 0; 665 } 666#endif /* !defined(_WIN32) */ 667} 668 669static bool wait_for_device(const char* service, TransportType t, const char* serial) { 670 // Was the caller vague about what they'd like us to wait for? 671 // If so, check they weren't more specific in their choice of transport type. 672 if (strcmp(service, "wait-for-device") == 0) { 673 if (t == kTransportUsb) { 674 service = "wait-for-usb"; 675 } else if (t == kTransportLocal) { 676 service = "wait-for-local"; 677 } else { 678 service = "wait-for-any"; 679 } 680 } 681 682 std::string cmd = format_host_command(service, t, serial); 683 std::string error; 684 if (adb_command(cmd, &error)) { 685 D("failure: %s *\n", error.c_str()); 686 fprintf(stderr,"error: %s\n", error.c_str()); 687 return false; 688 } 689 690 return true; 691} 692 693static int send_shell_command(TransportType transport_type, const char* serial, 694 const std::string& command) { 695 int fd; 696 while (true) { 697 std::string error; 698 fd = adb_connect(command, &error); 699 if (fd >= 0) { 700 break; 701 } 702 fprintf(stderr,"- waiting for device -\n"); 703 adb_sleep_ms(1000); 704 wait_for_device("wait-for-device", transport_type, serial); 705 } 706 707 read_and_dump(fd); 708 int rc = adb_close(fd); 709 if (rc) { 710 perror("close"); 711 } 712 return rc; 713} 714 715static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 716 char* log_tags = getenv("ANDROID_LOG_TAGS"); 717 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 718 719 std::string cmd = "shell:export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 720 721 if (!strcmp(argv[0], "longcat")) { 722 cmd += " -v long"; 723 } 724 725 --argc; 726 ++argv; 727 while (argc-- > 0) { 728 cmd += " " + escape_arg(*argv++); 729 } 730 731 return send_shell_command(transport, serial, cmd); 732} 733 734static int mkdirs(const char *path) 735{ 736 int ret; 737 char *x = (char *)path + 1; 738 739 for(;;) { 740 x = adb_dirstart(x); 741 if(x == 0) return 0; 742 *x = 0; 743 ret = adb_mkdir(path, 0775); 744 *x = OS_PATH_SEPARATOR; 745 if((ret < 0) && (errno != EEXIST)) { 746 return ret; 747 } 748 x++; 749 } 750 return 0; 751} 752 753static int backup(int argc, const char** argv) { 754 const char* filename = "./backup.ab"; 755 756 /* find, extract, and use any -f argument */ 757 for (int i = 1; i < argc; i++) { 758 if (!strcmp("-f", argv[i])) { 759 if (i == argc-1) { 760 fprintf(stderr, "adb: -f passed with no filename\n"); 761 return usage(); 762 } 763 filename = argv[i+1]; 764 for (int j = i+2; j <= argc; ) { 765 argv[i++] = argv[j++]; 766 } 767 argc -= 2; 768 argv[argc] = NULL; 769 } 770 } 771 772 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 773 if (argc < 2) return usage(); 774 775 adb_unlink(filename); 776 mkdirs(filename); 777 int outFd = adb_creat(filename, 0640); 778 if (outFd < 0) { 779 fprintf(stderr, "adb: unable to open file %s\n", filename); 780 return -1; 781 } 782 783 std::string cmd = "backup:"; 784 --argc; 785 ++argv; 786 while (argc-- > 0) { 787 cmd += " " + escape_arg(*argv++); 788 } 789 790 D("backup. filename=%s cmd=%s\n", filename, cmd.c_str()); 791 std::string error; 792 int fd = adb_connect(cmd, &error); 793 if (fd < 0) { 794 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 795 adb_close(outFd); 796 return -1; 797 } 798 799 printf("Now unlock your device and confirm the backup operation.\n"); 800 copy_to_file(fd, outFd); 801 802 adb_close(fd); 803 adb_close(outFd); 804 return 0; 805} 806 807static int restore(int argc, const char** argv) { 808 if (argc != 2) return usage(); 809 810 const char* filename = argv[1]; 811 int tarFd = adb_open(filename, O_RDONLY); 812 if (tarFd < 0) { 813 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 814 return -1; 815 } 816 817 std::string error; 818 int fd = adb_connect("restore:", &error); 819 if (fd < 0) { 820 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 821 adb_close(tarFd); 822 return -1; 823 } 824 825 printf("Now unlock your device and confirm the restore operation.\n"); 826 copy_to_file(tarFd, fd); 827 828 adb_close(fd); 829 adb_close(tarFd); 830 return 0; 831} 832 833/* <hint> may be: 834 * - A simple product name 835 * e.g., "sooner" 836 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 837 * e.g., "out/target/product/sooner" 838 * - An absolute path to the PRODUCT_OUT dir 839 * e.g., "/src/device/out/target/product/sooner" 840 * 841 * Given <hint>, try to construct an absolute path to the 842 * ANDROID_PRODUCT_OUT dir. 843 */ 844static std::string find_product_out_path(const char* hint) { 845 if (hint == NULL || hint[0] == '\0') { 846 return ""; 847 } 848 849 // If it's already absolute, don't bother doing any work. 850 if (adb_is_absolute_host_path(hint)) { 851 return hint; 852 } 853 854 // If there are any slashes in it, assume it's a relative path; 855 // make it absolute. 856 if (adb_dirstart(hint) != nullptr) { 857 std::string cwd; 858 if (!getcwd(&cwd)) { 859 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 860 return ""; 861 } 862 return android::base::StringPrintf("%s%s%s", cwd.c_str(), OS_PATH_SEPARATOR_STR, hint); 863 } 864 865 // It's a string without any slashes. Try to do something with it. 866 // 867 // Try to find the root of the build tree, and build a PRODUCT_OUT 868 // path from there. 869 char* top = getenv("ANDROID_BUILD_TOP"); 870 if (top == nullptr) { 871 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 872 return ""; 873 } 874 875 std::string path = top; 876 path += OS_PATH_SEPARATOR_STR; 877 path += "out"; 878 path += OS_PATH_SEPARATOR_STR; 879 path += "target"; 880 path += OS_PATH_SEPARATOR_STR; 881 path += "product"; 882 path += OS_PATH_SEPARATOR_STR; 883 path += hint; 884 if (!directory_exists(path)) { 885 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 886 "\"%s\" doesn't exist\n", hint, path.c_str()); 887 return ""; 888 } 889 return path; 890} 891 892static void parse_push_pull_args(const char **arg, int narg, char const **path1, 893 char const **path2, int *show_progress, 894 int *copy_attrs) { 895 *show_progress = 0; 896 *copy_attrs = 0; 897 898 while (narg > 0) { 899 if (!strcmp(*arg, "-p")) { 900 *show_progress = 1; 901 } else if (!strcmp(*arg, "-a")) { 902 *copy_attrs = 1; 903 } else { 904 break; 905 } 906 ++arg; 907 --narg; 908 } 909 910 if (narg > 0) { 911 *path1 = *arg; 912 ++arg; 913 --narg; 914 } 915 916 if (narg > 0) { 917 *path2 = *arg; 918 } 919} 920 921static int adb_connect_command(const std::string& command) { 922 std::string error; 923 int fd = adb_connect(command, &error); 924 if (fd < 0) { 925 fprintf(stderr, "error: %s\n", error.c_str()); 926 return 1; 927 } 928 read_and_dump(fd); 929 adb_close(fd); 930 return 0; 931} 932 933static int adb_query_command(const std::string& command) { 934 std::string result; 935 std::string error; 936 if (!adb_query(command, &result, &error)) { 937 fprintf(stderr, "error: %s\n", error.c_str()); 938 return 1; 939 } 940 printf("%s\n", result.c_str()); 941 return 0; 942} 943 944int adb_commandline(int argc, const char **argv) { 945 int no_daemon = 0; 946 int is_daemon = 0; 947 int is_server = 0; 948 int r; 949 TransportType transport_type = kTransportAny; 950 951 // If defined, this should be an absolute path to 952 // the directory containing all of the various system images 953 // for a particular product. If not defined, and the adb 954 // command requires this information, then the user must 955 // specify the path using "-p". 956 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 957 if (ANDROID_PRODUCT_OUT != nullptr) { 958 gProductOutPath = ANDROID_PRODUCT_OUT; 959 } 960 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 961 962 const char* serial = getenv("ANDROID_SERIAL"); 963 964 /* Validate and assign the server port */ 965 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 966 int server_port = DEFAULT_ADB_PORT; 967 if (server_port_str && strlen(server_port_str) > 0) { 968 server_port = (int) strtol(server_port_str, NULL, 0); 969 if (server_port <= 0 || server_port > 65535) { 970 fprintf(stderr, 971 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n", 972 server_port_str); 973 return usage(); 974 } 975 } 976 977 /* modifiers and flags */ 978 while (argc > 0) { 979 if (!strcmp(argv[0],"server")) { 980 is_server = 1; 981 } else if (!strcmp(argv[0],"nodaemon")) { 982 no_daemon = 1; 983 } else if (!strcmp(argv[0], "fork-server")) { 984 /* this is a special flag used only when the ADB client launches the ADB Server */ 985 is_daemon = 1; 986 } else if (!strncmp(argv[0], "-p", 2)) { 987 const char *product = NULL; 988 if (argv[0][2] == '\0') { 989 if (argc < 2) return usage(); 990 product = argv[1]; 991 argc--; 992 argv++; 993 } else { 994 product = argv[0] + 2; 995 } 996 gProductOutPath = find_product_out_path(product); 997 if (gProductOutPath.empty()) { 998 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 999 return usage(); 1000 } 1001 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1002 if (isdigit(argv[0][2])) { 1003 serial = argv[0] + 2; 1004 } else { 1005 if (argc < 2 || argv[0][2] != '\0') return usage(); 1006 serial = argv[1]; 1007 argc--; 1008 argv++; 1009 } 1010 } else if (!strcmp(argv[0],"-d")) { 1011 transport_type = kTransportUsb; 1012 } else if (!strcmp(argv[0],"-e")) { 1013 transport_type = kTransportLocal; 1014 } else if (!strcmp(argv[0],"-a")) { 1015 gListenAll = 1; 1016 } else if (!strncmp(argv[0], "-H", 2)) { 1017 const char *hostname = NULL; 1018 if (argv[0][2] == '\0') { 1019 if (argc < 2) return usage(); 1020 hostname = argv[1]; 1021 argc--; 1022 argv++; 1023 } else { 1024 hostname = argv[0] + 2; 1025 } 1026 adb_set_tcp_name(hostname); 1027 1028 } else if (!strncmp(argv[0], "-P", 2)) { 1029 if (argv[0][2] == '\0') { 1030 if (argc < 2) return usage(); 1031 server_port_str = argv[1]; 1032 argc--; 1033 argv++; 1034 } else { 1035 server_port_str = argv[0] + 2; 1036 } 1037 if (strlen(server_port_str) > 0) { 1038 server_port = (int) strtol(server_port_str, NULL, 0); 1039 if (server_port <= 0 || server_port > 65535) { 1040 fprintf(stderr, 1041 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1042 server_port_str); 1043 return usage(); 1044 } 1045 } else { 1046 fprintf(stderr, 1047 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1048 return usage(); 1049 } 1050 } else { 1051 /* out of recognized modifiers and flags */ 1052 break; 1053 } 1054 argc--; 1055 argv++; 1056 } 1057 1058 adb_set_transport(transport_type, serial); 1059 adb_set_tcp_specifics(server_port); 1060 1061 if (is_server) { 1062 if (no_daemon || is_daemon) { 1063 r = adb_main(is_daemon, server_port); 1064 } else { 1065 r = launch_server(server_port); 1066 } 1067 if (r) { 1068 fprintf(stderr,"* could not start server *\n"); 1069 } 1070 return r; 1071 } 1072 1073 if (argc == 0) { 1074 return usage(); 1075 } 1076 1077 /* handle wait-for-* prefix */ 1078 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1079 const char* service = argv[0]; 1080 1081 if (!wait_for_device(service, transport_type, serial)) { 1082 return 1; 1083 } 1084 1085 // Allow a command to be run after wait-for-device, 1086 // e.g. 'adb wait-for-device shell'. 1087 if (argc == 1) { 1088 return 0; 1089 } 1090 1091 /* Fall through */ 1092 argc--; 1093 argv++; 1094 } 1095 1096 /* adb_connect() commands */ 1097 if (!strcmp(argv[0], "devices")) { 1098 const char *listopt; 1099 if (argc < 2) { 1100 listopt = ""; 1101 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1102 listopt = argv[1]; 1103 } else { 1104 fprintf(stderr, "Usage: adb devices [-l]\n"); 1105 return 1; 1106 } 1107 1108 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1109 printf("List of devices attached\n"); 1110 return adb_query_command(query); 1111 } 1112 else if (!strcmp(argv[0], "connect")) { 1113 if (argc != 2) { 1114 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1115 return 1; 1116 } 1117 1118 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1119 return adb_query_command(query); 1120 } 1121 else if (!strcmp(argv[0], "disconnect")) { 1122 if (argc > 2) { 1123 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1124 return 1; 1125 } 1126 1127 std::string query = android::base::StringPrintf("host:disconnect:%s", 1128 (argc == 2) ? argv[1] : ""); 1129 return adb_query_command(query); 1130 } 1131 else if (!strcmp(argv[0], "emu")) { 1132 return adb_send_emulator_command(argc, argv, serial); 1133 } 1134 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1135 char h = (argv[0][0] == 'h'); 1136 1137 if (h) { 1138 printf("\x1b[41;33m"); 1139 fflush(stdout); 1140 } 1141 1142 if (argc < 2) { 1143 D("starting interactive shell\n"); 1144 r = interactive_shell(); 1145 if (h) { 1146 printf("\x1b[0m"); 1147 fflush(stdout); 1148 } 1149 return r; 1150 } 1151 1152 std::string cmd = "shell:"; 1153 --argc; 1154 ++argv; 1155 while (argc-- > 0) { 1156 // We don't escape here, just like ssh(1). http://b/20564385. 1157 cmd += *argv++; 1158 if (*argv) cmd += " "; 1159 } 1160 1161 while (true) { 1162 D("interactive shell loop. cmd=%s\n", cmd.c_str()); 1163 std::string error; 1164 int fd = adb_connect(cmd, &error); 1165 int r; 1166 if (fd >= 0) { 1167 D("about to read_and_dump(fd=%d)\n", fd); 1168 read_and_dump(fd); 1169 D("read_and_dump() done.\n"); 1170 adb_close(fd); 1171 r = 0; 1172 } else { 1173 fprintf(stderr,"error: %s\n", error.c_str()); 1174 r = -1; 1175 } 1176 1177 if (h) { 1178 printf("\x1b[0m"); 1179 fflush(stdout); 1180 } 1181 D("interactive shell loop. return r=%d\n", r); 1182 return r; 1183 } 1184 } 1185 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1186 int exec_in = !strcmp(argv[0], "exec-in"); 1187 1188 std::string cmd = "exec:"; 1189 cmd += argv[1]; 1190 argc -= 2; 1191 argv += 2; 1192 while (argc-- > 0) { 1193 cmd += " " + escape_arg(*argv++); 1194 } 1195 1196 std::string error; 1197 int fd = adb_connect(cmd, &error); 1198 if (fd < 0) { 1199 fprintf(stderr, "error: %s\n", error.c_str()); 1200 return -1; 1201 } 1202 1203 if (exec_in) { 1204 copy_to_file(STDIN_FILENO, fd); 1205 } else { 1206 copy_to_file(fd, STDOUT_FILENO); 1207 } 1208 1209 adb_close(fd); 1210 return 0; 1211 } 1212 else if (!strcmp(argv[0], "kill-server")) { 1213 std::string error; 1214 int fd = _adb_connect("host:kill", &error); 1215 if (fd == -1) { 1216 fprintf(stderr,"* server not running *\n"); 1217 return 1; 1218 } 1219 return 0; 1220 } 1221 else if (!strcmp(argv[0], "sideload")) { 1222 if (argc != 2) return usage(); 1223 if (adb_sideload_host(argv[1])) { 1224 return 1; 1225 } else { 1226 return 0; 1227 } 1228 } 1229 else if (!strcmp(argv[0], "remount") || 1230 !strcmp(argv[0], "reboot") || 1231 !strcmp(argv[0], "reboot-bootloader") || 1232 !strcmp(argv[0], "tcpip") || 1233 !strcmp(argv[0], "usb") || 1234 !strcmp(argv[0], "root") || 1235 !strcmp(argv[0], "unroot") || 1236 !strcmp(argv[0], "disable-verity") || 1237 !strcmp(argv[0], "enable-verity")) { 1238 std::string command; 1239 if (!strcmp(argv[0], "reboot-bootloader")) { 1240 command = "reboot:bootloader"; 1241 } else if (argc > 1) { 1242 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1243 } else { 1244 command = android::base::StringPrintf("%s:", argv[0]); 1245 } 1246 return adb_connect_command(command); 1247 } 1248 else if (!strcmp(argv[0], "bugreport")) { 1249 if (argc != 1) return usage(); 1250 return send_shell_command(transport_type, serial, "shell:bugreport"); 1251 } 1252 /* adb_command() wrapper commands */ 1253 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1254 std::string cmd; 1255 char host_prefix[64]; 1256 char reverse = (char) !strcmp(argv[0], "reverse"); 1257 char remove = 0; 1258 char remove_all = 0; 1259 char list = 0; 1260 char no_rebind = 0; 1261 1262 // Parse options here. 1263 while (argc > 1 && argv[1][0] == '-') { 1264 if (!strcmp(argv[1], "--list")) 1265 list = 1; 1266 else if (!strcmp(argv[1], "--remove")) 1267 remove = 1; 1268 else if (!strcmp(argv[1], "--remove-all")) 1269 remove_all = 1; 1270 else if (!strcmp(argv[1], "--no-rebind")) 1271 no_rebind = 1; 1272 else { 1273 return usage(); 1274 } 1275 argc--; 1276 argv++; 1277 } 1278 1279 // Ensure we can only use one option at a time. 1280 if (list + remove + remove_all + no_rebind > 1) { 1281 return usage(); 1282 } 1283 1284 // Determine the <host-prefix> for this command. 1285 if (reverse) { 1286 snprintf(host_prefix, sizeof host_prefix, "reverse"); 1287 } else { 1288 if (serial) { 1289 snprintf(host_prefix, sizeof host_prefix, "host-serial:%s", 1290 serial); 1291 } else if (transport_type == kTransportUsb) { 1292 snprintf(host_prefix, sizeof host_prefix, "host-usb"); 1293 } else if (transport_type == kTransportLocal) { 1294 snprintf(host_prefix, sizeof host_prefix, "host-local"); 1295 } else { 1296 snprintf(host_prefix, sizeof host_prefix, "host"); 1297 } 1298 } 1299 1300 // Implement forward --list 1301 if (list) { 1302 if (argc != 1) { 1303 return usage(); 1304 } 1305 1306 std::string query = android::base::StringPrintf("%s:list-forward", host_prefix); 1307 return adb_query_command(query); 1308 } 1309 1310 // Implement forward --remove-all 1311 else if (remove_all) { 1312 if (argc != 1) return usage(); 1313 cmd = android::base::StringPrintf("%s:killforward-all", host_prefix); 1314 } 1315 1316 // Implement forward --remove <local> 1317 else if (remove) { 1318 if (argc != 2) return usage(); 1319 cmd = android::base::StringPrintf("%s:killforward:%s", host_prefix, argv[1]); 1320 } 1321 // Or implement one of: 1322 // forward <local> <remote> 1323 // forward --no-rebind <local> <remote> 1324 else { 1325 if (argc != 3) return usage(); 1326 const char* command = no_rebind ? "forward:norebind" : "forward"; 1327 cmd = android::base::StringPrintf("%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]); 1328 } 1329 1330 std::string error; 1331 if (adb_command(cmd, &error)) { 1332 fprintf(stderr, "error: %s\n", error.c_str()); 1333 return 1; 1334 } 1335 return 0; 1336 } 1337 /* do_sync_*() commands */ 1338 else if (!strcmp(argv[0], "ls")) { 1339 if (argc != 2) return usage(); 1340 return do_sync_ls(argv[1]); 1341 } 1342 else if (!strcmp(argv[0], "push")) { 1343 int show_progress = 0; 1344 int copy_attrs = 0; // unused 1345 const char* lpath = NULL, *rpath = NULL; 1346 1347 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1348 1349 if ((lpath != NULL) && (rpath != NULL)) { 1350 return do_sync_push(lpath, rpath, show_progress); 1351 } 1352 1353 return usage(); 1354 } 1355 else if (!strcmp(argv[0], "pull")) { 1356 int show_progress = 0; 1357 int copy_attrs = 0; 1358 const char* rpath = NULL, *lpath = "."; 1359 1360 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1361 1362 if (rpath != NULL) { 1363 return do_sync_pull(rpath, lpath, show_progress, copy_attrs); 1364 } 1365 1366 return usage(); 1367 } 1368 else if (!strcmp(argv[0], "install")) { 1369 if (argc < 2) return usage(); 1370 return install_app(transport_type, serial, argc, argv); 1371 } 1372 else if (!strcmp(argv[0], "install-multiple")) { 1373 if (argc < 2) return usage(); 1374 return install_multiple_app(transport_type, serial, argc, argv); 1375 } 1376 else if (!strcmp(argv[0], "uninstall")) { 1377 if (argc < 2) return usage(); 1378 return uninstall_app(transport_type, serial, argc, argv); 1379 } 1380 else if (!strcmp(argv[0], "sync")) { 1381 std::string src; 1382 bool list_only = false; 1383 if (argc < 2) { 1384 // No local path was specified. 1385 src = ""; 1386 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1387 list_only = true; 1388 if (argc == 3) { 1389 src = argv[2]; 1390 } else { 1391 src = ""; 1392 } 1393 } else if (argc == 2) { 1394 // A local path or "android"/"data" arg was specified. 1395 src = argv[1]; 1396 } else { 1397 return usage(); 1398 } 1399 1400 if (src != "" && 1401 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1402 return usage(); 1403 } 1404 1405 std::string system_src_path = product_file("system"); 1406 std::string data_src_path = product_file("data"); 1407 std::string vendor_src_path = product_file("vendor"); 1408 std::string oem_src_path = product_file("oem"); 1409 1410 int rc = 0; 1411 if (rc == 0 && (src.empty() || src == "system")) { 1412 rc = do_sync_sync(system_src_path, "/system", list_only); 1413 } 1414 if (rc == 0 && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1415 rc = do_sync_sync(vendor_src_path, "/vendor", list_only); 1416 } 1417 if (rc == 0 && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1418 rc = do_sync_sync(oem_src_path, "/oem", list_only); 1419 } 1420 if (rc == 0 && (src.empty() || src == "data")) { 1421 rc = do_sync_sync(data_src_path, "/data", list_only); 1422 } 1423 return rc; 1424 } 1425 /* passthrough commands */ 1426 else if (!strcmp(argv[0],"get-state") || 1427 !strcmp(argv[0],"get-serialno") || 1428 !strcmp(argv[0],"get-devpath")) 1429 { 1430 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1431 } 1432 /* other commands */ 1433 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1434 return logcat(transport_type, serial, argc, argv); 1435 } 1436 else if (!strcmp(argv[0],"ppp")) { 1437 return ppp(argc, argv); 1438 } 1439 else if (!strcmp(argv[0], "start-server")) { 1440 std::string error; 1441 return adb_connect("host:start-server", &error); 1442 } 1443 else if (!strcmp(argv[0], "backup")) { 1444 return backup(argc, argv); 1445 } 1446 else if (!strcmp(argv[0], "restore")) { 1447 return restore(argc, argv); 1448 } 1449 else if (!strcmp(argv[0], "keygen")) { 1450 if (argc < 2) return usage(); 1451 return adb_auth_keygen(argv[1]); 1452 } 1453 else if (!strcmp(argv[0], "jdwp")) { 1454 return adb_connect_command("jdwp"); 1455 } 1456 /* "adb /?" is a common idiom under Windows */ 1457 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1458 help(); 1459 return 0; 1460 } 1461 else if (!strcmp(argv[0], "version")) { 1462 version(stdout); 1463 return 0; 1464 } 1465 1466 usage(); 1467 return 1; 1468} 1469 1470static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1471 std::string cmd = "shell:pm"; 1472 1473 while (argc-- > 0) { 1474 cmd += " " + escape_arg(*argv++); 1475 } 1476 1477 return send_shell_command(transport, serial, cmd); 1478} 1479 1480static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1481 /* if the user choose the -k option, we refuse to do it until devices are 1482 out with the option to uninstall the remaining data somehow (adb/ui) */ 1483 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1484 { 1485 printf( 1486 "The -k option uninstalls the application while retaining the data/cache.\n" 1487 "At the moment, there is no way to remove the remaining data.\n" 1488 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1489 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1490 return -1; 1491 } 1492 1493 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1494 return pm_command(transport, serial, argc, argv); 1495} 1496 1497static int delete_file(TransportType transport, const char* serial, char* filename) { 1498 std::string cmd = "shell:rm -f " + escape_arg(filename); 1499 return send_shell_command(transport, serial, cmd); 1500} 1501 1502static const char* get_basename(const char* filename) 1503{ 1504 const char* basename = adb_dirstop(filename); 1505 if (basename) { 1506 basename++; 1507 return basename; 1508 } else { 1509 return filename; 1510 } 1511} 1512 1513static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1514 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1515 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1516 const char* where = DATA_DEST; 1517 int i; 1518 struct stat sb; 1519 1520 for (i = 1; i < argc; i++) { 1521 if (!strcmp(argv[i], "-s")) { 1522 where = SD_DEST; 1523 } 1524 } 1525 1526 // Find last APK argument. 1527 // All other arguments passed through verbatim. 1528 int last_apk = -1; 1529 for (i = argc - 1; i >= 0; i--) { 1530 const char* file = argv[i]; 1531 char* dot = strrchr(file, '.'); 1532 if (dot && !strcasecmp(dot, ".apk")) { 1533 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1534 fprintf(stderr, "Invalid APK file: %s\n", file); 1535 return -1; 1536 } 1537 1538 last_apk = i; 1539 break; 1540 } 1541 } 1542 1543 if (last_apk == -1) { 1544 fprintf(stderr, "Missing APK file\n"); 1545 return -1; 1546 } 1547 1548 const char* apk_file = argv[last_apk]; 1549 char apk_dest[PATH_MAX]; 1550 snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file)); 1551 int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */); 1552 if (err) { 1553 goto cleanup_apk; 1554 } else { 1555 argv[last_apk] = apk_dest; /* destination name, not source location */ 1556 } 1557 1558 err = pm_command(transport, serial, argc, argv); 1559 1560cleanup_apk: 1561 delete_file(transport, serial, apk_dest); 1562 return err; 1563} 1564 1565static int install_multiple_app(TransportType transport, const char* serial, int argc, 1566 const char** argv) 1567{ 1568 int i; 1569 struct stat sb; 1570 uint64_t total_size = 0; 1571 1572 // Find all APK arguments starting at end. 1573 // All other arguments passed through verbatim. 1574 int first_apk = -1; 1575 for (i = argc - 1; i >= 0; i--) { 1576 const char* file = argv[i]; 1577 char* dot = strrchr(file, '.'); 1578 if (dot && !strcasecmp(dot, ".apk")) { 1579 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1580 fprintf(stderr, "Invalid APK file: %s\n", file); 1581 return -1; 1582 } 1583 1584 total_size += sb.st_size; 1585 first_apk = i; 1586 } else { 1587 break; 1588 } 1589 } 1590 1591 if (first_apk == -1) { 1592 fprintf(stderr, "Missing APK file\n"); 1593 return 1; 1594 } 1595 1596#if defined(_WIN32) // Remove when we're using clang for Win32. 1597 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %u", (unsigned) total_size); 1598#else 1599 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1600#endif 1601 for (i = 1; i < first_apk; i++) { 1602 cmd += " " + escape_arg(argv[i]); 1603 } 1604 1605 // Create install session 1606 std::string error; 1607 int fd = adb_connect(cmd, &error); 1608 if (fd < 0) { 1609 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1610 return -1; 1611 } 1612 char buf[BUFSIZ]; 1613 read_status_line(fd, buf, sizeof(buf)); 1614 adb_close(fd); 1615 1616 int session_id = -1; 1617 if (!strncmp("Success", buf, 7)) { 1618 char* start = strrchr(buf, '['); 1619 char* end = strrchr(buf, ']'); 1620 if (start && end) { 1621 *end = '\0'; 1622 session_id = strtol(start + 1, NULL, 10); 1623 } 1624 } 1625 if (session_id < 0) { 1626 fprintf(stderr, "Failed to create session\n"); 1627 fputs(buf, stderr); 1628 return -1; 1629 } 1630 1631 // Valid session, now stream the APKs 1632 int success = 1; 1633 for (i = first_apk; i < argc; i++) { 1634 const char* file = argv[i]; 1635 if (stat(file, &sb) == -1) { 1636 fprintf(stderr, "Failed to stat %s\n", file); 1637 success = 0; 1638 goto finalize_session; 1639 } 1640 1641#if defined(_WIN32) // Remove when we're using clang for Win32. 1642 std::string cmd = android::base::StringPrintf( 1643 "exec:pm install-write -S %u %d %d_%s -", 1644 (unsigned) sb.st_size, session_id, i, get_basename(file)); 1645#else 1646 std::string cmd = android::base::StringPrintf( 1647 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1648 static_cast<uint64_t>(sb.st_size), session_id, i, get_basename(file)); 1649#endif 1650 1651 int localFd = adb_open(file, O_RDONLY); 1652 if (localFd < 0) { 1653 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1654 success = 0; 1655 goto finalize_session; 1656 } 1657 1658 std::string error; 1659 int remoteFd = adb_connect(cmd, &error); 1660 if (remoteFd < 0) { 1661 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1662 adb_close(localFd); 1663 success = 0; 1664 goto finalize_session; 1665 } 1666 1667 copy_to_file(localFd, remoteFd); 1668 read_status_line(remoteFd, buf, sizeof(buf)); 1669 1670 adb_close(localFd); 1671 adb_close(remoteFd); 1672 1673 if (strncmp("Success", buf, 7)) { 1674 fprintf(stderr, "Failed to write %s\n", file); 1675 fputs(buf, stderr); 1676 success = 0; 1677 goto finalize_session; 1678 } 1679 } 1680 1681finalize_session: 1682 // Commit session if we streamed everything okay; otherwise abandon 1683 std::string service = 1684 android::base::StringPrintf("exec:pm install-%s %d", 1685 success ? "commit" : "abandon", session_id); 1686 fd = adb_connect(service, &error); 1687 if (fd < 0) { 1688 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1689 return -1; 1690 } 1691 read_status_line(fd, buf, sizeof(buf)); 1692 adb_close(fd); 1693 1694 if (!strncmp("Success", buf, 7)) { 1695 fputs(buf, stderr); 1696 return 0; 1697 } else { 1698 fprintf(stderr, "Failed to finalize session\n"); 1699 fputs(buf, stderr); 1700 return -1; 1701 } 1702} 1703