commandline.cpp revision 47d67c96ec991ef1690b4c07188335cbc4bfa2aa
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 " adb shell - run remote shell interactively\n" 114 " adb shell <command> - run remote shell command\n" 115 " adb emu <command> - run emulator console command\n" 116 " adb logcat [ <filter-spec> ] - View device log\n" 117 " adb forward --list - list all forward socket connections.\n" 118 " the format is a list of lines with the following format:\n" 119 " <serial> \" \" <local> \" \" <remote> \"\\n\"\n" 120 " adb forward <local> <remote> - forward socket connections\n" 121 " forward specs are one of: \n" 122 " tcp:<port>\n" 123 " localabstract:<unix domain socket name>\n" 124 " localreserved:<unix domain socket name>\n" 125 " localfilesystem:<unix domain socket name>\n" 126 " dev:<character device name>\n" 127 " jdwp:<process pid> (remote only)\n" 128 " adb forward --no-rebind <local> <remote>\n" 129 " - same as 'adb forward <local> <remote>' but fails\n" 130 " if <local> is already forwarded\n" 131 " adb forward --remove <local> - remove a specific forward socket connection\n" 132 " adb forward --remove-all - remove all forward socket connections\n" 133 " adb reverse --list - list all reverse socket connections from device\n" 134 " adb reverse <remote> <local> - reverse socket connections\n" 135 " reverse specs are one of:\n" 136 " tcp:<port>\n" 137 " localabstract:<unix domain socket name>\n" 138 " localreserved:<unix domain socket name>\n" 139 " localfilesystem:<unix domain socket name>\n" 140 " adb reverse --norebind <remote> <local>\n" 141 " - same as 'adb reverse <remote> <local>' but fails\n" 142 " if <remote> is already reversed.\n" 143 " adb reverse --remove <remote>\n" 144 " - remove a specific reversed socket connection\n" 145 " adb reverse --remove-all - remove all reversed socket connections from device\n" 146 " adb jdwp - list PIDs of processes hosting a JDWP transport\n" 147 " adb install [-lrtsd] <file>\n" 148 " adb install-multiple [-lrtsdp] <file...>\n" 149 " - push this package file to the device and install it\n" 150 " (-l: forward lock application)\n" 151 " (-r: replace existing application)\n" 152 " (-t: allow test packages)\n" 153 " (-s: install application on sdcard)\n" 154 " (-d: allow version code downgrade)\n" 155 " (-p: partial application install)\n" 156 " adb uninstall [-k] <package> - remove this app package from the device\n" 157 " ('-k' means keep the data and cache directories)\n" 158 " adb bugreport - return all information from the device\n" 159 " that should be included in a bug report.\n" 160 "\n" 161 " adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n" 162 " - write an archive of the device's data to <file>.\n" 163 " If no -f option is supplied then the data is written\n" 164 " to \"backup.ab\" in the current directory.\n" 165 " (-apk|-noapk enable/disable backup of the .apks themselves\n" 166 " in the archive; the default is noapk.)\n" 167 " (-obb|-noobb enable/disable backup of any installed apk expansion\n" 168 " (aka .obb) files associated with each application; the default\n" 169 " is noobb.)\n" 170 " (-shared|-noshared enable/disable backup of the device's\n" 171 " shared storage / SD card contents; the default is noshared.)\n" 172 " (-all means to back up all installed applications)\n" 173 " (-system|-nosystem toggles whether -all automatically includes\n" 174 " system applications; the default is to include system apps)\n" 175 " (<packages...> is the list of applications to be backed up. If\n" 176 " the -all or -shared flags are passed, then the package\n" 177 " list is optional. Applications explicitly given on the\n" 178 " command line will be included even if -nosystem would\n" 179 " ordinarily cause them to be omitted.)\n" 180 "\n" 181 " adb restore <file> - restore device contents from the <file> backup archive\n" 182 "\n" 183 " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n" 184 " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n" 185 " adb keygen <file> - generate adb public/private key. The private key is stored in <file>,\n" 186 " and the public key is stored in <file>.pub. Any existing files\n" 187 " are overwritten.\n" 188 " adb help - show this help message\n" 189 " adb version - show version num\n" 190 "\n" 191 "scripting:\n" 192 " adb wait-for-device - block until device is online\n" 193 " adb start-server - ensure that there is a server running\n" 194 " adb kill-server - kill the server if it is running\n" 195 " adb get-state - prints: offline | bootloader | device\n" 196 " adb get-serialno - prints: <serial-number>\n" 197 " adb get-devpath - prints: <device-path>\n" 198 " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n" 199 " adb reboot [bootloader|recovery]\n" 200 " - reboots the device, optionally into the bootloader or recovery program.\n" 201 " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n" 202 " adb reboot sideload-auto-reboot\n" 203 " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n" 204 " adb sideload <file> - sideloads the given package\n" 205 " adb root - restarts the adbd daemon with root permissions\n" 206 " adb unroot - restarts the adbd daemon without root permissions\n" 207 " adb usb - restarts the adbd daemon listening on USB\n" 208 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port\n" 209 "\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 "environment 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 const 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 backup(int argc, const char** argv) { 760 const char* filename = "./backup.ab"; 761 762 /* find, extract, and use any -f argument */ 763 for (int i = 1; i < argc; i++) { 764 if (!strcmp("-f", argv[i])) { 765 if (i == argc-1) { 766 fprintf(stderr, "adb: -f passed with no filename\n"); 767 return usage(); 768 } 769 filename = argv[i+1]; 770 for (int j = i+2; j <= argc; ) { 771 argv[i++] = argv[j++]; 772 } 773 argc -= 2; 774 argv[argc] = NULL; 775 } 776 } 777 778 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 779 if (argc < 2) return usage(); 780 781 adb_unlink(filename); 782 mkdirs(filename); 783 int outFd = adb_creat(filename, 0640); 784 if (outFd < 0) { 785 fprintf(stderr, "adb: unable to open file %s\n", filename); 786 return -1; 787 } 788 789 std::string cmd = "backup:"; 790 --argc; 791 ++argv; 792 while (argc-- > 0) { 793 cmd += " " + escape_arg(*argv++); 794 } 795 796 D("backup. filename=%s cmd=%s\n", filename, cmd.c_str()); 797 std::string error; 798 int fd = adb_connect(cmd, &error); 799 if (fd < 0) { 800 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 801 adb_close(outFd); 802 return -1; 803 } 804 805 printf("Now unlock your device and confirm the backup operation.\n"); 806 copy_to_file(fd, outFd); 807 808 adb_close(fd); 809 adb_close(outFd); 810 return 0; 811} 812 813static int restore(int argc, const char** argv) { 814 if (argc != 2) return usage(); 815 816 const char* filename = argv[1]; 817 int tarFd = adb_open(filename, O_RDONLY); 818 if (tarFd < 0) { 819 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 820 return -1; 821 } 822 823 std::string error; 824 int fd = adb_connect("restore:", &error); 825 if (fd < 0) { 826 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 827 adb_close(tarFd); 828 return -1; 829 } 830 831 printf("Now unlock your device and confirm the restore operation.\n"); 832 copy_to_file(tarFd, fd); 833 834 adb_close(fd); 835 adb_close(tarFd); 836 return 0; 837} 838 839/* <hint> may be: 840 * - A simple product name 841 * e.g., "sooner" 842 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 843 * e.g., "out/target/product/sooner" 844 * - An absolute path to the PRODUCT_OUT dir 845 * e.g., "/src/device/out/target/product/sooner" 846 * 847 * Given <hint>, try to construct an absolute path to the 848 * ANDROID_PRODUCT_OUT dir. 849 */ 850static std::string find_product_out_path(const char* hint) { 851 if (hint == NULL || hint[0] == '\0') { 852 return ""; 853 } 854 855 // If it's already absolute, don't bother doing any work. 856 if (adb_is_absolute_host_path(hint)) { 857 return hint; 858 } 859 860 // If there are any slashes in it, assume it's a relative path; 861 // make it absolute. 862 if (adb_dirstart(hint) != std::string::npos) { 863 std::string cwd; 864 if (!getcwd(&cwd)) { 865 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 866 return ""; 867 } 868 return android::base::StringPrintf("%s%s%s", cwd.c_str(), OS_PATH_SEPARATOR_STR, hint); 869 } 870 871 // It's a string without any slashes. Try to do something with it. 872 // 873 // Try to find the root of the build tree, and build a PRODUCT_OUT 874 // path from there. 875 char* top = getenv("ANDROID_BUILD_TOP"); 876 if (top == nullptr) { 877 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 878 return ""; 879 } 880 881 std::string path = top; 882 path += OS_PATH_SEPARATOR_STR; 883 path += "out"; 884 path += OS_PATH_SEPARATOR_STR; 885 path += "target"; 886 path += OS_PATH_SEPARATOR_STR; 887 path += "product"; 888 path += OS_PATH_SEPARATOR_STR; 889 path += hint; 890 if (!directory_exists(path)) { 891 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 892 "\"%s\" doesn't exist\n", hint, path.c_str()); 893 return ""; 894 } 895 return path; 896} 897 898static void parse_push_pull_args(const char **arg, int narg, char const **path1, 899 char const **path2, int *show_progress, 900 int *copy_attrs) { 901 *show_progress = 0; 902 *copy_attrs = 0; 903 904 while (narg > 0) { 905 if (!strcmp(*arg, "-p")) { 906 *show_progress = 1; 907 } else if (!strcmp(*arg, "-a")) { 908 *copy_attrs = 1; 909 } else { 910 break; 911 } 912 ++arg; 913 --narg; 914 } 915 916 if (narg > 0) { 917 *path1 = *arg; 918 ++arg; 919 --narg; 920 } 921 922 if (narg > 0) { 923 *path2 = *arg; 924 } 925} 926 927static int adb_connect_command(const std::string& command) { 928 std::string error; 929 int fd = adb_connect(command, &error); 930 if (fd < 0) { 931 fprintf(stderr, "error: %s\n", error.c_str()); 932 return 1; 933 } 934 read_and_dump(fd); 935 adb_close(fd); 936 return 0; 937} 938 939static int adb_query_command(const std::string& command) { 940 std::string result; 941 std::string error; 942 if (!adb_query(command, &result, &error)) { 943 fprintf(stderr, "error: %s\n", error.c_str()); 944 return 1; 945 } 946 printf("%s\n", result.c_str()); 947 return 0; 948} 949 950int adb_commandline(int argc, const char **argv) { 951 int no_daemon = 0; 952 int is_daemon = 0; 953 int is_server = 0; 954 int r; 955 TransportType transport_type = kTransportAny; 956 957 // If defined, this should be an absolute path to 958 // the directory containing all of the various system images 959 // for a particular product. If not defined, and the adb 960 // command requires this information, then the user must 961 // specify the path using "-p". 962 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 963 if (ANDROID_PRODUCT_OUT != nullptr) { 964 gProductOutPath = ANDROID_PRODUCT_OUT; 965 } 966 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 967 968 const char* serial = getenv("ANDROID_SERIAL"); 969 970 /* Validate and assign the server port */ 971 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 972 int server_port = DEFAULT_ADB_PORT; 973 if (server_port_str && strlen(server_port_str) > 0) { 974 server_port = (int) strtol(server_port_str, NULL, 0); 975 if (server_port <= 0 || server_port > 65535) { 976 fprintf(stderr, 977 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n", 978 server_port_str); 979 return usage(); 980 } 981 } 982 983 /* modifiers and flags */ 984 while (argc > 0) { 985 if (!strcmp(argv[0],"server")) { 986 is_server = 1; 987 } else if (!strcmp(argv[0],"nodaemon")) { 988 no_daemon = 1; 989 } else if (!strcmp(argv[0], "fork-server")) { 990 /* this is a special flag used only when the ADB client launches the ADB Server */ 991 is_daemon = 1; 992 } else if (!strncmp(argv[0], "-p", 2)) { 993 const char *product = NULL; 994 if (argv[0][2] == '\0') { 995 if (argc < 2) return usage(); 996 product = argv[1]; 997 argc--; 998 argv++; 999 } else { 1000 product = argv[0] + 2; 1001 } 1002 gProductOutPath = find_product_out_path(product); 1003 if (gProductOutPath.empty()) { 1004 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1005 return usage(); 1006 } 1007 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1008 if (isdigit(argv[0][2])) { 1009 serial = argv[0] + 2; 1010 } else { 1011 if (argc < 2 || argv[0][2] != '\0') return usage(); 1012 serial = argv[1]; 1013 argc--; 1014 argv++; 1015 } 1016 } else if (!strcmp(argv[0],"-d")) { 1017 transport_type = kTransportUsb; 1018 } else if (!strcmp(argv[0],"-e")) { 1019 transport_type = kTransportLocal; 1020 } else if (!strcmp(argv[0],"-a")) { 1021 gListenAll = 1; 1022 } else if (!strncmp(argv[0], "-H", 2)) { 1023 const char *hostname = NULL; 1024 if (argv[0][2] == '\0') { 1025 if (argc < 2) return usage(); 1026 hostname = argv[1]; 1027 argc--; 1028 argv++; 1029 } else { 1030 hostname = argv[0] + 2; 1031 } 1032 adb_set_tcp_name(hostname); 1033 1034 } else if (!strncmp(argv[0], "-P", 2)) { 1035 if (argv[0][2] == '\0') { 1036 if (argc < 2) return usage(); 1037 server_port_str = argv[1]; 1038 argc--; 1039 argv++; 1040 } else { 1041 server_port_str = argv[0] + 2; 1042 } 1043 if (strlen(server_port_str) > 0) { 1044 server_port = (int) strtol(server_port_str, NULL, 0); 1045 if (server_port <= 0 || server_port > 65535) { 1046 fprintf(stderr, 1047 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1048 server_port_str); 1049 return usage(); 1050 } 1051 } else { 1052 fprintf(stderr, 1053 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1054 return usage(); 1055 } 1056 } else { 1057 /* out of recognized modifiers and flags */ 1058 break; 1059 } 1060 argc--; 1061 argv++; 1062 } 1063 1064 adb_set_transport(transport_type, serial); 1065 adb_set_tcp_specifics(server_port); 1066 1067 if (is_server) { 1068 if (no_daemon || is_daemon) { 1069 r = adb_main(is_daemon, server_port); 1070 } else { 1071 r = launch_server(server_port); 1072 } 1073 if (r) { 1074 fprintf(stderr,"* could not start server *\n"); 1075 } 1076 return r; 1077 } 1078 1079 if (argc == 0) { 1080 return usage(); 1081 } 1082 1083 /* handle wait-for-* prefix */ 1084 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1085 const char* service = argv[0]; 1086 1087 if (!wait_for_device(service, transport_type, serial)) { 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 if (argc == 1) { 1094 return 0; 1095 } 1096 1097 /* Fall through */ 1098 argc--; 1099 argv++; 1100 } 1101 1102 /* adb_connect() commands */ 1103 if (!strcmp(argv[0], "devices")) { 1104 const char *listopt; 1105 if (argc < 2) { 1106 listopt = ""; 1107 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1108 listopt = argv[1]; 1109 } else { 1110 fprintf(stderr, "Usage: adb devices [-l]\n"); 1111 return 1; 1112 } 1113 1114 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1115 printf("List of devices attached\n"); 1116 return adb_query_command(query); 1117 } 1118 else if (!strcmp(argv[0], "connect")) { 1119 if (argc != 2) { 1120 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1121 return 1; 1122 } 1123 1124 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1125 return adb_query_command(query); 1126 } 1127 else if (!strcmp(argv[0], "disconnect")) { 1128 if (argc > 2) { 1129 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1130 return 1; 1131 } 1132 1133 std::string query = android::base::StringPrintf("host:disconnect:%s", 1134 (argc == 2) ? argv[1] : ""); 1135 return adb_query_command(query); 1136 } 1137 else if (!strcmp(argv[0], "emu")) { 1138 return adb_send_emulator_command(argc, argv, serial); 1139 } 1140 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1141 char h = (argv[0][0] == 'h'); 1142 1143 if (h) { 1144 printf("\x1b[41;33m"); 1145 fflush(stdout); 1146 } 1147 1148 if (argc < 2) { 1149 D("starting interactive shell\n"); 1150 r = interactive_shell(); 1151 if (h) { 1152 printf("\x1b[0m"); 1153 fflush(stdout); 1154 } 1155 return r; 1156 } 1157 1158 std::string cmd = "shell:"; 1159 --argc; 1160 ++argv; 1161 while (argc-- > 0) { 1162 // We don't escape here, just like ssh(1). http://b/20564385. 1163 cmd += *argv++; 1164 if (*argv) cmd += " "; 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 (h) { 1184 printf("\x1b[0m"); 1185 fflush(stdout); 1186 } 1187 D("interactive shell loop. return r=%d\n", r); 1188 return r; 1189 } 1190 } 1191 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1192 int exec_in = !strcmp(argv[0], "exec-in"); 1193 1194 std::string cmd = "exec:"; 1195 cmd += argv[1]; 1196 argc -= 2; 1197 argv += 2; 1198 while (argc-- > 0) { 1199 cmd += " " + escape_arg(*argv++); 1200 } 1201 1202 std::string error; 1203 int fd = adb_connect(cmd, &error); 1204 if (fd < 0) { 1205 fprintf(stderr, "error: %s\n", error.c_str()); 1206 return -1; 1207 } 1208 1209 if (exec_in) { 1210 copy_to_file(STDIN_FILENO, fd); 1211 } else { 1212 copy_to_file(fd, STDOUT_FILENO); 1213 } 1214 1215 adb_close(fd); 1216 return 0; 1217 } 1218 else if (!strcmp(argv[0], "kill-server")) { 1219 std::string error; 1220 int fd = _adb_connect("host:kill", &error); 1221 if (fd == -1) { 1222 fprintf(stderr,"* server not running *\n"); 1223 return 1; 1224 } 1225 return 0; 1226 } 1227 else if (!strcmp(argv[0], "sideload")) { 1228 if (argc != 2) return usage(); 1229 if (adb_sideload_host(argv[1])) { 1230 return 1; 1231 } else { 1232 return 0; 1233 } 1234 } 1235 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1236 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1237 } 1238 else if (!strcmp(argv[0], "remount") || 1239 !strcmp(argv[0], "reboot") || 1240 !strcmp(argv[0], "reboot-bootloader") || 1241 !strcmp(argv[0], "usb") || 1242 !strcmp(argv[0], "root") || 1243 !strcmp(argv[0], "unroot") || 1244 !strcmp(argv[0], "disable-verity") || 1245 !strcmp(argv[0], "enable-verity")) { 1246 std::string command; 1247 if (!strcmp(argv[0], "reboot-bootloader")) { 1248 command = "reboot:bootloader"; 1249 } else if (argc > 1) { 1250 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1251 } else { 1252 command = android::base::StringPrintf("%s:", argv[0]); 1253 } 1254 return adb_connect_command(command); 1255 } 1256 else if (!strcmp(argv[0], "bugreport")) { 1257 if (argc != 1) return usage(); 1258 return send_shell_command(transport_type, serial, "shell:bugreport"); 1259 } 1260 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1261 bool reverse = !strcmp(argv[0], "reverse"); 1262 ++argv; 1263 --argc; 1264 if (argc < 1) return usage(); 1265 1266 // Determine the <host-prefix> for this command. 1267 std::string host_prefix; 1268 if (reverse) { 1269 host_prefix = "reverse"; 1270 } else { 1271 if (serial) { 1272 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1273 } else if (transport_type == kTransportUsb) { 1274 host_prefix = "host-usb"; 1275 } else if (transport_type == kTransportLocal) { 1276 host_prefix = "host-local"; 1277 } else { 1278 host_prefix = "host"; 1279 } 1280 } 1281 1282 std::string cmd; 1283 if (strcmp(argv[0], "--list") == 0) { 1284 if (argc != 1) return usage(); 1285 return adb_query_command(host_prefix + ":list-forward"); 1286 } else if (strcmp(argv[0], "--remove-all") == 0) { 1287 if (argc != 1) return usage(); 1288 cmd = host_prefix + ":killforward-all"; 1289 } else if (strcmp(argv[0], "--remove") == 0) { 1290 // forward --remove <local> 1291 if (argc != 2) return usage(); 1292 cmd = host_prefix + ":killforward:" + argv[1]; 1293 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1294 // forward --no-rebind <local> <remote> 1295 if (argc != 3) return usage(); 1296 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1297 } else { 1298 // forward <local> <remote> 1299 if (argc != 2) return usage(); 1300 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1301 } 1302 1303 return adb_command(cmd) ? 0 : 1; 1304 } 1305 /* do_sync_*() commands */ 1306 else if (!strcmp(argv[0], "ls")) { 1307 if (argc != 2) return usage(); 1308 return do_sync_ls(argv[1]); 1309 } 1310 else if (!strcmp(argv[0], "push")) { 1311 int show_progress = 0; 1312 int copy_attrs = 0; // unused 1313 const char* lpath = NULL, *rpath = NULL; 1314 1315 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1316 1317 if ((lpath != NULL) && (rpath != NULL)) { 1318 return do_sync_push(lpath, rpath, show_progress); 1319 } 1320 1321 return usage(); 1322 } 1323 else if (!strcmp(argv[0], "pull")) { 1324 int show_progress = 0; 1325 int copy_attrs = 0; 1326 const char* rpath = NULL, *lpath = "."; 1327 1328 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1329 1330 if (rpath != NULL) { 1331 return do_sync_pull(rpath, lpath, show_progress, copy_attrs); 1332 } 1333 1334 return usage(); 1335 } 1336 else if (!strcmp(argv[0], "install")) { 1337 if (argc < 2) return usage(); 1338 return install_app(transport_type, serial, argc, argv); 1339 } 1340 else if (!strcmp(argv[0], "install-multiple")) { 1341 if (argc < 2) return usage(); 1342 return install_multiple_app(transport_type, serial, argc, argv); 1343 } 1344 else if (!strcmp(argv[0], "uninstall")) { 1345 if (argc < 2) return usage(); 1346 return uninstall_app(transport_type, serial, argc, argv); 1347 } 1348 else if (!strcmp(argv[0], "sync")) { 1349 std::string src; 1350 bool list_only = false; 1351 if (argc < 2) { 1352 // No local path was specified. 1353 src = ""; 1354 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1355 list_only = true; 1356 if (argc == 3) { 1357 src = argv[2]; 1358 } else { 1359 src = ""; 1360 } 1361 } else if (argc == 2) { 1362 // A local path or "android"/"data" arg was specified. 1363 src = argv[1]; 1364 } else { 1365 return usage(); 1366 } 1367 1368 if (src != "" && 1369 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1370 return usage(); 1371 } 1372 1373 std::string system_src_path = product_file("system"); 1374 std::string data_src_path = product_file("data"); 1375 std::string vendor_src_path = product_file("vendor"); 1376 std::string oem_src_path = product_file("oem"); 1377 1378 int rc = 0; 1379 if (rc == 0 && (src.empty() || src == "system")) { 1380 rc = do_sync_sync(system_src_path, "/system", list_only); 1381 } 1382 if (rc == 0 && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1383 rc = do_sync_sync(vendor_src_path, "/vendor", list_only); 1384 } 1385 if (rc == 0 && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1386 rc = do_sync_sync(oem_src_path, "/oem", list_only); 1387 } 1388 if (rc == 0 && (src.empty() || src == "data")) { 1389 rc = do_sync_sync(data_src_path, "/data", list_only); 1390 } 1391 return rc; 1392 } 1393 /* passthrough commands */ 1394 else if (!strcmp(argv[0],"get-state") || 1395 !strcmp(argv[0],"get-serialno") || 1396 !strcmp(argv[0],"get-devpath")) 1397 { 1398 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1399 } 1400 /* other commands */ 1401 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1402 return logcat(transport_type, serial, argc, argv); 1403 } 1404 else if (!strcmp(argv[0],"ppp")) { 1405 return ppp(argc, argv); 1406 } 1407 else if (!strcmp(argv[0], "start-server")) { 1408 std::string error; 1409 return adb_connect("host:start-server", &error); 1410 } 1411 else if (!strcmp(argv[0], "backup")) { 1412 return backup(argc, argv); 1413 } 1414 else if (!strcmp(argv[0], "restore")) { 1415 return restore(argc, argv); 1416 } 1417 else if (!strcmp(argv[0], "keygen")) { 1418 if (argc < 2) return usage(); 1419 return adb_auth_keygen(argv[1]); 1420 } 1421 else if (!strcmp(argv[0], "jdwp")) { 1422 return adb_connect_command("jdwp"); 1423 } 1424 /* "adb /?" is a common idiom under Windows */ 1425 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1426 help(); 1427 return 0; 1428 } 1429 else if (!strcmp(argv[0], "version")) { 1430 version(stdout); 1431 return 0; 1432 } 1433 1434 usage(); 1435 return 1; 1436} 1437 1438static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1439 std::string cmd = "shell:pm"; 1440 1441 while (argc-- > 0) { 1442 cmd += " " + escape_arg(*argv++); 1443 } 1444 1445 return send_shell_command(transport, serial, cmd); 1446} 1447 1448static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1449 /* if the user choose the -k option, we refuse to do it until devices are 1450 out with the option to uninstall the remaining data somehow (adb/ui) */ 1451 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1452 { 1453 printf( 1454 "The -k option uninstalls the application while retaining the data/cache.\n" 1455 "At the moment, there is no way to remove the remaining data.\n" 1456 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1457 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1458 return -1; 1459 } 1460 1461 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1462 return pm_command(transport, serial, argc, argv); 1463} 1464 1465static int delete_file(TransportType transport, const char* serial, char* filename) { 1466 std::string cmd = "shell:rm -f " + escape_arg(filename); 1467 return send_shell_command(transport, serial, cmd); 1468} 1469 1470static const char* get_basename(const std::string& filename) 1471{ 1472 size_t base = adb_dirstop(filename); 1473 if (base != std::string::npos) { 1474 ++base; 1475 } else { 1476 base = 0; 1477 } 1478 return filename.c_str() + base; 1479} 1480 1481static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1482 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1483 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1484 const char* where = DATA_DEST; 1485 int i; 1486 struct stat sb; 1487 1488 for (i = 1; i < argc; i++) { 1489 if (!strcmp(argv[i], "-s")) { 1490 where = SD_DEST; 1491 } 1492 } 1493 1494 // Find last APK argument. 1495 // All other arguments passed through verbatim. 1496 int last_apk = -1; 1497 for (i = argc - 1; i >= 0; i--) { 1498 const char* file = argv[i]; 1499 const char* dot = strrchr(file, '.'); 1500 if (dot && !strcasecmp(dot, ".apk")) { 1501 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1502 fprintf(stderr, "Invalid APK file: %s\n", file); 1503 return -1; 1504 } 1505 1506 last_apk = i; 1507 break; 1508 } 1509 } 1510 1511 if (last_apk == -1) { 1512 fprintf(stderr, "Missing APK file\n"); 1513 return -1; 1514 } 1515 1516 const char* apk_file = argv[last_apk]; 1517 char apk_dest[PATH_MAX]; 1518 snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file)); 1519 int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */); 1520 if (err) { 1521 goto cleanup_apk; 1522 } else { 1523 argv[last_apk] = apk_dest; /* destination name, not source location */ 1524 } 1525 1526 err = pm_command(transport, serial, argc, argv); 1527 1528cleanup_apk: 1529 delete_file(transport, serial, apk_dest); 1530 return err; 1531} 1532 1533static int install_multiple_app(TransportType transport, const char* serial, int argc, 1534 const char** argv) 1535{ 1536 int i; 1537 struct stat sb; 1538 uint64_t total_size = 0; 1539 1540 // Find all APK arguments starting at end. 1541 // All other arguments passed through verbatim. 1542 int first_apk = -1; 1543 for (i = argc - 1; i >= 0; i--) { 1544 const char* file = argv[i]; 1545 const char* dot = strrchr(file, '.'); 1546 if (dot && !strcasecmp(dot, ".apk")) { 1547 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1548 fprintf(stderr, "Invalid APK file: %s\n", file); 1549 return -1; 1550 } 1551 1552 total_size += sb.st_size; 1553 first_apk = i; 1554 } else { 1555 break; 1556 } 1557 } 1558 1559 if (first_apk == -1) { 1560 fprintf(stderr, "Missing APK file\n"); 1561 return 1; 1562 } 1563 1564 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1565 for (i = 1; i < first_apk; i++) { 1566 cmd += " " + escape_arg(argv[i]); 1567 } 1568 1569 // Create install session 1570 std::string error; 1571 int fd = adb_connect(cmd, &error); 1572 if (fd < 0) { 1573 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1574 return -1; 1575 } 1576 char buf[BUFSIZ]; 1577 read_status_line(fd, buf, sizeof(buf)); 1578 adb_close(fd); 1579 1580 int session_id = -1; 1581 if (!strncmp("Success", buf, 7)) { 1582 char* start = strrchr(buf, '['); 1583 char* end = strrchr(buf, ']'); 1584 if (start && end) { 1585 *end = '\0'; 1586 session_id = strtol(start + 1, NULL, 10); 1587 } 1588 } 1589 if (session_id < 0) { 1590 fprintf(stderr, "Failed to create session\n"); 1591 fputs(buf, stderr); 1592 return -1; 1593 } 1594 1595 // Valid session, now stream the APKs 1596 int success = 1; 1597 for (i = first_apk; i < argc; i++) { 1598 const char* file = argv[i]; 1599 if (stat(file, &sb) == -1) { 1600 fprintf(stderr, "Failed to stat %s\n", file); 1601 success = 0; 1602 goto finalize_session; 1603 } 1604 1605 std::string cmd = android::base::StringPrintf( 1606 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1607 static_cast<uint64_t>(sb.st_size), session_id, i, get_basename(file)); 1608 1609 int localFd = adb_open(file, O_RDONLY); 1610 if (localFd < 0) { 1611 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1612 success = 0; 1613 goto finalize_session; 1614 } 1615 1616 std::string error; 1617 int remoteFd = adb_connect(cmd, &error); 1618 if (remoteFd < 0) { 1619 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1620 adb_close(localFd); 1621 success = 0; 1622 goto finalize_session; 1623 } 1624 1625 copy_to_file(localFd, remoteFd); 1626 read_status_line(remoteFd, buf, sizeof(buf)); 1627 1628 adb_close(localFd); 1629 adb_close(remoteFd); 1630 1631 if (strncmp("Success", buf, 7)) { 1632 fprintf(stderr, "Failed to write %s\n", file); 1633 fputs(buf, stderr); 1634 success = 0; 1635 goto finalize_session; 1636 } 1637 } 1638 1639finalize_session: 1640 // Commit session if we streamed everything okay; otherwise abandon 1641 std::string service = 1642 android::base::StringPrintf("exec:pm install-%s %d", 1643 success ? "commit" : "abandon", session_id); 1644 fd = adb_connect(service, &error); 1645 if (fd < 0) { 1646 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1647 return -1; 1648 } 1649 read_status_line(fd, buf, sizeof(buf)); 1650 adb_close(fd); 1651 1652 if (!strncmp("Success", buf, 7)) { 1653 fputs(buf, stderr); 1654 return 0; 1655 } else { 1656 fprintf(stderr, "Failed to finalize session\n"); 1657 fputs(buf, stderr); 1658 return -1; 1659 } 1660} 1661