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