commandline.cpp revision b7dfb79b53c516e54a8964ba66e207a3bb4db9ee
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#ifdef _WIN32 306 int old_stdin_mode = -1; 307 int old_stdout_mode = -1; 308#endif 309 310 D("copy_to_file(%d -> %d)\n", inFd, outFd); 311 312 if (inFd == STDIN_FILENO) { 313 stdin_raw_init(STDIN_FILENO); 314#ifdef _WIN32 315 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY); 316 if (old_stdin_mode == -1) { 317 fatal_errno("could not set stdin to binary"); 318 } 319#endif 320 } 321 322#ifdef _WIN32 323 if (outFd == STDOUT_FILENO) { 324 old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY); 325 if (old_stdout_mode == -1) { 326 fatal_errno("could not set stdout to binary"); 327 } 328 } 329#endif 330 331 while (true) { 332 if (inFd == STDIN_FILENO) { 333 len = unix_read(inFd, buf, BUFSIZE); 334 } else { 335 len = adb_read(inFd, buf, BUFSIZE); 336 } 337 if (len == 0) { 338 D("copy_to_file() : read 0 bytes; exiting\n"); 339 break; 340 } 341 if (len < 0) { 342 if (errno == EINTR) { 343 D("copy_to_file() : EINTR, retrying\n"); 344 continue; 345 } 346 D("copy_to_file() : error %d\n", errno); 347 break; 348 } 349 if (outFd == STDOUT_FILENO) { 350 fwrite(buf, 1, len, stdout); 351 fflush(stdout); 352 } else { 353 adb_write(outFd, buf, len); 354 } 355 total += len; 356 } 357 358 if (inFd == STDIN_FILENO) { 359 stdin_raw_restore(STDIN_FILENO); 360#ifdef _WIN32 361 if (_setmode(STDIN_FILENO, old_stdin_mode) == -1) { 362 fatal_errno("could not restore stdin mode"); 363 } 364#endif 365 } 366 367#ifdef _WIN32 368 if (outFd == STDOUT_FILENO) { 369 if (_setmode(STDOUT_FILENO, old_stdout_mode) == -1) { 370 fatal_errno("could not restore stdout mode"); 371 } 372 } 373#endif 374 375 D("copy_to_file() finished after %lu bytes\n", total); 376 free(buf); 377} 378 379static void *stdin_read_thread(void *x) 380{ 381 int fd, fdi; 382 unsigned char buf[1024]; 383 int r, n; 384 int state = 0; 385 386 int *fds = (int*) x; 387 fd = fds[0]; 388 fdi = fds[1]; 389 free(fds); 390 391 for(;;) { 392 /* fdi is really the client's stdin, so use read, not adb_read here */ 393 D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi); 394 r = unix_read(fdi, buf, 1024); 395 D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi); 396 if(r == 0) break; 397 if(r < 0) { 398 if(errno == EINTR) continue; 399 break; 400 } 401 for(n = 0; n < r; n++){ 402 switch(buf[n]) { 403 case '\n': 404 state = 1; 405 break; 406 case '\r': 407 state = 1; 408 break; 409 case '~': 410 if(state == 1) state++; 411 break; 412 case '.': 413 if(state == 2) { 414 fprintf(stderr,"\n* disconnect *\n"); 415 stdin_raw_restore(fdi); 416 exit(0); 417 } 418 default: 419 state = 0; 420 } 421 } 422 r = adb_write(fd, buf, r); 423 if(r <= 0) { 424 break; 425 } 426 } 427 return 0; 428} 429 430static int interactive_shell() { 431 int fdi; 432 433 std::string error; 434 int fd = adb_connect("shell:", &error); 435 if (fd < 0) { 436 fprintf(stderr,"error: %s\n", error.c_str()); 437 return 1; 438 } 439 fdi = 0; //dup(0); 440 441 int* fds = reinterpret_cast<int*>(malloc(sizeof(int) * 2)); 442 if (fds == nullptr) { 443 fprintf(stderr, "couldn't allocate fds array: %s\n", strerror(errno)); 444 return 1; 445 } 446 447 fds[0] = fd; 448 fds[1] = fdi; 449 450 stdin_raw_init(fdi); 451 452 adb_thread_create(stdin_read_thread, fds); 453 read_and_dump(fd); 454 stdin_raw_restore(fdi); 455 return 0; 456} 457 458 459static std::string format_host_command(const char* command, TransportType type, const char* serial) { 460 if (serial) { 461 return android::base::StringPrintf("host-serial:%s:%s", serial, command); 462 } 463 464 const char* prefix = "host"; 465 if (type == kTransportUsb) { 466 prefix = "host-usb"; 467 } else if (type == kTransportLocal) { 468 prefix = "host-local"; 469 } 470 return android::base::StringPrintf("%s:%s", prefix, command); 471} 472 473static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 474 bool show_progress) 475{ 476 std::string error; 477 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 478 if (fd < 0) { 479 fprintf(stderr,"error: %s\n", error.c_str()); 480 return -1; 481 } 482 483 int opt = CHUNK_SIZE; 484 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 485 486 unsigned total = sz; 487 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 488 489 if (show_progress) { 490 char *x = strrchr(service, ':'); 491 if(x) service = x + 1; 492 } 493 494 while (sz > 0) { 495 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 496 if (!WriteFdExactly(fd, ptr, xfer)) { 497 std::string error; 498 adb_status(fd, &error); 499 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 500 return -1; 501 } 502 sz -= xfer; 503 ptr += xfer; 504 if (show_progress) { 505 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 506 fflush(stdout); 507 } 508 } 509 if (show_progress) { 510 printf("\n"); 511 } 512 513 if (!adb_status(fd, &error)) { 514 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 515 return -1; 516 } 517 518 adb_close(fd); 519 return 0; 520} 521 522#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 523 524/* 525 * The sideload-host protocol serves the data in a file (given on the 526 * command line) to the client, using a simple protocol: 527 * 528 * - The connect message includes the total number of bytes in the 529 * file and a block size chosen by us. 530 * 531 * - The other side sends the desired block number as eight decimal 532 * digits (eg "00000023" for block 23). Blocks are numbered from 533 * zero. 534 * 535 * - We send back the data of the requested block. The last block is 536 * likely to be partial; when the last block is requested we only 537 * send the part of the block that exists, it's not padded up to the 538 * block size. 539 * 540 * - When the other side sends "DONEDONE" instead of a block number, 541 * we hang up. 542 */ 543static int adb_sideload_host(const char* fn) { 544 unsigned sz; 545 size_t xfer = 0; 546 int status; 547 int last_percent = -1; 548 int opt = SIDELOAD_HOST_BLOCK_SIZE; 549 550 printf("loading: '%s'", fn); 551 fflush(stdout); 552 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 553 if (data == 0) { 554 printf("\n"); 555 fprintf(stderr, "* cannot read '%s' *\n", fn); 556 return -1; 557 } 558 559 std::string service = 560 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 561 std::string error; 562 int fd = adb_connect(service, &error); 563 if (fd < 0) { 564 // Try falling back to the older sideload method. Maybe this 565 // is an older device that doesn't support sideload-host. 566 printf("\n"); 567 status = adb_download_buffer("sideload", fn, data, sz, true); 568 goto done; 569 } 570 571 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 572 573 while (true) { 574 char buf[9]; 575 if (!ReadFdExactly(fd, buf, 8)) { 576 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 577 status = -1; 578 goto done; 579 } 580 buf[8] = '\0'; 581 582 if (strcmp("DONEDONE", buf) == 0) { 583 status = 0; 584 break; 585 } 586 587 int block = strtol(buf, NULL, 10); 588 589 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 590 if (offset >= sz) { 591 fprintf(stderr, "* attempt to read block %d past end\n", block); 592 status = -1; 593 goto done; 594 } 595 uint8_t* start = data + offset; 596 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 597 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 598 if (offset_end > sz) { 599 to_write = sz - offset; 600 } 601 602 if(!WriteFdExactly(fd, start, to_write)) { 603 adb_status(fd, &error); 604 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 605 status = -1; 606 goto done; 607 } 608 xfer += to_write; 609 610 // For normal OTA packages, we expect to transfer every byte 611 // twice, plus a bit of overhead (one read during 612 // verification, one read of each byte for installation, plus 613 // extra access to things like the zip central directory). 614 // This estimate of the completion becomes 100% when we've 615 // transferred ~2.13 (=100/47) times the package size. 616 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 617 if (percent != last_percent) { 618 printf("\rserving: '%s' (~%d%%) ", fn, percent); 619 fflush(stdout); 620 last_percent = percent; 621 } 622 } 623 624 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 625 626 done: 627 if (fd >= 0) adb_close(fd); 628 free(data); 629 return status; 630} 631 632/** 633 * Run ppp in "notty" mode against a resource listed as the first parameter 634 * eg: 635 * 636 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 637 * 638 */ 639static int ppp(int argc, const char** argv) { 640#if defined(_WIN32) 641 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 642 return -1; 643#else 644 if (argc < 2) { 645 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 646 argv[0]); 647 648 return 1; 649 } 650 651 const char* adb_service_name = argv[1]; 652 std::string error; 653 int fd = adb_connect(adb_service_name, &error); 654 if (fd < 0) { 655 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 656 adb_service_name, error.c_str()); 657 return 1; 658 } 659 660 pid_t pid = fork(); 661 662 if (pid < 0) { 663 perror("from fork()"); 664 return 1; 665 } else if (pid == 0) { 666 int err; 667 int i; 668 const char **ppp_args; 669 670 // copy args 671 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 672 ppp_args[0] = "pppd"; 673 for (i = 2 ; i < argc ; i++) { 674 //argv[2] and beyond become ppp_args[1] and beyond 675 ppp_args[i - 1] = argv[i]; 676 } 677 ppp_args[i-1] = NULL; 678 679 // child side 680 681 dup2(fd, STDIN_FILENO); 682 dup2(fd, STDOUT_FILENO); 683 adb_close(STDERR_FILENO); 684 adb_close(fd); 685 686 err = execvp("pppd", (char * const *)ppp_args); 687 688 if (err < 0) { 689 perror("execing pppd"); 690 } 691 exit(-1); 692 } else { 693 // parent side 694 695 adb_close(fd); 696 return 0; 697 } 698#endif /* !defined(_WIN32) */ 699} 700 701static bool wait_for_device(const char* service, TransportType t, const char* serial) { 702 // Was the caller vague about what they'd like us to wait for? 703 // If so, check they weren't more specific in their choice of transport type. 704 if (strcmp(service, "wait-for-device") == 0) { 705 if (t == kTransportUsb) { 706 service = "wait-for-usb"; 707 } else if (t == kTransportLocal) { 708 service = "wait-for-local"; 709 } else { 710 service = "wait-for-any"; 711 } 712 } 713 714 std::string cmd = format_host_command(service, t, serial); 715 return adb_command(cmd); 716} 717 718static int send_shell_command(TransportType transport_type, const char* serial, 719 const std::string& command) { 720 int fd; 721 while (true) { 722 std::string error; 723 fd = adb_connect(command, &error); 724 if (fd >= 0) { 725 break; 726 } 727 fprintf(stderr,"- waiting for device -\n"); 728 adb_sleep_ms(1000); 729 wait_for_device("wait-for-device", transport_type, serial); 730 } 731 732 read_and_dump(fd); 733 int rc = adb_close(fd); 734 if (rc) { 735 perror("close"); 736 } 737 return rc; 738} 739 740static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 741 char* log_tags = getenv("ANDROID_LOG_TAGS"); 742 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 743 744 std::string cmd = "shell:export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 745 746 if (!strcmp(argv[0], "longcat")) { 747 cmd += " -v long"; 748 } 749 750 --argc; 751 ++argv; 752 while (argc-- > 0) { 753 cmd += " " + escape_arg(*argv++); 754 } 755 756 return send_shell_command(transport, serial, cmd); 757} 758 759static int mkdirs(const char *path) 760{ 761 int ret; 762 char *x = (char *)path + 1; 763 764 for(;;) { 765 x = adb_dirstart(x); 766 if(x == 0) return 0; 767 *x = 0; 768 ret = adb_mkdir(path, 0775); 769 *x = OS_PATH_SEPARATOR; 770 if((ret < 0) && (errno != EEXIST)) { 771 return ret; 772 } 773 x++; 774 } 775 return 0; 776} 777 778static int backup(int argc, const char** argv) { 779 const char* filename = "./backup.ab"; 780 781 /* find, extract, and use any -f argument */ 782 for (int i = 1; i < argc; i++) { 783 if (!strcmp("-f", argv[i])) { 784 if (i == argc-1) { 785 fprintf(stderr, "adb: -f passed with no filename\n"); 786 return usage(); 787 } 788 filename = argv[i+1]; 789 for (int j = i+2; j <= argc; ) { 790 argv[i++] = argv[j++]; 791 } 792 argc -= 2; 793 argv[argc] = NULL; 794 } 795 } 796 797 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 798 if (argc < 2) return usage(); 799 800 adb_unlink(filename); 801 mkdirs(filename); 802 int outFd = adb_creat(filename, 0640); 803 if (outFd < 0) { 804 fprintf(stderr, "adb: unable to open file %s\n", filename); 805 return -1; 806 } 807 808 std::string cmd = "backup:"; 809 --argc; 810 ++argv; 811 while (argc-- > 0) { 812 cmd += " " + escape_arg(*argv++); 813 } 814 815 D("backup. filename=%s cmd=%s\n", filename, cmd.c_str()); 816 std::string error; 817 int fd = adb_connect(cmd, &error); 818 if (fd < 0) { 819 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 820 adb_close(outFd); 821 return -1; 822 } 823 824 printf("Now unlock your device and confirm the backup operation.\n"); 825 copy_to_file(fd, outFd); 826 827 adb_close(fd); 828 adb_close(outFd); 829 return 0; 830} 831 832static int restore(int argc, const char** argv) { 833 if (argc != 2) return usage(); 834 835 const char* filename = argv[1]; 836 int tarFd = adb_open(filename, O_RDONLY); 837 if (tarFd < 0) { 838 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 839 return -1; 840 } 841 842 std::string error; 843 int fd = adb_connect("restore:", &error); 844 if (fd < 0) { 845 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 846 adb_close(tarFd); 847 return -1; 848 } 849 850 printf("Now unlock your device and confirm the restore operation.\n"); 851 copy_to_file(tarFd, fd); 852 853 adb_close(fd); 854 adb_close(tarFd); 855 return 0; 856} 857 858/* <hint> may be: 859 * - A simple product name 860 * e.g., "sooner" 861 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 862 * e.g., "out/target/product/sooner" 863 * - An absolute path to the PRODUCT_OUT dir 864 * e.g., "/src/device/out/target/product/sooner" 865 * 866 * Given <hint>, try to construct an absolute path to the 867 * ANDROID_PRODUCT_OUT dir. 868 */ 869static std::string find_product_out_path(const char* hint) { 870 if (hint == NULL || hint[0] == '\0') { 871 return ""; 872 } 873 874 // If it's already absolute, don't bother doing any work. 875 if (adb_is_absolute_host_path(hint)) { 876 return hint; 877 } 878 879 // If there are any slashes in it, assume it's a relative path; 880 // make it absolute. 881 if (adb_dirstart(hint) != nullptr) { 882 std::string cwd; 883 if (!getcwd(&cwd)) { 884 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 885 return ""; 886 } 887 return android::base::StringPrintf("%s%s%s", cwd.c_str(), OS_PATH_SEPARATOR_STR, hint); 888 } 889 890 // It's a string without any slashes. Try to do something with it. 891 // 892 // Try to find the root of the build tree, and build a PRODUCT_OUT 893 // path from there. 894 char* top = getenv("ANDROID_BUILD_TOP"); 895 if (top == nullptr) { 896 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 897 return ""; 898 } 899 900 std::string path = top; 901 path += OS_PATH_SEPARATOR_STR; 902 path += "out"; 903 path += OS_PATH_SEPARATOR_STR; 904 path += "target"; 905 path += OS_PATH_SEPARATOR_STR; 906 path += "product"; 907 path += OS_PATH_SEPARATOR_STR; 908 path += hint; 909 if (!directory_exists(path)) { 910 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 911 "\"%s\" doesn't exist\n", hint, path.c_str()); 912 return ""; 913 } 914 return path; 915} 916 917static void parse_push_pull_args(const char **arg, int narg, char const **path1, 918 char const **path2, int *show_progress, 919 int *copy_attrs) { 920 *show_progress = 0; 921 *copy_attrs = 0; 922 923 while (narg > 0) { 924 if (!strcmp(*arg, "-p")) { 925 *show_progress = 1; 926 } else if (!strcmp(*arg, "-a")) { 927 *copy_attrs = 1; 928 } else { 929 break; 930 } 931 ++arg; 932 --narg; 933 } 934 935 if (narg > 0) { 936 *path1 = *arg; 937 ++arg; 938 --narg; 939 } 940 941 if (narg > 0) { 942 *path2 = *arg; 943 } 944} 945 946static int adb_connect_command(const std::string& command) { 947 std::string error; 948 int fd = adb_connect(command, &error); 949 if (fd < 0) { 950 fprintf(stderr, "error: %s\n", error.c_str()); 951 return 1; 952 } 953 read_and_dump(fd); 954 adb_close(fd); 955 return 0; 956} 957 958static int adb_query_command(const std::string& command) { 959 std::string result; 960 std::string error; 961 if (!adb_query(command, &result, &error)) { 962 fprintf(stderr, "error: %s\n", error.c_str()); 963 return 1; 964 } 965 printf("%s\n", result.c_str()); 966 return 0; 967} 968 969int adb_commandline(int argc, const char **argv) { 970 int no_daemon = 0; 971 int is_daemon = 0; 972 int is_server = 0; 973 int r; 974 TransportType transport_type = kTransportAny; 975 976 // If defined, this should be an absolute path to 977 // the directory containing all of the various system images 978 // for a particular product. If not defined, and the adb 979 // command requires this information, then the user must 980 // specify the path using "-p". 981 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 982 if (ANDROID_PRODUCT_OUT != nullptr) { 983 gProductOutPath = ANDROID_PRODUCT_OUT; 984 } 985 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 986 987 const char* serial = getenv("ANDROID_SERIAL"); 988 989 /* Validate and assign the server port */ 990 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 991 int server_port = DEFAULT_ADB_PORT; 992 if (server_port_str && strlen(server_port_str) > 0) { 993 server_port = (int) strtol(server_port_str, NULL, 0); 994 if (server_port <= 0 || server_port > 65535) { 995 fprintf(stderr, 996 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n", 997 server_port_str); 998 return usage(); 999 } 1000 } 1001 1002 /* modifiers and flags */ 1003 while (argc > 0) { 1004 if (!strcmp(argv[0],"server")) { 1005 is_server = 1; 1006 } else if (!strcmp(argv[0],"nodaemon")) { 1007 no_daemon = 1; 1008 } else if (!strcmp(argv[0], "fork-server")) { 1009 /* this is a special flag used only when the ADB client launches the ADB Server */ 1010 is_daemon = 1; 1011 } else if (!strncmp(argv[0], "-p", 2)) { 1012 const char *product = NULL; 1013 if (argv[0][2] == '\0') { 1014 if (argc < 2) return usage(); 1015 product = argv[1]; 1016 argc--; 1017 argv++; 1018 } else { 1019 product = argv[0] + 2; 1020 } 1021 gProductOutPath = find_product_out_path(product); 1022 if (gProductOutPath.empty()) { 1023 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1024 return usage(); 1025 } 1026 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1027 if (isdigit(argv[0][2])) { 1028 serial = argv[0] + 2; 1029 } else { 1030 if (argc < 2 || argv[0][2] != '\0') return usage(); 1031 serial = argv[1]; 1032 argc--; 1033 argv++; 1034 } 1035 } else if (!strcmp(argv[0],"-d")) { 1036 transport_type = kTransportUsb; 1037 } else if (!strcmp(argv[0],"-e")) { 1038 transport_type = kTransportLocal; 1039 } else if (!strcmp(argv[0],"-a")) { 1040 gListenAll = 1; 1041 } else if (!strncmp(argv[0], "-H", 2)) { 1042 const char *hostname = NULL; 1043 if (argv[0][2] == '\0') { 1044 if (argc < 2) return usage(); 1045 hostname = argv[1]; 1046 argc--; 1047 argv++; 1048 } else { 1049 hostname = argv[0] + 2; 1050 } 1051 adb_set_tcp_name(hostname); 1052 1053 } else if (!strncmp(argv[0], "-P", 2)) { 1054 if (argv[0][2] == '\0') { 1055 if (argc < 2) return usage(); 1056 server_port_str = argv[1]; 1057 argc--; 1058 argv++; 1059 } else { 1060 server_port_str = argv[0] + 2; 1061 } 1062 if (strlen(server_port_str) > 0) { 1063 server_port = (int) strtol(server_port_str, NULL, 0); 1064 if (server_port <= 0 || server_port > 65535) { 1065 fprintf(stderr, 1066 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1067 server_port_str); 1068 return usage(); 1069 } 1070 } else { 1071 fprintf(stderr, 1072 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1073 return usage(); 1074 } 1075 } else { 1076 /* out of recognized modifiers and flags */ 1077 break; 1078 } 1079 argc--; 1080 argv++; 1081 } 1082 1083 adb_set_transport(transport_type, serial); 1084 adb_set_tcp_specifics(server_port); 1085 1086 if (is_server) { 1087 if (no_daemon || is_daemon) { 1088 r = adb_main(is_daemon, server_port); 1089 } else { 1090 r = launch_server(server_port); 1091 } 1092 if (r) { 1093 fprintf(stderr,"* could not start server *\n"); 1094 } 1095 return r; 1096 } 1097 1098 if (argc == 0) { 1099 return usage(); 1100 } 1101 1102 /* handle wait-for-* prefix */ 1103 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1104 const char* service = argv[0]; 1105 1106 if (!wait_for_device(service, transport_type, serial)) { 1107 return 1; 1108 } 1109 1110 // Allow a command to be run after wait-for-device, 1111 // e.g. 'adb wait-for-device shell'. 1112 if (argc == 1) { 1113 return 0; 1114 } 1115 1116 /* Fall through */ 1117 argc--; 1118 argv++; 1119 } 1120 1121 /* adb_connect() commands */ 1122 if (!strcmp(argv[0], "devices")) { 1123 const char *listopt; 1124 if (argc < 2) { 1125 listopt = ""; 1126 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1127 listopt = argv[1]; 1128 } else { 1129 fprintf(stderr, "Usage: adb devices [-l]\n"); 1130 return 1; 1131 } 1132 1133 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1134 printf("List of devices attached\n"); 1135 return adb_query_command(query); 1136 } 1137 else if (!strcmp(argv[0], "connect")) { 1138 if (argc != 2) { 1139 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1140 return 1; 1141 } 1142 1143 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1144 return adb_query_command(query); 1145 } 1146 else if (!strcmp(argv[0], "disconnect")) { 1147 if (argc > 2) { 1148 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1149 return 1; 1150 } 1151 1152 std::string query = android::base::StringPrintf("host:disconnect:%s", 1153 (argc == 2) ? argv[1] : ""); 1154 return adb_query_command(query); 1155 } 1156 else if (!strcmp(argv[0], "emu")) { 1157 return adb_send_emulator_command(argc, argv, serial); 1158 } 1159 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1160 char h = (argv[0][0] == 'h'); 1161 1162 if (h) { 1163 printf("\x1b[41;33m"); 1164 fflush(stdout); 1165 } 1166 1167 if (argc < 2) { 1168 D("starting interactive shell\n"); 1169 r = interactive_shell(); 1170 if (h) { 1171 printf("\x1b[0m"); 1172 fflush(stdout); 1173 } 1174 return r; 1175 } 1176 1177 std::string cmd = "shell:"; 1178 --argc; 1179 ++argv; 1180 while (argc-- > 0) { 1181 // We don't escape here, just like ssh(1). http://b/20564385. 1182 cmd += *argv++; 1183 if (*argv) cmd += " "; 1184 } 1185 1186 while (true) { 1187 D("interactive shell loop. cmd=%s\n", cmd.c_str()); 1188 std::string error; 1189 int fd = adb_connect(cmd, &error); 1190 int r; 1191 if (fd >= 0) { 1192 D("about to read_and_dump(fd=%d)\n", fd); 1193 read_and_dump(fd); 1194 D("read_and_dump() done.\n"); 1195 adb_close(fd); 1196 r = 0; 1197 } else { 1198 fprintf(stderr,"error: %s\n", error.c_str()); 1199 r = -1; 1200 } 1201 1202 if (h) { 1203 printf("\x1b[0m"); 1204 fflush(stdout); 1205 } 1206 D("interactive shell loop. return r=%d\n", r); 1207 return r; 1208 } 1209 } 1210 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1211 int exec_in = !strcmp(argv[0], "exec-in"); 1212 1213 std::string cmd = "exec:"; 1214 cmd += argv[1]; 1215 argc -= 2; 1216 argv += 2; 1217 while (argc-- > 0) { 1218 cmd += " " + escape_arg(*argv++); 1219 } 1220 1221 std::string error; 1222 int fd = adb_connect(cmd, &error); 1223 if (fd < 0) { 1224 fprintf(stderr, "error: %s\n", error.c_str()); 1225 return -1; 1226 } 1227 1228 if (exec_in) { 1229 copy_to_file(STDIN_FILENO, fd); 1230 } else { 1231 copy_to_file(fd, STDOUT_FILENO); 1232 } 1233 1234 adb_close(fd); 1235 return 0; 1236 } 1237 else if (!strcmp(argv[0], "kill-server")) { 1238 std::string error; 1239 int fd = _adb_connect("host:kill", &error); 1240 if (fd == -1) { 1241 fprintf(stderr,"* server not running *\n"); 1242 return 1; 1243 } 1244 return 0; 1245 } 1246 else if (!strcmp(argv[0], "sideload")) { 1247 if (argc != 2) return usage(); 1248 if (adb_sideload_host(argv[1])) { 1249 return 1; 1250 } else { 1251 return 0; 1252 } 1253 } 1254 else if (!strcmp(argv[0], "remount") || 1255 !strcmp(argv[0], "reboot") || 1256 !strcmp(argv[0], "reboot-bootloader") || 1257 !strcmp(argv[0], "tcpip") || 1258 !strcmp(argv[0], "usb") || 1259 !strcmp(argv[0], "root") || 1260 !strcmp(argv[0], "unroot") || 1261 !strcmp(argv[0], "disable-verity") || 1262 !strcmp(argv[0], "enable-verity")) { 1263 std::string command; 1264 if (!strcmp(argv[0], "reboot-bootloader")) { 1265 command = "reboot:bootloader"; 1266 } else if (argc > 1) { 1267 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1268 } else { 1269 command = android::base::StringPrintf("%s:", argv[0]); 1270 } 1271 return adb_connect_command(command); 1272 } 1273 else if (!strcmp(argv[0], "bugreport")) { 1274 if (argc != 1) return usage(); 1275 return send_shell_command(transport_type, serial, "shell:bugreport"); 1276 } 1277 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1278 bool reverse = !strcmp(argv[0], "reverse"); 1279 ++argv; 1280 --argc; 1281 if (argc < 1) return usage(); 1282 1283 // Determine the <host-prefix> for this command. 1284 std::string host_prefix; 1285 if (reverse) { 1286 host_prefix = "reverse"; 1287 } else { 1288 if (serial) { 1289 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1290 } else if (transport_type == kTransportUsb) { 1291 host_prefix = "host-usb"; 1292 } else if (transport_type == kTransportLocal) { 1293 host_prefix = "host-local"; 1294 } else { 1295 host_prefix = "host"; 1296 } 1297 } 1298 1299 std::string cmd; 1300 if (strcmp(argv[0], "--list") == 0) { 1301 if (argc != 1) return usage(); 1302 return adb_query_command(host_prefix + ":list-forward"); 1303 } else if (strcmp(argv[0], "--remove-all") == 0) { 1304 if (argc != 1) return usage(); 1305 cmd = host_prefix + ":killforward-all"; 1306 } else if (strcmp(argv[0], "--remove") == 0) { 1307 // forward --remove <local> 1308 if (argc != 2) return usage(); 1309 cmd = host_prefix + ":killforward:" + argv[1]; 1310 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1311 // forward --no-rebind <local> <remote> 1312 if (argc != 3) return usage(); 1313 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1314 } else { 1315 // forward <local> <remote> 1316 if (argc != 2) return usage(); 1317 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1318 } 1319 1320 return adb_command(cmd) ? 0 : 1; 1321 } 1322 /* do_sync_*() commands */ 1323 else if (!strcmp(argv[0], "ls")) { 1324 if (argc != 2) return usage(); 1325 return do_sync_ls(argv[1]); 1326 } 1327 else if (!strcmp(argv[0], "push")) { 1328 int show_progress = 0; 1329 int copy_attrs = 0; // unused 1330 const char* lpath = NULL, *rpath = NULL; 1331 1332 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1333 1334 if ((lpath != NULL) && (rpath != NULL)) { 1335 return do_sync_push(lpath, rpath, show_progress); 1336 } 1337 1338 return usage(); 1339 } 1340 else if (!strcmp(argv[0], "pull")) { 1341 int show_progress = 0; 1342 int copy_attrs = 0; 1343 const char* rpath = NULL, *lpath = "."; 1344 1345 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1346 1347 if (rpath != NULL) { 1348 return do_sync_pull(rpath, lpath, show_progress, copy_attrs); 1349 } 1350 1351 return usage(); 1352 } 1353 else if (!strcmp(argv[0], "install")) { 1354 if (argc < 2) return usage(); 1355 return install_app(transport_type, serial, argc, argv); 1356 } 1357 else if (!strcmp(argv[0], "install-multiple")) { 1358 if (argc < 2) return usage(); 1359 return install_multiple_app(transport_type, serial, argc, argv); 1360 } 1361 else if (!strcmp(argv[0], "uninstall")) { 1362 if (argc < 2) return usage(); 1363 return uninstall_app(transport_type, serial, argc, argv); 1364 } 1365 else if (!strcmp(argv[0], "sync")) { 1366 std::string src; 1367 bool list_only = false; 1368 if (argc < 2) { 1369 // No local path was specified. 1370 src = ""; 1371 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1372 list_only = true; 1373 if (argc == 3) { 1374 src = argv[2]; 1375 } else { 1376 src = ""; 1377 } 1378 } else if (argc == 2) { 1379 // A local path or "android"/"data" arg was specified. 1380 src = argv[1]; 1381 } else { 1382 return usage(); 1383 } 1384 1385 if (src != "" && 1386 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1387 return usage(); 1388 } 1389 1390 std::string system_src_path = product_file("system"); 1391 std::string data_src_path = product_file("data"); 1392 std::string vendor_src_path = product_file("vendor"); 1393 std::string oem_src_path = product_file("oem"); 1394 1395 int rc = 0; 1396 if (rc == 0 && (src.empty() || src == "system")) { 1397 rc = do_sync_sync(system_src_path, "/system", list_only); 1398 } 1399 if (rc == 0 && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1400 rc = do_sync_sync(vendor_src_path, "/vendor", list_only); 1401 } 1402 if (rc == 0 && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1403 rc = do_sync_sync(oem_src_path, "/oem", list_only); 1404 } 1405 if (rc == 0 && (src.empty() || src == "data")) { 1406 rc = do_sync_sync(data_src_path, "/data", list_only); 1407 } 1408 return rc; 1409 } 1410 /* passthrough commands */ 1411 else if (!strcmp(argv[0],"get-state") || 1412 !strcmp(argv[0],"get-serialno") || 1413 !strcmp(argv[0],"get-devpath")) 1414 { 1415 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1416 } 1417 /* other commands */ 1418 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1419 return logcat(transport_type, serial, argc, argv); 1420 } 1421 else if (!strcmp(argv[0],"ppp")) { 1422 return ppp(argc, argv); 1423 } 1424 else if (!strcmp(argv[0], "start-server")) { 1425 std::string error; 1426 return adb_connect("host:start-server", &error); 1427 } 1428 else if (!strcmp(argv[0], "backup")) { 1429 return backup(argc, argv); 1430 } 1431 else if (!strcmp(argv[0], "restore")) { 1432 return restore(argc, argv); 1433 } 1434 else if (!strcmp(argv[0], "keygen")) { 1435 if (argc < 2) return usage(); 1436 return adb_auth_keygen(argv[1]); 1437 } 1438 else if (!strcmp(argv[0], "jdwp")) { 1439 return adb_connect_command("jdwp"); 1440 } 1441 /* "adb /?" is a common idiom under Windows */ 1442 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1443 help(); 1444 return 0; 1445 } 1446 else if (!strcmp(argv[0], "version")) { 1447 version(stdout); 1448 return 0; 1449 } 1450 1451 usage(); 1452 return 1; 1453} 1454 1455static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1456 std::string cmd = "shell:pm"; 1457 1458 while (argc-- > 0) { 1459 cmd += " " + escape_arg(*argv++); 1460 } 1461 1462 return send_shell_command(transport, serial, cmd); 1463} 1464 1465static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1466 /* if the user choose the -k option, we refuse to do it until devices are 1467 out with the option to uninstall the remaining data somehow (adb/ui) */ 1468 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1469 { 1470 printf( 1471 "The -k option uninstalls the application while retaining the data/cache.\n" 1472 "At the moment, there is no way to remove the remaining data.\n" 1473 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1474 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1475 return -1; 1476 } 1477 1478 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1479 return pm_command(transport, serial, argc, argv); 1480} 1481 1482static int delete_file(TransportType transport, const char* serial, char* filename) { 1483 std::string cmd = "shell:rm -f " + escape_arg(filename); 1484 return send_shell_command(transport, serial, cmd); 1485} 1486 1487static const char* get_basename(const char* filename) 1488{ 1489 const char* basename = adb_dirstop(filename); 1490 if (basename) { 1491 basename++; 1492 return basename; 1493 } else { 1494 return filename; 1495 } 1496} 1497 1498static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1499 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1500 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1501 const char* where = DATA_DEST; 1502 int i; 1503 struct stat sb; 1504 1505 for (i = 1; i < argc; i++) { 1506 if (!strcmp(argv[i], "-s")) { 1507 where = SD_DEST; 1508 } 1509 } 1510 1511 // Find last APK argument. 1512 // All other arguments passed through verbatim. 1513 int last_apk = -1; 1514 for (i = argc - 1; i >= 0; i--) { 1515 const char* file = argv[i]; 1516 char* dot = strrchr(file, '.'); 1517 if (dot && !strcasecmp(dot, ".apk")) { 1518 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1519 fprintf(stderr, "Invalid APK file: %s\n", file); 1520 return -1; 1521 } 1522 1523 last_apk = i; 1524 break; 1525 } 1526 } 1527 1528 if (last_apk == -1) { 1529 fprintf(stderr, "Missing APK file\n"); 1530 return -1; 1531 } 1532 1533 const char* apk_file = argv[last_apk]; 1534 char apk_dest[PATH_MAX]; 1535 snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file)); 1536 int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */); 1537 if (err) { 1538 goto cleanup_apk; 1539 } else { 1540 argv[last_apk] = apk_dest; /* destination name, not source location */ 1541 } 1542 1543 err = pm_command(transport, serial, argc, argv); 1544 1545cleanup_apk: 1546 delete_file(transport, serial, apk_dest); 1547 return err; 1548} 1549 1550static int install_multiple_app(TransportType transport, const char* serial, int argc, 1551 const char** argv) 1552{ 1553 int i; 1554 struct stat sb; 1555 uint64_t total_size = 0; 1556 1557 // Find all APK arguments starting at end. 1558 // All other arguments passed through verbatim. 1559 int first_apk = -1; 1560 for (i = argc - 1; i >= 0; i--) { 1561 const char* file = argv[i]; 1562 char* dot = strrchr(file, '.'); 1563 if (dot && !strcasecmp(dot, ".apk")) { 1564 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1565 fprintf(stderr, "Invalid APK file: %s\n", file); 1566 return -1; 1567 } 1568 1569 total_size += sb.st_size; 1570 first_apk = i; 1571 } else { 1572 break; 1573 } 1574 } 1575 1576 if (first_apk == -1) { 1577 fprintf(stderr, "Missing APK file\n"); 1578 return 1; 1579 } 1580 1581 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1582 for (i = 1; i < first_apk; i++) { 1583 cmd += " " + escape_arg(argv[i]); 1584 } 1585 1586 // Create install session 1587 std::string error; 1588 int fd = adb_connect(cmd, &error); 1589 if (fd < 0) { 1590 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1591 return -1; 1592 } 1593 char buf[BUFSIZ]; 1594 read_status_line(fd, buf, sizeof(buf)); 1595 adb_close(fd); 1596 1597 int session_id = -1; 1598 if (!strncmp("Success", buf, 7)) { 1599 char* start = strrchr(buf, '['); 1600 char* end = strrchr(buf, ']'); 1601 if (start && end) { 1602 *end = '\0'; 1603 session_id = strtol(start + 1, NULL, 10); 1604 } 1605 } 1606 if (session_id < 0) { 1607 fprintf(stderr, "Failed to create session\n"); 1608 fputs(buf, stderr); 1609 return -1; 1610 } 1611 1612 // Valid session, now stream the APKs 1613 int success = 1; 1614 for (i = first_apk; i < argc; i++) { 1615 const char* file = argv[i]; 1616 if (stat(file, &sb) == -1) { 1617 fprintf(stderr, "Failed to stat %s\n", file); 1618 success = 0; 1619 goto finalize_session; 1620 } 1621 1622 std::string cmd = android::base::StringPrintf( 1623 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1624 static_cast<uint64_t>(sb.st_size), session_id, i, get_basename(file)); 1625 1626 int localFd = adb_open(file, O_RDONLY); 1627 if (localFd < 0) { 1628 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1629 success = 0; 1630 goto finalize_session; 1631 } 1632 1633 std::string error; 1634 int remoteFd = adb_connect(cmd, &error); 1635 if (remoteFd < 0) { 1636 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1637 adb_close(localFd); 1638 success = 0; 1639 goto finalize_session; 1640 } 1641 1642 copy_to_file(localFd, remoteFd); 1643 read_status_line(remoteFd, buf, sizeof(buf)); 1644 1645 adb_close(localFd); 1646 adb_close(remoteFd); 1647 1648 if (strncmp("Success", buf, 7)) { 1649 fprintf(stderr, "Failed to write %s\n", file); 1650 fputs(buf, stderr); 1651 success = 0; 1652 goto finalize_session; 1653 } 1654 } 1655 1656finalize_session: 1657 // Commit session if we streamed everything okay; otherwise abandon 1658 std::string service = 1659 android::base::StringPrintf("exec:pm install-%s %d", 1660 success ? "commit" : "abandon", session_id); 1661 fd = adb_connect(service, &error); 1662 if (fd < 0) { 1663 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1664 return -1; 1665 } 1666 read_status_line(fd, buf, sizeof(buf)); 1667 adb_close(fd); 1668 1669 if (!strncmp("Success", buf, 7)) { 1670 fputs(buf, stderr); 1671 return 0; 1672 } else { 1673 fprintf(stderr, "Failed to finalize session\n"); 1674 fputs(buf, stderr); 1675 return -1; 1676 } 1677} 1678