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