commandline.cpp revision 2ec36b0da00f959ed5cf47b947630fe6bfe73c9f
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 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#include <thread> 37#include <vector> 38 39#include <android-base/file.h> 40#include <android-base/logging.h> 41#include <android-base/parseint.h> 42#include <android-base/stringprintf.h> 43#include <android-base/strings.h> 44 45#if !defined(_WIN32) 46#include <signal.h> 47#include <sys/ioctl.h> 48#include <termios.h> 49#include <unistd.h> 50#endif 51 52#include "adb.h" 53#include "adb_auth.h" 54#include "adb_client.h" 55#include "adb_io.h" 56#include "adb_unique_fd.h" 57#include "adb_utils.h" 58#include "bugreport.h" 59#include "commandline.h" 60#include "file_sync_service.h" 61#include "services.h" 62#include "shell_service.h" 63#include "sysdeps/chrono.h" 64 65static int install_app(TransportType t, const char* serial, int argc, const char** argv); 66static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv); 67static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv); 68static int install_app_legacy(TransportType t, const char* serial, int argc, const char** argv); 69static int uninstall_app_legacy(TransportType t, const char* serial, int argc, const char** argv); 70 71static auto& gProductOutPath = *new std::string(); 72extern int gListenAll; 73 74DefaultStandardStreamsCallback DEFAULT_STANDARD_STREAMS_CALLBACK(nullptr, nullptr); 75 76static std::string product_file(const char *extra) { 77 if (gProductOutPath.empty()) { 78 fprintf(stderr, "adb: Product directory not specified; " 79 "use -p or define ANDROID_PRODUCT_OUT\n"); 80 exit(1); 81 } 82 83 return android::base::StringPrintf("%s%s%s", 84 gProductOutPath.c_str(), OS_PATH_SEPARATOR_STR, extra); 85} 86 87static void help() { 88 fprintf(stdout, "%s\n", adb_version().c_str()); 89 // clang-format off 90 fprintf(stdout, 91 "global options:\n" 92 " -a listen on all network interfaces, not just localhost\n" 93 " -d use USB device (error if multiple devices connected)\n" 94 " -e use TCP/IP device (error if multiple TCP/IP devices available)\n" 95 " -s SERIAL\n" 96 " use device with given serial number (overrides $ANDROID_SERIAL)\n" 97 " -p PRODUCT\n" 98 " name or path ('angler'/'out/target/product/angler');\n" 99 " default $ANDROID_PRODUCT_OUT\n" 100 " -H name of adb server host [default=localhost]\n" 101 " -P port of adb server [default=5037]\n" 102 " -L SOCKET listen on given socket for adb server [default=tcp:localhost:5037]\n" 103 "\n" 104 "general commands:\n" 105 " devices [-l] list connected devices (-l for long output)\n" 106 " help show this help message\n" 107 " version show version num\n" 108 "\n" 109 "networking:\n" 110 " connect HOST[:PORT] connect to a device via TCP/IP [default port=5555]\n" 111 " disconnect [HOST[:PORT]]\n" 112 " disconnect from given TCP/IP device [default port=5555], or all\n" 113 " forward --list list all forward socket connections\n" 114 " forward [--no-rebind] LOCAL REMOTE\n" 115 " forward socket connection using:\n" 116 " tcp:<port> (<local> may be \"tcp:0\" to pick any open port)\n" 117 " localabstract:<unix domain socket name>\n" 118 " localreserved:<unix domain socket name>\n" 119 " localfilesystem:<unix domain socket name>\n" 120 " dev:<character device name>\n" 121 " jdwp:<process pid> (remote only)\n" 122 " forward --remove LOCAL remove specific forward socket connection\n" 123 " forward --remove-all remove all forward socket connections\n" 124 " ppp TTY [PARAMETER...] run PPP over USB\n" 125 " reverse --list list all reverse socket connections from device\n" 126 " reverse [--no-rebind] REMOTE LOCAL\n" 127 " reverse socket connection using:\n" 128 " tcp:<port> (<remote> may be \"tcp:0\" to pick any open port)\n" 129 " localabstract:<unix domain socket name>\n" 130 " localreserved:<unix domain socket name>\n" 131 " localfilesystem:<unix domain socket name>\n" 132 " reverse --remove REMOTE remove specific reverse socket connection\n" 133 " reverse --remove-all remove all reverse socket connections from device\n" 134 "\n" 135 "file transfer:\n" 136 " push LOCAL... REMOTE\n" 137 " copy local files/directories to device\n" 138 " pull [-a] REMOTE... LOCAL\n" 139 " copy files/dirs from device\n" 140 " -a: preserve file timestamp and mode\n" 141 " sync [DIR]\n" 142 " copy all changed files to device; if DIR is \"system\", \"vendor\", \"oem\",\n" 143 " or \"data\", only sync that partition (default all)\n" 144 " -l: list but don't copy\n" 145 "\n" 146 "shell:\n" 147 " shell [-e ESCAPE] [-n] [-Tt] [-x] [COMMAND...]\n" 148 " run remote shell command (interactive shell if no command given)\n" 149 " -e: choose escape character, or \"none\"; default '~'\n" 150 " -n: don't read from stdin\n" 151 " -T: disable PTY allocation\n" 152 " -t: force PTY allocation\n" 153 " -x: disable remote exit codes and stdout/stderr separation\n" 154 " emu COMMAND run emulator console command\n" 155 "\n" 156 "app installation:\n" 157 " install [-lrtsdg] PACKAGE\n" 158 " install-multiple [-lrtsdpg] PACKAGE...\n" 159 " push package(s) to the device and install them\n" 160 " -l: forward lock application\n" 161 " -r: replace existing application\n" 162 " -t: allow test packages\n" 163 " -s: install application on sdcard\n" 164 " -d: allow version code downgrade (debuggable packages only)\n" 165 " -p: partial application install (install-multiple only)\n" 166 " -g: grant all runtime permissions\n" 167 " uninstall [-k] PACKAGE\n" 168 " remove this app package from the device\n" 169 " '-k': keep the data and cache directories\n" 170 "\n" 171 "backup/restore:\n" 172 " backup [-f FILE] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [PACKAGE...]\n" 173 " write an archive of the device's data to FILE [default=backup.adb]\n" 174 " package list optional if -all/-shared are supplied\n" 175 " -apk/-noapk: do/don't back up .apk files (default -noapk)\n" 176 " -obb/-noobb: do/don't back up .obb files (default -noobb)\n" 177 " -shared|-noshared: do/don't back up shared storage (default -noshared)\n" 178 " -all: back up all installed applications\n" 179 " -system|-nosystem: include system apps in -all (default -system)\n" 180 " restore FILE restore device contents from FILE\n" 181 "\n" 182 "debugging:\n" 183 " bugreport [PATH]\n" 184 " write bugreport to given PATH [default=bugreport.zip];\n" 185 " if PATH is a directory, the bug report is saved in that directory.\n" 186 " devices that don't support zipped bug reports output to stdout.\n" 187 " jdwp list pids of processes hosting a JDWP transport\n" 188 " logcat show device log (logcat --help for more)\n" 189 "\n" 190 "security:\n" 191 " disable-verity disable dm-verity checking on userdebug builds\n" 192 " enable-verity re-enable dm-verity checking on userdebug builds\n" 193 " keygen FILE\n" 194 " generate adb public/private key; private key stored in FILE,\n" 195 " public key stored in FILE.pub (existing files overwritten)\n" 196 "\n" 197 "scripting:\n" 198 " wait-for[-TRANSPORT]-STATE\n" 199 " wait for device to be in the given state\n" 200 " State: device, recovery, sideload, or bootloader\n" 201 " Transport: usb, local, or any [default=any]\n" 202 " get-state print offline | bootloader | device\n" 203 " get-serialno print <serial-number>\n" 204 " get-devpath print <device-path>\n" 205 " remount\n" 206 " remount /system, /vendor, and /oem partitions read-write\n" 207 " reboot [bootloader|recovery|sideload|sideload-auto-reboot]\n" 208 " reboot the device; defaults to booting system image but\n" 209 " supports bootloader and recovery too. sideload reboots\n" 210 " into recovery and automatically starts sideload mode,\n" 211 " sideload-auto-reboot is the same but reboots after sideloading.\n" 212 " sideload OTAPACKAGE sideload the given full OTA package\n" 213 " root restart adbd with root permissions\n" 214 " unroot restart adbd without root permissions\n" 215 " usb restart adb server listening on USB\n" 216 " tcpip PORT restart adb server listening on TCP on PORT\n" 217 "\n" 218 "internal debugging:\n" 219 " start-server ensure that there is a server running\n" 220 " kill-server kill the server if it is running\n" 221 " reconnect kick connection from host side to force reconnect\n" 222 " reconnect device kick connection from device side to force reconnect\n" 223 "\n" 224 "environment variables:\n" 225 " $ADB_TRACE\n" 226 " comma-separated list of debug info to log:\n" 227 " all,adb,sockets,packets,rwx,usb,sync,sysdeps,transport,jdwp\n" 228 " $ADB_VENDOR_KEYS colon-separated list of keys (files or directories)\n" 229 " $ANDROID_SERIAL serial number to connect to (see -s)\n" 230 " $ANDROID_LOG_TAGS tags to be used by logcat (see logcat --help)\n"); 231 // clang-format on 232} 233 234#if defined(_WIN32) 235 236// Implemented in sysdeps_win32.cpp. 237void stdin_raw_init(); 238void stdin_raw_restore(); 239 240#else 241static termios g_saved_terminal_state; 242 243static void stdin_raw_init() { 244 if (tcgetattr(STDIN_FILENO, &g_saved_terminal_state)) return; 245 246 termios tio; 247 if (tcgetattr(STDIN_FILENO, &tio)) return; 248 249 cfmakeraw(&tio); 250 251 // No timeout but request at least one character per read. 252 tio.c_cc[VTIME] = 0; 253 tio.c_cc[VMIN] = 1; 254 255 tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio); 256} 257 258static void stdin_raw_restore() { 259 tcsetattr(STDIN_FILENO, TCSAFLUSH, &g_saved_terminal_state); 260} 261#endif 262 263// Reads from |fd| and prints received data. If |use_shell_protocol| is true 264// this expects that incoming data will use the shell protocol, in which case 265// stdout/stderr are routed independently and the remote exit code will be 266// returned. 267// if |callback| is non-null, stdout/stderr output will be handled by it. 268int read_and_dump(int fd, bool use_shell_protocol = false, 269 StandardStreamsCallbackInterface* callback = &DEFAULT_STANDARD_STREAMS_CALLBACK) { 270 int exit_code = 0; 271 if (fd < 0) return exit_code; 272 273 std::unique_ptr<ShellProtocol> protocol; 274 int length = 0; 275 276 char raw_buffer[BUFSIZ]; 277 char* buffer_ptr = raw_buffer; 278 if (use_shell_protocol) { 279 protocol.reset(new ShellProtocol(fd)); 280 if (!protocol) { 281 LOG(ERROR) << "failed to allocate memory for ShellProtocol object"; 282 return 1; 283 } 284 buffer_ptr = protocol->data(); 285 } 286 287 while (true) { 288 if (use_shell_protocol) { 289 if (!protocol->Read()) { 290 break; 291 } 292 length = protocol->data_length(); 293 switch (protocol->id()) { 294 case ShellProtocol::kIdStdout: 295 callback->OnStdout(buffer_ptr, length); 296 break; 297 case ShellProtocol::kIdStderr: 298 callback->OnStderr(buffer_ptr, length); 299 break; 300 case ShellProtocol::kIdExit: 301 exit_code = protocol->data()[0]; 302 continue; 303 default: 304 continue; 305 } 306 length = protocol->data_length(); 307 } else { 308 D("read_and_dump(): pre adb_read(fd=%d)", fd); 309 length = adb_read(fd, raw_buffer, sizeof(raw_buffer)); 310 D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length); 311 if (length <= 0) { 312 break; 313 } 314 callback->OnStdout(buffer_ptr, length); 315 } 316 } 317 318 return callback->Done(exit_code); 319} 320 321static void read_status_line(int fd, char* buf, size_t count) 322{ 323 count--; 324 while (count > 0) { 325 int len = adb_read(fd, buf, count); 326 if (len <= 0) { 327 break; 328 } 329 330 buf += len; 331 count -= len; 332 } 333 *buf = '\0'; 334} 335 336static void stdinout_raw_prologue(int inFd, int outFd, int& old_stdin_mode, int& old_stdout_mode) { 337 if (inFd == STDIN_FILENO) { 338 stdin_raw_init(); 339#ifdef _WIN32 340 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY); 341 if (old_stdin_mode == -1) { 342 fatal_errno("could not set stdin to binary"); 343 } 344#endif 345 } 346 347#ifdef _WIN32 348 if (outFd == STDOUT_FILENO) { 349 old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY); 350 if (old_stdout_mode == -1) { 351 fatal_errno("could not set stdout to binary"); 352 } 353 } 354#endif 355} 356 357static void stdinout_raw_epilogue(int inFd, int outFd, int old_stdin_mode, int old_stdout_mode) { 358 if (inFd == STDIN_FILENO) { 359 stdin_raw_restore(); 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 376static void copy_to_file(int inFd, int outFd) { 377 const size_t BUFSIZE = 32 * 1024; 378 char* buf = (char*) malloc(BUFSIZE); 379 if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file"); 380 int len; 381 long total = 0; 382 int old_stdin_mode = -1; 383 int old_stdout_mode = -1; 384 385 D("copy_to_file(%d -> %d)", inFd, outFd); 386 387 stdinout_raw_prologue(inFd, outFd, old_stdin_mode, old_stdout_mode); 388 389 while (true) { 390 if (inFd == STDIN_FILENO) { 391 len = unix_read(inFd, buf, BUFSIZE); 392 } else { 393 len = adb_read(inFd, buf, BUFSIZE); 394 } 395 if (len == 0) { 396 D("copy_to_file() : read 0 bytes; exiting"); 397 break; 398 } 399 if (len < 0) { 400 D("copy_to_file(): read failed: %s", strerror(errno)); 401 break; 402 } 403 if (outFd == STDOUT_FILENO) { 404 fwrite(buf, 1, len, stdout); 405 fflush(stdout); 406 } else { 407 adb_write(outFd, buf, len); 408 } 409 total += len; 410 } 411 412 stdinout_raw_epilogue(inFd, outFd, old_stdin_mode, old_stdout_mode); 413 414 D("copy_to_file() finished after %lu bytes", total); 415 free(buf); 416} 417 418static void send_window_size_change(int fd, std::unique_ptr<ShellProtocol>& shell) { 419 // Old devices can't handle window size changes. 420 if (shell == nullptr) return; 421 422#if defined(_WIN32) 423 struct winsize { 424 unsigned short ws_row; 425 unsigned short ws_col; 426 unsigned short ws_xpixel; 427 unsigned short ws_ypixel; 428 }; 429#endif 430 431 winsize ws; 432 433#if defined(_WIN32) 434 // If stdout is redirected to a non-console, we won't be able to get the 435 // console size, but that makes sense. 436 const intptr_t intptr_handle = _get_osfhandle(STDOUT_FILENO); 437 if (intptr_handle == -1) return; 438 439 const HANDLE handle = reinterpret_cast<const HANDLE>(intptr_handle); 440 441 CONSOLE_SCREEN_BUFFER_INFO info; 442 memset(&info, 0, sizeof(info)); 443 if (!GetConsoleScreenBufferInfo(handle, &info)) return; 444 445 memset(&ws, 0, sizeof(ws)); 446 // The number of visible rows, excluding offscreen scroll-back rows which are in info.dwSize.Y. 447 ws.ws_row = info.srWindow.Bottom - info.srWindow.Top + 1; 448 // If the user has disabled "Wrap text output on resize", they can make the screen buffer wider 449 // than the window, in which case we should use the width of the buffer. 450 ws.ws_col = info.dwSize.X; 451#else 452 if (ioctl(fd, TIOCGWINSZ, &ws) == -1) return; 453#endif 454 455 // Send the new window size as human-readable ASCII for debugging convenience. 456 size_t l = snprintf(shell->data(), shell->data_capacity(), "%dx%d,%dx%d", 457 ws.ws_row, ws.ws_col, ws.ws_xpixel, ws.ws_ypixel); 458 shell->Write(ShellProtocol::kIdWindowSizeChange, l + 1); 459} 460 461// Used to pass multiple values to the stdin read thread. 462struct StdinReadArgs { 463 int stdin_fd, write_fd; 464 bool raw_stdin; 465 std::unique_ptr<ShellProtocol> protocol; 466 char escape_char; 467}; 468 469// Loops to read from stdin and push the data to the given FD. 470// The argument should be a pointer to a StdinReadArgs object. This function 471// will take ownership of the object and delete it when finished. 472static void stdin_read_thread_loop(void* x) { 473 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x)); 474 475#if !defined(_WIN32) 476 // Mask SIGTTIN in case we're in a backgrounded process. 477 sigset_t sigset; 478 sigemptyset(&sigset); 479 sigaddset(&sigset, SIGTTIN); 480 pthread_sigmask(SIG_BLOCK, &sigset, nullptr); 481#endif 482 483#if defined(_WIN32) 484 // _get_interesting_input_record_uncached() causes unix_read_interruptible() 485 // to return -1 with errno == EINTR if the window size changes. 486#else 487 // Unblock SIGWINCH for this thread, so our read(2) below will be 488 // interrupted if the window size changes. 489 sigset_t mask; 490 sigemptyset(&mask); 491 sigaddset(&mask, SIGWINCH); 492 pthread_sigmask(SIG_UNBLOCK, &mask, nullptr); 493#endif 494 495 // Set up the initial window size. 496 send_window_size_change(args->stdin_fd, args->protocol); 497 498 char raw_buffer[BUFSIZ]; 499 char* buffer_ptr = raw_buffer; 500 size_t buffer_size = sizeof(raw_buffer); 501 if (args->protocol != nullptr) { 502 buffer_ptr = args->protocol->data(); 503 buffer_size = args->protocol->data_capacity(); 504 } 505 506 // If we need to parse escape sequences, make life easy. 507 if (args->raw_stdin && args->escape_char != '\0') { 508 buffer_size = 1; 509 } 510 511 enum EscapeState { kMidFlow, kStartOfLine, kInEscape }; 512 EscapeState state = kStartOfLine; 513 514 while (true) { 515 // Use unix_read_interruptible() rather than adb_read() for stdin. 516 D("stdin_read_thread_loop(): pre unix_read_interruptible(fdi=%d,...)", args->stdin_fd); 517 int r = unix_read_interruptible(args->stdin_fd, buffer_ptr, 518 buffer_size); 519 if (r == -1 && errno == EINTR) { 520 send_window_size_change(args->stdin_fd, args->protocol); 521 continue; 522 } 523 D("stdin_read_thread_loop(): post unix_read_interruptible(fdi=%d,...)", args->stdin_fd); 524 if (r <= 0) { 525 // Only devices using the shell protocol know to close subprocess 526 // stdin. For older devices we want to just leave the connection 527 // open, otherwise an unpredictable amount of return data could 528 // be lost due to the FD closing before all data has been received. 529 if (args->protocol) { 530 args->protocol->Write(ShellProtocol::kIdCloseStdin, 0); 531 } 532 break; 533 } 534 // If we made stdin raw, check input for escape sequences. In 535 // this situation signals like Ctrl+C are sent remotely rather than 536 // interpreted locally so this provides an emergency out if the remote 537 // process starts ignoring the signal. SSH also does this, see the 538 // "escape characters" section on the ssh man page for more info. 539 if (args->raw_stdin && args->escape_char != '\0') { 540 char ch = buffer_ptr[0]; 541 if (ch == args->escape_char) { 542 if (state == kStartOfLine) { 543 state = kInEscape; 544 // Swallow the escape character. 545 continue; 546 } else { 547 state = kMidFlow; 548 } 549 } else { 550 if (state == kInEscape) { 551 if (ch == '.') { 552 fprintf(stderr,"\r\n[ disconnected ]\r\n"); 553 stdin_raw_restore(); 554 exit(0); 555 } else { 556 // We swallowed an escape character that wasn't part of 557 // a valid escape sequence; time to cough it up. 558 buffer_ptr[0] = args->escape_char; 559 buffer_ptr[1] = ch; 560 ++r; 561 } 562 } 563 state = (ch == '\n' || ch == '\r') ? kStartOfLine : kMidFlow; 564 } 565 } 566 if (args->protocol) { 567 if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) { 568 break; 569 } 570 } else { 571 if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) { 572 break; 573 } 574 } 575 } 576} 577 578// Returns a shell service string with the indicated arguments and command. 579static std::string ShellServiceString(bool use_shell_protocol, 580 const std::string& type_arg, 581 const std::string& command) { 582 std::vector<std::string> args; 583 if (use_shell_protocol) { 584 args.push_back(kShellServiceArgShellProtocol); 585 586 const char* terminal_type = getenv("TERM"); 587 if (terminal_type != nullptr) { 588 args.push_back(std::string("TERM=") + terminal_type); 589 } 590 } 591 if (!type_arg.empty()) { 592 args.push_back(type_arg); 593 } 594 595 // Shell service string can look like: shell[,arg1,arg2,...]:[command]. 596 return android::base::StringPrintf("shell%s%s:%s", 597 args.empty() ? "" : ",", 598 android::base::Join(args, ',').c_str(), 599 command.c_str()); 600} 601 602// Connects to a shell on the device and read/writes data. 603// 604// Note: currently this function doesn't properly clean up resources; the 605// FD connected to the adb server is never closed and the stdin read thread 606// may never exit. 607// 608// On success returns the remote exit code if |use_shell_protocol| is true, 609// 0 otherwise. On failure returns 1. 610static int RemoteShell(bool use_shell_protocol, const std::string& type_arg, 611 char escape_char, 612 const std::string& command) { 613 std::string service_string = ShellServiceString(use_shell_protocol, 614 type_arg, command); 615 616 // Make local stdin raw if the device allocates a PTY, which happens if: 617 // 1. We are explicitly asking for a PTY shell, or 618 // 2. We don't specify shell type and are starting an interactive session. 619 bool raw_stdin = (type_arg == kShellServiceArgPty || 620 (type_arg.empty() && command.empty())); 621 622 std::string error; 623 int fd = adb_connect(service_string, &error); 624 if (fd < 0) { 625 fprintf(stderr,"error: %s\n", error.c_str()); 626 return 1; 627 } 628 629 StdinReadArgs* args = new StdinReadArgs; 630 if (!args) { 631 LOG(ERROR) << "couldn't allocate StdinReadArgs object"; 632 return 1; 633 } 634 args->stdin_fd = STDIN_FILENO; 635 args->write_fd = fd; 636 args->raw_stdin = raw_stdin; 637 args->escape_char = escape_char; 638 if (use_shell_protocol) { 639 args->protocol.reset(new ShellProtocol(args->write_fd)); 640 } 641 642 if (raw_stdin) stdin_raw_init(); 643 644#if !defined(_WIN32) 645 // Ensure our process is notified if the local window size changes. 646 // We use sigaction(2) to ensure that the SA_RESTART flag is not set, 647 // because the whole reason we're sending signals is to unblock the read(2)! 648 // That also means we don't need to do anything in the signal handler: 649 // the side effect of delivering the signal is all we need. 650 struct sigaction sa; 651 memset(&sa, 0, sizeof(sa)); 652 sa.sa_handler = [](int) {}; 653 sa.sa_flags = 0; 654 sigaction(SIGWINCH, &sa, nullptr); 655 656 // Now block SIGWINCH in this thread (the main thread) and all threads spawned 657 // from it. The stdin read thread will unblock this signal to ensure that it's 658 // the thread that receives the signal. 659 sigset_t mask; 660 sigemptyset(&mask); 661 sigaddset(&mask, SIGWINCH); 662 pthread_sigmask(SIG_BLOCK, &mask, nullptr); 663#endif 664 665 // TODO: combine read_and_dump with stdin_read_thread to make life simpler? 666 int exit_code = 1; 667 if (!adb_thread_create(stdin_read_thread_loop, args)) { 668 PLOG(ERROR) << "error starting stdin read thread"; 669 delete args; 670 } else { 671 exit_code = read_and_dump(fd, use_shell_protocol); 672 } 673 674 // TODO: properly exit stdin_read_thread_loop and close |fd|. 675 676 // TODO: we should probably install signal handlers for this. 677 // TODO: can we use atexit? even on Windows? 678 if (raw_stdin) stdin_raw_restore(); 679 680 return exit_code; 681} 682 683static int adb_shell(int argc, const char** argv) { 684 FeatureSet features; 685 std::string error; 686 if (!adb_get_feature_set(&features, &error)) { 687 fprintf(stderr, "error: %s\n", error.c_str()); 688 return 1; 689 } 690 691 enum PtyAllocationMode { kPtyAuto, kPtyNo, kPtyYes, kPtyDefinitely }; 692 693 // Defaults. 694 char escape_char = '~'; // -e 695 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); // -x 696 PtyAllocationMode tty = use_shell_protocol ? kPtyAuto : kPtyDefinitely; // -t/-T 697 698 // Parse shell-specific command-line options. 699 argv[0] = "adb shell"; // So getopt(3) error messages start "adb shell". 700 optind = 1; // argv[0] is always "shell", so set `optind` appropriately. 701 int opt; 702 while ((opt = getopt(argc, const_cast<char**>(argv), "+e:ntTx")) != -1) { 703 switch (opt) { 704 case 'e': 705 if (!(strlen(optarg) == 1 || strcmp(optarg, "none") == 0)) { 706 fprintf(stderr, "error: -e requires a single-character argument or 'none'\n"); 707 return 1; 708 } 709 escape_char = (strcmp(optarg, "none") == 0) ? 0 : optarg[0]; 710 break; 711 case 'n': 712 close_stdin(); 713 break; 714 case 'x': 715 // This option basically asks for historical behavior, so set options that 716 // correspond to the historical defaults. This is slightly weird in that -Tx 717 // is fine (because we'll undo the -T) but -xT isn't, but that does seem to 718 // be our least worst choice... 719 use_shell_protocol = false; 720 tty = kPtyDefinitely; 721 escape_char = '~'; 722 break; 723 case 't': 724 // Like ssh, -t arguments are cumulative so that multiple -t's 725 // are needed to force a PTY. 726 tty = (tty >= kPtyYes) ? kPtyDefinitely : kPtyYes; 727 break; 728 case 'T': 729 tty = kPtyNo; 730 break; 731 default: 732 // getopt(3) already printed an error message for us. 733 return 1; 734 } 735 } 736 737 bool is_interactive = (optind == argc); 738 739 std::string shell_type_arg = kShellServiceArgPty; 740 if (tty == kPtyNo) { 741 shell_type_arg = kShellServiceArgRaw; 742 } else if (tty == kPtyAuto) { 743 // If stdin isn't a TTY, default to a raw shell; this lets 744 // things like `adb shell < my_script.sh` work as expected. 745 // Non-interactive shells should also not have a pty. 746 if (!unix_isatty(STDIN_FILENO) || !is_interactive) { 747 shell_type_arg = kShellServiceArgRaw; 748 } 749 } else if (tty == kPtyYes) { 750 // A single -t arg isn't enough to override implicit -T. 751 if (!unix_isatty(STDIN_FILENO)) { 752 fprintf(stderr, 753 "Remote PTY will not be allocated because stdin is not a terminal.\n" 754 "Use multiple -t options to force remote PTY allocation.\n"); 755 shell_type_arg = kShellServiceArgRaw; 756 } 757 } 758 759 D("shell -e 0x%x t=%d use_shell_protocol=%s shell_type_arg=%s\n", 760 escape_char, tty, 761 use_shell_protocol ? "true" : "false", 762 (shell_type_arg == kShellServiceArgPty) ? "pty" : "raw"); 763 764 // Raw mode is only supported when talking to a new device *and* using the shell protocol. 765 if (!use_shell_protocol) { 766 if (shell_type_arg != kShellServiceArgPty) { 767 fprintf(stderr, "error: %s only supports allocating a pty\n", 768 !CanUseFeature(features, kFeatureShell2) ? "device" : "-x"); 769 return 1; 770 } else { 771 // If we're not using the shell protocol, the type argument must be empty. 772 shell_type_arg = ""; 773 } 774 } 775 776 std::string command; 777 if (optind < argc) { 778 // We don't escape here, just like ssh(1). http://b/20564385. 779 command = android::base::Join(std::vector<const char*>(argv + optind, argv + argc), ' '); 780 } 781 782 return RemoteShell(use_shell_protocol, shell_type_arg, escape_char, command); 783} 784 785static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 786 bool show_progress) 787{ 788 std::string error; 789 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 790 if (fd < 0) { 791 fprintf(stderr,"error: %s\n", error.c_str()); 792 return -1; 793 } 794 795 int opt = CHUNK_SIZE; 796 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 797 798 unsigned total = sz; 799 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 800 801 if (show_progress) { 802 const char* x = strrchr(service, ':'); 803 if (x) service = x + 1; 804 } 805 806 while (sz > 0) { 807 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 808 if (!WriteFdExactly(fd, ptr, xfer)) { 809 std::string error; 810 adb_status(fd, &error); 811 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 812 adb_close(fd); 813 return -1; 814 } 815 sz -= xfer; 816 ptr += xfer; 817 if (show_progress) { 818 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 819 fflush(stdout); 820 } 821 } 822 if (show_progress) { 823 printf("\n"); 824 } 825 826 if (!adb_status(fd, &error)) { 827 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 828 adb_close(fd); 829 return -1; 830 } 831 832 adb_close(fd); 833 return 0; 834} 835 836#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 837 838/* 839 * The sideload-host protocol serves the data in a file (given on the 840 * command line) to the client, using a simple protocol: 841 * 842 * - The connect message includes the total number of bytes in the 843 * file and a block size chosen by us. 844 * 845 * - The other side sends the desired block number as eight decimal 846 * digits (eg "00000023" for block 23). Blocks are numbered from 847 * zero. 848 * 849 * - We send back the data of the requested block. The last block is 850 * likely to be partial; when the last block is requested we only 851 * send the part of the block that exists, it's not padded up to the 852 * block size. 853 * 854 * - When the other side sends "DONEDONE" instead of a block number, 855 * we hang up. 856 */ 857static int adb_sideload_host(const char* fn) { 858 fprintf(stderr, "loading: '%s'...\n", fn); 859 860 std::string content; 861 if (!android::base::ReadFileToString(fn, &content)) { 862 fprintf(stderr, "failed: %s\n", strerror(errno)); 863 return -1; 864 } 865 866 const uint8_t* data = reinterpret_cast<const uint8_t*>(content.data()); 867 unsigned sz = content.size(); 868 869 fprintf(stderr, "connecting...\n"); 870 std::string service = 871 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 872 std::string error; 873 unique_fd fd(adb_connect(service, &error)); 874 if (fd < 0) { 875 // Try falling back to the older sideload method. Maybe this 876 // is an older device that doesn't support sideload-host. 877 fprintf(stderr, "falling back to older sideload method...\n"); 878 return adb_download_buffer("sideload", fn, data, sz, true); 879 } 880 881 int opt = SIDELOAD_HOST_BLOCK_SIZE; 882 adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)); 883 884 size_t xfer = 0; 885 int last_percent = -1; 886 while (true) { 887 char buf[9]; 888 if (!ReadFdExactly(fd, buf, 8)) { 889 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 890 return -1; 891 } 892 buf[8] = '\0'; 893 894 if (strcmp("DONEDONE", buf) == 0) { 895 printf("\rTotal xfer: %.2fx%*s\n", 896 (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 897 return 0; 898 } 899 900 int block = strtol(buf, NULL, 10); 901 902 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 903 if (offset >= sz) { 904 fprintf(stderr, "* attempt to read block %d past end\n", block); 905 return -1; 906 } 907 const uint8_t* start = data + offset; 908 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 909 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 910 if (offset_end > sz) { 911 to_write = sz - offset; 912 } 913 914 if (!WriteFdExactly(fd, start, to_write)) { 915 adb_status(fd, &error); 916 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 917 return -1; 918 } 919 xfer += to_write; 920 921 // For normal OTA packages, we expect to transfer every byte 922 // twice, plus a bit of overhead (one read during 923 // verification, one read of each byte for installation, plus 924 // extra access to things like the zip central directory). 925 // This estimate of the completion becomes 100% when we've 926 // transferred ~2.13 (=100/47) times the package size. 927 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 928 if (percent != last_percent) { 929 printf("\rserving: '%s' (~%d%%) ", fn, percent); 930 fflush(stdout); 931 last_percent = percent; 932 } 933 } 934} 935 936/** 937 * Run ppp in "notty" mode against a resource listed as the first parameter 938 * eg: 939 * 940 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 941 * 942 */ 943static int ppp(int argc, const char** argv) { 944#if defined(_WIN32) 945 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 946 return -1; 947#else 948 if (argc < 2) { 949 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 950 argv[0]); 951 952 return 1; 953 } 954 955 const char* adb_service_name = argv[1]; 956 std::string error; 957 int fd = adb_connect(adb_service_name, &error); 958 if (fd < 0) { 959 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 960 adb_service_name, error.c_str()); 961 return 1; 962 } 963 964 pid_t pid = fork(); 965 966 if (pid < 0) { 967 perror("from fork()"); 968 return 1; 969 } else if (pid == 0) { 970 int err; 971 int i; 972 const char **ppp_args; 973 974 // copy args 975 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 976 ppp_args[0] = "pppd"; 977 for (i = 2 ; i < argc ; i++) { 978 //argv[2] and beyond become ppp_args[1] and beyond 979 ppp_args[i - 1] = argv[i]; 980 } 981 ppp_args[i-1] = NULL; 982 983 // child side 984 985 dup2(fd, STDIN_FILENO); 986 dup2(fd, STDOUT_FILENO); 987 adb_close(STDERR_FILENO); 988 adb_close(fd); 989 990 err = execvp("pppd", (char * const *)ppp_args); 991 992 if (err < 0) { 993 perror("execing pppd"); 994 } 995 exit(-1); 996 } else { 997 // parent side 998 999 adb_close(fd); 1000 return 0; 1001 } 1002#endif /* !defined(_WIN32) */ 1003} 1004 1005static bool wait_for_device(const char* service, TransportType t, const char* serial) { 1006 std::vector<std::string> components = android::base::Split(service, "-"); 1007 if (components.size() < 3 || components.size() > 4) { 1008 fprintf(stderr, "adb: couldn't parse 'wait-for' command: %s\n", service); 1009 return false; 1010 } 1011 1012 // Was the caller vague about what they'd like us to wait for? 1013 // If so, check they weren't more specific in their choice of transport type. 1014 if (components.size() == 3) { 1015 auto it = components.begin() + 2; 1016 if (t == kTransportUsb) { 1017 components.insert(it, "usb"); 1018 } else if (t == kTransportLocal) { 1019 components.insert(it, "local"); 1020 } else { 1021 components.insert(it, "any"); 1022 } 1023 } else if (components[2] != "any" && components[2] != "local" && components[2] != "usb") { 1024 fprintf(stderr, "adb: unknown type %s; expected 'any', 'local', or 'usb'\n", 1025 components[2].c_str()); 1026 return false; 1027 } 1028 1029 if (components[3] != "any" && components[3] != "bootloader" && components[3] != "device" && 1030 components[3] != "recovery" && components[3] != "sideload") { 1031 fprintf(stderr, 1032 "adb: unknown state %s; " 1033 "expected 'any', 'bootloader', 'device', 'recovery', or 'sideload'\n", 1034 components[3].c_str()); 1035 return false; 1036 } 1037 1038 std::string cmd = format_host_command(android::base::Join(components, "-").c_str(), t, serial); 1039 return adb_command(cmd); 1040} 1041 1042static bool adb_root(const char* command) { 1043 std::string error; 1044 1045 unique_fd fd(adb_connect(android::base::StringPrintf("%s:", command), &error)); 1046 if (fd < 0) { 1047 fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str()); 1048 return false; 1049 } 1050 1051 // Figure out whether we actually did anything. 1052 char buf[256]; 1053 char* cur = buf; 1054 ssize_t bytes_left = sizeof(buf); 1055 while (bytes_left > 0) { 1056 ssize_t bytes_read = adb_read(fd, cur, bytes_left); 1057 if (bytes_read == 0) { 1058 break; 1059 } else if (bytes_read < 0) { 1060 fprintf(stderr, "adb: error while reading for %s: %s\n", command, strerror(errno)); 1061 return false; 1062 } 1063 cur += bytes_read; 1064 bytes_left -= bytes_read; 1065 } 1066 1067 if (bytes_left == 0) { 1068 fprintf(stderr, "adb: unexpected output length for %s\n", command); 1069 return false; 1070 } 1071 1072 fflush(stdout); 1073 WriteFdExactly(STDOUT_FILENO, buf, sizeof(buf) - bytes_left); 1074 if (cur != buf && strstr(buf, "restarting") == nullptr) { 1075 return true; 1076 } 1077 1078 // Give adbd some time to kill itself and come back up. 1079 // We can't use wait-for-device because devices (e.g. adb over network) might not come back. 1080 std::this_thread::sleep_for(3s); 1081 return true; 1082} 1083 1084int send_shell_command(TransportType transport_type, const char* serial, const std::string& command, 1085 bool disable_shell_protocol, StandardStreamsCallbackInterface* callback) { 1086 int fd; 1087 bool use_shell_protocol = false; 1088 1089 while (true) { 1090 bool attempt_connection = true; 1091 1092 // Use shell protocol if it's supported and the caller doesn't explicitly 1093 // disable it. 1094 if (!disable_shell_protocol) { 1095 FeatureSet features; 1096 std::string error; 1097 if (adb_get_feature_set(&features, &error)) { 1098 use_shell_protocol = CanUseFeature(features, kFeatureShell2); 1099 } else { 1100 // Device was unreachable. 1101 attempt_connection = false; 1102 } 1103 } 1104 1105 if (attempt_connection) { 1106 std::string error; 1107 std::string service_string = ShellServiceString(use_shell_protocol, "", command); 1108 1109 fd = adb_connect(service_string, &error); 1110 if (fd >= 0) { 1111 break; 1112 } 1113 } 1114 1115 fprintf(stderr, "- waiting for device -\n"); 1116 if (!wait_for_device("wait-for-device", transport_type, serial)) { 1117 return 1; 1118 } 1119 } 1120 1121 int exit_code = read_and_dump(fd, use_shell_protocol, callback); 1122 1123 if (adb_close(fd) < 0) { 1124 PLOG(ERROR) << "failure closing FD " << fd; 1125 } 1126 1127 return exit_code; 1128} 1129 1130static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 1131 char* log_tags = getenv("ANDROID_LOG_TAGS"); 1132 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 1133 1134 std::string cmd = "export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 1135 1136 if (!strcmp(argv[0], "longcat")) { 1137 cmd += " -v long"; 1138 } 1139 1140 --argc; 1141 ++argv; 1142 while (argc-- > 0) { 1143 cmd += " " + escape_arg(*argv++); 1144 } 1145 1146 // No need for shell protocol with logcat, always disable for simplicity. 1147 return send_shell_command(transport, serial, cmd, true); 1148} 1149 1150static void write_zeros(int bytes, int fd) { 1151 int old_stdin_mode = -1; 1152 int old_stdout_mode = -1; 1153 char* buf = (char*) calloc(1, bytes); 1154 if (buf == nullptr) fatal("couldn't allocate buffer for write_zeros"); 1155 1156 D("write_zeros(%d) -> %d", bytes, fd); 1157 1158 stdinout_raw_prologue(-1, fd, old_stdin_mode, old_stdout_mode); 1159 1160 if (fd == STDOUT_FILENO) { 1161 fwrite(buf, 1, bytes, stdout); 1162 fflush(stdout); 1163 } else { 1164 adb_write(fd, buf, bytes); 1165 } 1166 1167 stdinout_raw_prologue(-1, fd, old_stdin_mode, old_stdout_mode); 1168 1169 D("write_zeros() finished"); 1170 free(buf); 1171} 1172 1173static int backup(int argc, const char** argv) { 1174 const char* filename = "backup.ab"; 1175 1176 /* find, extract, and use any -f argument */ 1177 for (int i = 1; i < argc; i++) { 1178 if (!strcmp("-f", argv[i])) { 1179 if (i == argc-1) { 1180 fprintf(stderr, "adb: backup -f passed with no filename.\n"); 1181 return EXIT_FAILURE; 1182 } 1183 filename = argv[i+1]; 1184 for (int j = i+2; j <= argc; ) { 1185 argv[i++] = argv[j++]; 1186 } 1187 argc -= 2; 1188 argv[argc] = NULL; 1189 } 1190 } 1191 1192 // Bare "adb backup" or "adb backup -f filename" are not valid invocations --- 1193 // a list of packages is required. 1194 if (argc < 2) { 1195 fprintf(stderr, "adb: backup either needs a list of packages or -all/-shared.\n"); 1196 return EXIT_FAILURE; 1197 } 1198 1199 adb_unlink(filename); 1200 int outFd = adb_creat(filename, 0640); 1201 if (outFd < 0) { 1202 fprintf(stderr, "adb: backup unable to create file '%s': %s\n", filename, strerror(errno)); 1203 return EXIT_FAILURE; 1204 } 1205 1206 std::string cmd = "backup:"; 1207 --argc; 1208 ++argv; 1209 while (argc-- > 0) { 1210 cmd += " " + escape_arg(*argv++); 1211 } 1212 1213 D("backup. filename=%s cmd=%s", filename, cmd.c_str()); 1214 std::string error; 1215 int fd = adb_connect(cmd, &error); 1216 if (fd < 0) { 1217 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 1218 adb_close(outFd); 1219 return EXIT_FAILURE; 1220 } 1221 1222 printf("Now unlock your device and confirm the backup operation...\n"); 1223 fflush(stdout); 1224 1225 copy_to_file(fd, outFd); 1226 1227 adb_close(fd); 1228 adb_close(outFd); 1229 return EXIT_SUCCESS; 1230} 1231 1232static int restore(int argc, const char** argv) { 1233 if (argc != 2) return usage("restore requires an argument"); 1234 1235 const char* filename = argv[1]; 1236 int tarFd = adb_open(filename, O_RDONLY); 1237 if (tarFd < 0) { 1238 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 1239 return -1; 1240 } 1241 1242 std::string error; 1243 int fd = adb_connect("restore:", &error); 1244 if (fd < 0) { 1245 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 1246 adb_close(tarFd); 1247 return -1; 1248 } 1249 1250 printf("Now unlock your device and confirm the restore operation.\n"); 1251 copy_to_file(tarFd, fd); 1252 1253 // Provide an in-band EOD marker in case the archive file is malformed 1254 write_zeros(512*2, fd); 1255 1256 // Wait until the other side finishes, or it'll get sent SIGHUP. 1257 copy_to_file(fd, STDOUT_FILENO); 1258 1259 adb_close(fd); 1260 adb_close(tarFd); 1261 return 0; 1262} 1263 1264/* <hint> may be: 1265 * - A simple product name 1266 * e.g., "sooner" 1267 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 1268 * e.g., "out/target/product/sooner" 1269 * - An absolute path to the PRODUCT_OUT dir 1270 * e.g., "/src/device/out/target/product/sooner" 1271 * 1272 * Given <hint>, try to construct an absolute path to the 1273 * ANDROID_PRODUCT_OUT dir. 1274 */ 1275static std::string find_product_out_path(const std::string& hint) { 1276 if (hint.empty()) { 1277 return ""; 1278 } 1279 1280 // If it's already absolute, don't bother doing any work. 1281 if (adb_is_absolute_host_path(hint.c_str())) { 1282 return hint; 1283 } 1284 1285 // If any of the OS_PATH_SEPARATORS is found, assume it's a relative path; 1286 // make it absolute. 1287 // NOLINT: Do not complain if OS_PATH_SEPARATORS has only one character. 1288 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { // NOLINT 1289 std::string cwd; 1290 if (!getcwd(&cwd)) { 1291 perror("adb: getcwd failed"); 1292 return ""; 1293 } 1294 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); 1295 } 1296 1297 // It's a string without any slashes. Try to do something with it. 1298 // 1299 // Try to find the root of the build tree, and build a PRODUCT_OUT 1300 // path from there. 1301 char* top = getenv("ANDROID_BUILD_TOP"); 1302 if (top == nullptr) { 1303 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 1304 return ""; 1305 } 1306 1307 std::string path = top; 1308 path += OS_PATH_SEPARATOR_STR; 1309 path += "out"; 1310 path += OS_PATH_SEPARATOR_STR; 1311 path += "target"; 1312 path += OS_PATH_SEPARATOR_STR; 1313 path += "product"; 1314 path += OS_PATH_SEPARATOR_STR; 1315 path += hint; 1316 if (!directory_exists(path)) { 1317 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 1318 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); 1319 return ""; 1320 } 1321 return path; 1322} 1323 1324static void parse_push_pull_args(const char** arg, int narg, 1325 std::vector<const char*>* srcs, 1326 const char** dst, bool* copy_attrs) { 1327 *copy_attrs = false; 1328 1329 srcs->clear(); 1330 bool ignore_flags = false; 1331 while (narg > 0) { 1332 if (ignore_flags || *arg[0] != '-') { 1333 srcs->push_back(*arg); 1334 } else { 1335 if (!strcmp(*arg, "-p")) { 1336 // Silently ignore for backwards compatibility. 1337 } else if (!strcmp(*arg, "-a")) { 1338 *copy_attrs = true; 1339 } else if (!strcmp(*arg, "--")) { 1340 ignore_flags = true; 1341 } else { 1342 fprintf(stderr, "adb: unrecognized option '%s'\n", *arg); 1343 exit(1); 1344 } 1345 } 1346 ++arg; 1347 --narg; 1348 } 1349 1350 if (srcs->size() > 1) { 1351 *dst = srcs->back(); 1352 srcs->pop_back(); 1353 } 1354} 1355 1356static int adb_connect_command(const std::string& command) { 1357 std::string error; 1358 int fd = adb_connect(command, &error); 1359 if (fd < 0) { 1360 fprintf(stderr, "error: %s\n", error.c_str()); 1361 return 1; 1362 } 1363 read_and_dump(fd); 1364 adb_close(fd); 1365 return 0; 1366} 1367 1368static int adb_query_command(const std::string& command) { 1369 std::string result; 1370 std::string error; 1371 if (!adb_query(command, &result, &error)) { 1372 fprintf(stderr, "error: %s\n", error.c_str()); 1373 return 1; 1374 } 1375 printf("%s\n", result.c_str()); 1376 return 0; 1377} 1378 1379// Disallow stdin, stdout, and stderr. 1380static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { 1381#ifdef _WIN32 1382 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); 1383 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && 1384 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && 1385 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); 1386#else 1387 return ack_reply_fd > 2; 1388#endif 1389} 1390 1391static bool _use_legacy_install() { 1392 FeatureSet features; 1393 std::string error; 1394 if (!adb_get_feature_set(&features, &error)) { 1395 fprintf(stderr, "error: %s\n", error.c_str()); 1396 return true; 1397 } 1398 return !CanUseFeature(features, kFeatureCmd); 1399} 1400 1401int adb_commandline(int argc, const char** argv) { 1402 int no_daemon = 0; 1403 int is_daemon = 0; 1404 int is_server = 0; 1405 int r; 1406 TransportType transport_type = kTransportAny; 1407 int ack_reply_fd = -1; 1408 1409#if !defined(_WIN32) 1410 // We'd rather have EPIPE than SIGPIPE. 1411 signal(SIGPIPE, SIG_IGN); 1412#endif 1413 1414 // If defined, this should be an absolute path to 1415 // the directory containing all of the various system images 1416 // for a particular product. If not defined, and the adb 1417 // command requires this information, then the user must 1418 // specify the path using "-p". 1419 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1420 if (ANDROID_PRODUCT_OUT != nullptr) { 1421 gProductOutPath = ANDROID_PRODUCT_OUT; 1422 } 1423 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1424 1425 const char* server_host_str = nullptr; 1426 const char* server_port_str = nullptr; 1427 const char* server_socket_str = nullptr; 1428 1429 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1430 const char* serial = nullptr; 1431 1432 while (argc > 0) { 1433 if (!strcmp(argv[0],"server")) { 1434 is_server = 1; 1435 } else if (!strcmp(argv[0],"nodaemon")) { 1436 no_daemon = 1; 1437 } else if (!strcmp(argv[0], "fork-server")) { 1438 /* this is a special flag used only when the ADB client launches the ADB Server */ 1439 is_daemon = 1; 1440 } else if (!strcmp(argv[0], "--reply-fd")) { 1441 if (argc < 2) return usage("--reply-fd requires an argument"); 1442 const char* reply_fd_str = argv[1]; 1443 argc--; 1444 argv++; 1445 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1446 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1447 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1448 return 1; 1449 } 1450 } else if (!strncmp(argv[0], "-p", 2)) { 1451 const char* product = nullptr; 1452 if (argv[0][2] == '\0') { 1453 if (argc < 2) return usage("-p requires an argument"); 1454 product = argv[1]; 1455 argc--; 1456 argv++; 1457 } else { 1458 product = argv[0] + 2; 1459 } 1460 gProductOutPath = find_product_out_path(product); 1461 if (gProductOutPath.empty()) { 1462 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1463 return 1; 1464 } 1465 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1466 if (isdigit(argv[0][2])) { 1467 serial = argv[0] + 2; 1468 } else { 1469 if (argc < 2 || argv[0][2] != '\0') return usage("-s requires an argument"); 1470 serial = argv[1]; 1471 argc--; 1472 argv++; 1473 } 1474 } else if (!strcmp(argv[0],"-d")) { 1475 transport_type = kTransportUsb; 1476 } else if (!strcmp(argv[0],"-e")) { 1477 transport_type = kTransportLocal; 1478 } else if (!strcmp(argv[0],"-a")) { 1479 gListenAll = 1; 1480 } else if (!strncmp(argv[0], "-H", 2)) { 1481 if (argv[0][2] == '\0') { 1482 if (argc < 2) return usage("-H requires an argument"); 1483 server_host_str = argv[1]; 1484 argc--; 1485 argv++; 1486 } else { 1487 server_host_str = argv[0] + 2; 1488 } 1489 } else if (!strncmp(argv[0], "-P", 2)) { 1490 if (argv[0][2] == '\0') { 1491 if (argc < 2) return usage("-P requires an argument"); 1492 server_port_str = argv[1]; 1493 argc--; 1494 argv++; 1495 } else { 1496 server_port_str = argv[0] + 2; 1497 } 1498 } else if (!strcmp(argv[0], "-L")) { 1499 if (argc < 2) return usage("-L requires an argument"); 1500 server_socket_str = argv[1]; 1501 argc--; 1502 argv++; 1503 } else { 1504 /* out of recognized modifiers and flags */ 1505 break; 1506 } 1507 argc--; 1508 argv++; 1509 } 1510 1511 if ((server_host_str || server_port_str) && server_socket_str) { 1512 fprintf(stderr, "adb: -L is incompatible with -H or -P\n"); 1513 exit(1); 1514 } 1515 1516 // If -L, -H, or -P are specified, ignore environment variables. 1517 // Otherwise, prefer ADB_SERVER_SOCKET over ANDROID_ADB_SERVER_ADDRESS/PORT. 1518 if (!server_host_str && !server_port_str && !server_socket_str) { 1519 server_socket_str = getenv("ADB_SERVER_SOCKET"); 1520 } 1521 1522 if (!server_socket_str) { 1523 // tcp:1234 and tcp:localhost:1234 are different with -a, so don't default to localhost 1524 server_host_str = server_host_str ? server_host_str : getenv("ANDROID_ADB_SERVER_ADDRESS"); 1525 1526 int server_port = DEFAULT_ADB_PORT; 1527 server_port_str = server_port_str ? server_port_str : getenv("ANDROID_ADB_SERVER_PORT"); 1528 if (server_port_str && strlen(server_port_str) > 0) { 1529 if (!android::base::ParseInt(server_port_str, &server_port, 1, 65535)) { 1530 fprintf(stderr, 1531 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive" 1532 " number less than 65535. Got \"%s\"\n", 1533 server_port_str); 1534 exit(1); 1535 } 1536 } 1537 1538 int rc; 1539 char* temp; 1540 if (server_host_str) { 1541 rc = asprintf(&temp, "tcp:%s:%d", server_host_str, server_port); 1542 } else { 1543 rc = asprintf(&temp, "tcp:%d", server_port); 1544 } 1545 if (rc < 0) { 1546 fatal("failed to allocate server socket specification"); 1547 } 1548 server_socket_str = temp; 1549 } 1550 1551 adb_set_socket_spec(server_socket_str); 1552 1553 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1554 if (transport_type == kTransportAny && serial == nullptr) { 1555 serial = getenv("ANDROID_SERIAL"); 1556 } 1557 1558 adb_set_transport(transport_type, serial); 1559 1560 if (is_server) { 1561 if (no_daemon || is_daemon) { 1562 if (is_daemon && (ack_reply_fd == -1)) { 1563 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1564 return 1; 1565 } 1566 r = adb_server_main(is_daemon, server_socket_str, ack_reply_fd); 1567 } else { 1568 r = launch_server(server_socket_str); 1569 } 1570 if (r) { 1571 fprintf(stderr,"* could not start server *\n"); 1572 } 1573 return r; 1574 } 1575 1576 if (argc == 0) { 1577 help(); 1578 return 1; 1579 } 1580 1581 /* handle wait-for-* prefix */ 1582 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1583 const char* service = argv[0]; 1584 1585 if (!wait_for_device(service, transport_type, serial)) { 1586 return 1; 1587 } 1588 1589 // Allow a command to be run after wait-for-device, 1590 // e.g. 'adb wait-for-device shell'. 1591 if (argc == 1) { 1592 return 0; 1593 } 1594 1595 /* Fall through */ 1596 argc--; 1597 argv++; 1598 } 1599 1600 /* adb_connect() commands */ 1601 if (!strcmp(argv[0], "devices")) { 1602 const char *listopt; 1603 if (argc < 2) { 1604 listopt = ""; 1605 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1606 listopt = argv[1]; 1607 } else { 1608 fprintf(stderr, "Usage: adb devices [-l]\n"); 1609 return 1; 1610 } 1611 1612 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1613 printf("List of devices attached\n"); 1614 return adb_query_command(query); 1615 } 1616 else if (!strcmp(argv[0], "connect")) { 1617 if (argc != 2) { 1618 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1619 return 1; 1620 } 1621 1622 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1623 return adb_query_command(query); 1624 } 1625 else if (!strcmp(argv[0], "disconnect")) { 1626 if (argc > 2) { 1627 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1628 return 1; 1629 } 1630 1631 std::string query = android::base::StringPrintf("host:disconnect:%s", 1632 (argc == 2) ? argv[1] : ""); 1633 return adb_query_command(query); 1634 } 1635 else if (!strcmp(argv[0], "emu")) { 1636 return adb_send_emulator_command(argc, argv, serial); 1637 } 1638 else if (!strcmp(argv[0], "shell")) { 1639 return adb_shell(argc, argv); 1640 } 1641 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1642 int exec_in = !strcmp(argv[0], "exec-in"); 1643 1644 if (argc < 2) { 1645 fprintf(stderr, "Usage: adb %s command\n", argv[0]); 1646 return 1; 1647 } 1648 1649 std::string cmd = "exec:"; 1650 cmd += argv[1]; 1651 argc -= 2; 1652 argv += 2; 1653 while (argc-- > 0) { 1654 cmd += " " + escape_arg(*argv++); 1655 } 1656 1657 std::string error; 1658 int fd = adb_connect(cmd, &error); 1659 if (fd < 0) { 1660 fprintf(stderr, "error: %s\n", error.c_str()); 1661 return -1; 1662 } 1663 1664 if (exec_in) { 1665 copy_to_file(STDIN_FILENO, fd); 1666 } else { 1667 copy_to_file(fd, STDOUT_FILENO); 1668 } 1669 1670 adb_close(fd); 1671 return 0; 1672 } 1673 else if (!strcmp(argv[0], "kill-server")) { 1674 std::string error; 1675 int fd = _adb_connect("host:kill", &error); 1676 if (fd == -2) { 1677 // Failed to make network connection to server. Don't output the 1678 // network error since that is expected. 1679 fprintf(stderr,"* server not running *\n"); 1680 // Successful exit code because the server is already "killed". 1681 return 0; 1682 } else if (fd == -1) { 1683 // Some other error. 1684 fprintf(stderr, "error: %s\n", error.c_str()); 1685 return 1; 1686 } else { 1687 // Successfully connected, kill command sent, okay status came back. 1688 // Server should exit() in a moment, if not already. 1689 ReadOrderlyShutdown(fd); 1690 adb_close(fd); 1691 return 0; 1692 } 1693 } 1694 else if (!strcmp(argv[0], "sideload")) { 1695 if (argc != 2) return usage("sideload requires an argument"); 1696 if (adb_sideload_host(argv[1])) { 1697 return 1; 1698 } else { 1699 return 0; 1700 } 1701 } 1702 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1703 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1704 } 1705 else if (!strcmp(argv[0], "remount") || 1706 !strcmp(argv[0], "reboot") || 1707 !strcmp(argv[0], "reboot-bootloader") || 1708 !strcmp(argv[0], "usb") || 1709 !strcmp(argv[0], "disable-verity") || 1710 !strcmp(argv[0], "enable-verity")) { 1711 std::string command; 1712 if (!strcmp(argv[0], "reboot-bootloader")) { 1713 command = "reboot:bootloader"; 1714 } else if (argc > 1) { 1715 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1716 } else { 1717 command = android::base::StringPrintf("%s:", argv[0]); 1718 } 1719 return adb_connect_command(command); 1720 } else if (!strcmp(argv[0], "root") || !strcmp(argv[0], "unroot")) { 1721 return adb_root(argv[0]) ? 0 : 1; 1722 } else if (!strcmp(argv[0], "bugreport")) { 1723 Bugreport bugreport; 1724 return bugreport.DoIt(transport_type, serial, argc, argv); 1725 } else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1726 bool reverse = !strcmp(argv[0], "reverse"); 1727 ++argv; 1728 --argc; 1729 if (argc < 1) return usage("%s requires an argument", argv[0]); 1730 1731 // Determine the <host-prefix> for this command. 1732 std::string host_prefix; 1733 if (reverse) { 1734 host_prefix = "reverse"; 1735 } else { 1736 if (serial) { 1737 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1738 } else if (transport_type == kTransportUsb) { 1739 host_prefix = "host-usb"; 1740 } else if (transport_type == kTransportLocal) { 1741 host_prefix = "host-local"; 1742 } else { 1743 host_prefix = "host"; 1744 } 1745 } 1746 1747 std::string cmd, error; 1748 if (strcmp(argv[0], "--list") == 0) { 1749 if (argc != 1) return usage("--list doesn't take any arguments"); 1750 return adb_query_command(host_prefix + ":list-forward"); 1751 } else if (strcmp(argv[0], "--remove-all") == 0) { 1752 if (argc != 1) return usage("--remove-all doesn't take any arguments"); 1753 cmd = host_prefix + ":killforward-all"; 1754 } else if (strcmp(argv[0], "--remove") == 0) { 1755 // forward --remove <local> 1756 if (argc != 2) return usage("--remove requires an argument"); 1757 cmd = host_prefix + ":killforward:" + argv[1]; 1758 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1759 // forward --no-rebind <local> <remote> 1760 if (argc != 3) return usage("--no-rebind takes two arguments"); 1761 if (forward_targets_are_valid(argv[1], argv[2], &error)) { 1762 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1763 } 1764 } else { 1765 // forward <local> <remote> 1766 if (argc != 2) return usage("forward takes two arguments"); 1767 if (forward_targets_are_valid(argv[0], argv[1], &error)) { 1768 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1769 } 1770 } 1771 1772 if (!error.empty()) { 1773 fprintf(stderr, "error: %s\n", error.c_str()); 1774 return 1; 1775 } 1776 1777 int fd = adb_connect(cmd, &error); 1778 if (fd < 0 || !adb_status(fd, &error)) { 1779 adb_close(fd); 1780 fprintf(stderr, "error: %s\n", error.c_str()); 1781 return 1; 1782 } 1783 1784 // Server or device may optionally return a resolved TCP port number. 1785 std::string resolved_port; 1786 if (ReadProtocolString(fd, &resolved_port, &error) && !resolved_port.empty()) { 1787 printf("%s\n", resolved_port.c_str()); 1788 } 1789 1790 ReadOrderlyShutdown(fd); 1791 return 0; 1792 } 1793 /* do_sync_*() commands */ 1794 else if (!strcmp(argv[0], "ls")) { 1795 if (argc != 2) return usage("ls requires an argument"); 1796 return do_sync_ls(argv[1]) ? 0 : 1; 1797 } 1798 else if (!strcmp(argv[0], "push")) { 1799 bool copy_attrs = false; 1800 std::vector<const char*> srcs; 1801 const char* dst = nullptr; 1802 1803 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1804 if (srcs.empty() || !dst) return usage("push requires an argument"); 1805 return do_sync_push(srcs, dst) ? 0 : 1; 1806 } 1807 else if (!strcmp(argv[0], "pull")) { 1808 bool copy_attrs = false; 1809 std::vector<const char*> srcs; 1810 const char* dst = "."; 1811 1812 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1813 if (srcs.empty()) return usage("pull requires an argument"); 1814 return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1; 1815 } 1816 else if (!strcmp(argv[0], "install")) { 1817 if (argc < 2) return usage("install requires an argument"); 1818 if (_use_legacy_install()) { 1819 return install_app_legacy(transport_type, serial, argc, argv); 1820 } 1821 return install_app(transport_type, serial, argc, argv); 1822 } 1823 else if (!strcmp(argv[0], "install-multiple")) { 1824 if (argc < 2) return usage("install-multiple requires an argument"); 1825 return install_multiple_app(transport_type, serial, argc, argv); 1826 } 1827 else if (!strcmp(argv[0], "uninstall")) { 1828 if (argc < 2) return usage("uninstall requires an argument"); 1829 if (_use_legacy_install()) { 1830 return uninstall_app_legacy(transport_type, serial, argc, argv); 1831 } 1832 return uninstall_app(transport_type, serial, argc, argv); 1833 } 1834 else if (!strcmp(argv[0], "sync")) { 1835 std::string src; 1836 bool list_only = false; 1837 if (argc < 2) { 1838 // No local path was specified. 1839 src = ""; 1840 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1841 list_only = true; 1842 if (argc == 3) { 1843 src = argv[2]; 1844 } else { 1845 src = ""; 1846 } 1847 } else if (argc == 2) { 1848 // A local path or "android"/"data" arg was specified. 1849 src = argv[1]; 1850 } else { 1851 return usage("usage: adb sync [-l] [PARTITION]"); 1852 } 1853 1854 if (src != "" && 1855 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1856 return usage("don't know how to sync %s partition", src.c_str()); 1857 } 1858 1859 std::string system_src_path = product_file("system"); 1860 std::string data_src_path = product_file("data"); 1861 std::string vendor_src_path = product_file("vendor"); 1862 std::string oem_src_path = product_file("oem"); 1863 1864 bool okay = true; 1865 if (okay && (src.empty() || src == "system")) { 1866 okay = do_sync_sync(system_src_path, "/system", list_only); 1867 } 1868 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1869 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1870 } 1871 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1872 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1873 } 1874 if (okay && (src.empty() || src == "data")) { 1875 okay = do_sync_sync(data_src_path, "/data", list_only); 1876 } 1877 return okay ? 0 : 1; 1878 } 1879 /* passthrough commands */ 1880 else if (!strcmp(argv[0],"get-state") || 1881 !strcmp(argv[0],"get-serialno") || 1882 !strcmp(argv[0],"get-devpath")) 1883 { 1884 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1885 } 1886 /* other commands */ 1887 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1888 return logcat(transport_type, serial, argc, argv); 1889 } 1890 else if (!strcmp(argv[0],"ppp")) { 1891 return ppp(argc, argv); 1892 } 1893 else if (!strcmp(argv[0], "start-server")) { 1894 std::string error; 1895 const int result = adb_connect("host:start-server", &error); 1896 if (result < 0) { 1897 fprintf(stderr, "error: %s\n", error.c_str()); 1898 } 1899 return result; 1900 } 1901 else if (!strcmp(argv[0], "backup")) { 1902 return backup(argc, argv); 1903 } 1904 else if (!strcmp(argv[0], "restore")) { 1905 return restore(argc, argv); 1906 } 1907 else if (!strcmp(argv[0], "keygen")) { 1908 if (argc != 2) return usage("keygen requires an argument"); 1909 // Always print key generation information for keygen command. 1910 adb_trace_enable(AUTH); 1911 return adb_auth_keygen(argv[1]); 1912 } 1913 else if (!strcmp(argv[0], "jdwp")) { 1914 return adb_connect_command("jdwp"); 1915 } 1916 else if (!strcmp(argv[0], "track-jdwp")) { 1917 return adb_connect_command("track-jdwp"); 1918 } 1919 else if (!strcmp(argv[0], "track-devices")) { 1920 return adb_connect_command("host:track-devices"); 1921 } 1922 1923 1924 /* "adb /?" is a common idiom under Windows */ 1925 else if (!strcmp(argv[0], "--help") || !strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1926 help(); 1927 return 0; 1928 } 1929 else if (!strcmp(argv[0], "--version") || !strcmp(argv[0], "version")) { 1930 fprintf(stdout, "%s", adb_version().c_str()); 1931 return 0; 1932 } 1933 else if (!strcmp(argv[0], "features")) { 1934 // Only list the features common to both the adb client and the device. 1935 FeatureSet features; 1936 std::string error; 1937 if (!adb_get_feature_set(&features, &error)) { 1938 fprintf(stderr, "error: %s\n", error.c_str()); 1939 return 1; 1940 } 1941 1942 for (const std::string& name : features) { 1943 if (CanUseFeature(features, name)) { 1944 printf("%s\n", name.c_str()); 1945 } 1946 } 1947 return 0; 1948 } else if (!strcmp(argv[0], "reconnect")) { 1949 if (argc == 1) { 1950 return adb_query_command("host:reconnect"); 1951 } else if (argc == 2) { 1952 if (!strcmp(argv[1], "device")) { 1953 std::string err; 1954 adb_connect("reconnect", &err); 1955 return 0; 1956 } else if (!strcmp(argv[1], "offline")) { 1957 std::string err; 1958 return adb_query_command("host:reconnect-offline"); 1959 } else { 1960 return usage("usage: adb reconnect [device|offline]"); 1961 } 1962 } 1963 } 1964 1965 usage("unknown command %s", argv[0]); 1966 return 1; 1967} 1968 1969static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1970 // 'adb uninstall' takes the same arguments as 'cmd package uninstall' on device 1971 std::string cmd = "cmd package"; 1972 while (argc-- > 0) { 1973 // deny the '-k' option until the remaining data/cache can be removed with adb/UI 1974 if (strcmp(*argv, "-k") == 0) { 1975 printf( 1976 "The -k option uninstalls the application while retaining the data/cache.\n" 1977 "At the moment, there is no way to remove the remaining data.\n" 1978 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1979 "If you truly wish to continue, execute 'adb shell cmd package uninstall -k'.\n"); 1980 return EXIT_FAILURE; 1981 } 1982 cmd += " " + escape_arg(*argv++); 1983 } 1984 1985 return send_shell_command(transport, serial, cmd, false); 1986} 1987 1988static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1989 // The last argument must be the APK file 1990 const char* file = argv[argc - 1]; 1991 if (!android::base::EndsWithIgnoreCase(file, ".apk")) { 1992 fprintf(stderr, "Filename doesn't end .apk: %s\n", file); 1993 return EXIT_FAILURE; 1994 } 1995 1996 struct stat sb; 1997 if (stat(file, &sb) == -1) { 1998 fprintf(stderr, "Failed to stat %s: %s\n", file, strerror(errno)); 1999 return 1; 2000 } 2001 2002 int localFd = adb_open(file, O_RDONLY); 2003 if (localFd < 0) { 2004 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 2005 return 1; 2006 } 2007 2008 std::string error; 2009 std::string cmd = "exec:cmd package"; 2010 2011 // don't copy the APK name, but, copy the rest of the arguments as-is 2012 while (argc-- > 1) { 2013 cmd += " " + escape_arg(std::string(*argv++)); 2014 } 2015 2016 // add size parameter [required for streaming installs] 2017 // do last to override any user specified value 2018 cmd += " " + android::base::StringPrintf("-S %" PRIu64, static_cast<uint64_t>(sb.st_size)); 2019 2020 int remoteFd = adb_connect(cmd, &error); 2021 if (remoteFd < 0) { 2022 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 2023 adb_close(localFd); 2024 return 1; 2025 } 2026 2027 char buf[BUFSIZ]; 2028 copy_to_file(localFd, remoteFd); 2029 read_status_line(remoteFd, buf, sizeof(buf)); 2030 2031 adb_close(localFd); 2032 adb_close(remoteFd); 2033 2034 if (strncmp("Success", buf, 7)) { 2035 fprintf(stderr, "Failed to install %s: %s", file, buf); 2036 return 1; 2037 } 2038 fputs(buf, stderr); 2039 return 0; 2040} 2041 2042static int install_multiple_app(TransportType transport, const char* serial, int argc, 2043 const char** argv) 2044{ 2045 // Find all APK arguments starting at end. 2046 // All other arguments passed through verbatim. 2047 int first_apk = -1; 2048 uint64_t total_size = 0; 2049 for (int i = argc - 1; i >= 0; i--) { 2050 const char* file = argv[i]; 2051 2052 if (android::base::EndsWithIgnoreCase(file, ".apk")) { 2053 struct stat sb; 2054 if (stat(file, &sb) != -1) total_size += sb.st_size; 2055 first_apk = i; 2056 } else { 2057 break; 2058 } 2059 } 2060 2061 if (first_apk == -1) { 2062 fprintf(stderr, "No APK file on command line\n"); 2063 return 1; 2064 } 2065 2066 std::string install_cmd; 2067 if (_use_legacy_install()) { 2068 install_cmd = "exec:pm"; 2069 } else { 2070 install_cmd = "exec:cmd package"; 2071 } 2072 2073 std::string cmd = android::base::StringPrintf("%s install-create -S %" PRIu64, install_cmd.c_str(), total_size); 2074 for (int i = 1; i < first_apk; i++) { 2075 cmd += " " + escape_arg(argv[i]); 2076 } 2077 2078 // Create install session 2079 std::string error; 2080 int fd = adb_connect(cmd, &error); 2081 if (fd < 0) { 2082 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 2083 return EXIT_FAILURE; 2084 } 2085 char buf[BUFSIZ]; 2086 read_status_line(fd, buf, sizeof(buf)); 2087 adb_close(fd); 2088 2089 int session_id = -1; 2090 if (!strncmp("Success", buf, 7)) { 2091 char* start = strrchr(buf, '['); 2092 char* end = strrchr(buf, ']'); 2093 if (start && end) { 2094 *end = '\0'; 2095 session_id = strtol(start + 1, NULL, 10); 2096 } 2097 } 2098 if (session_id < 0) { 2099 fprintf(stderr, "Failed to create session\n"); 2100 fputs(buf, stderr); 2101 return EXIT_FAILURE; 2102 } 2103 2104 // Valid session, now stream the APKs 2105 int success = 1; 2106 for (int i = first_apk; i < argc; i++) { 2107 const char* file = argv[i]; 2108 struct stat sb; 2109 if (stat(file, &sb) == -1) { 2110 fprintf(stderr, "Failed to stat %s: %s\n", file, strerror(errno)); 2111 success = 0; 2112 goto finalize_session; 2113 } 2114 2115 std::string cmd = android::base::StringPrintf( 2116 "%s install-write -S %" PRIu64 " %d %d_%s -", 2117 install_cmd.c_str(), static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 2118 2119 int localFd = adb_open(file, O_RDONLY); 2120 if (localFd < 0) { 2121 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 2122 success = 0; 2123 goto finalize_session; 2124 } 2125 2126 std::string error; 2127 int remoteFd = adb_connect(cmd, &error); 2128 if (remoteFd < 0) { 2129 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 2130 adb_close(localFd); 2131 success = 0; 2132 goto finalize_session; 2133 } 2134 2135 copy_to_file(localFd, remoteFd); 2136 read_status_line(remoteFd, buf, sizeof(buf)); 2137 2138 adb_close(localFd); 2139 adb_close(remoteFd); 2140 2141 if (strncmp("Success", buf, 7)) { 2142 fprintf(stderr, "Failed to write %s\n", file); 2143 fputs(buf, stderr); 2144 success = 0; 2145 goto finalize_session; 2146 } 2147 } 2148 2149finalize_session: 2150 // Commit session if we streamed everything okay; otherwise abandon 2151 std::string service = 2152 android::base::StringPrintf("%s install-%s %d", 2153 install_cmd.c_str(), success ? "commit" : "abandon", session_id); 2154 fd = adb_connect(service, &error); 2155 if (fd < 0) { 2156 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 2157 return EXIT_FAILURE; 2158 } 2159 read_status_line(fd, buf, sizeof(buf)); 2160 adb_close(fd); 2161 2162 if (!strncmp("Success", buf, 7)) { 2163 fputs(buf, stderr); 2164 return 0; 2165 } else { 2166 fprintf(stderr, "Failed to finalize session\n"); 2167 fputs(buf, stderr); 2168 return EXIT_FAILURE; 2169 } 2170} 2171 2172static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 2173 std::string cmd = "pm"; 2174 2175 while (argc-- > 0) { 2176 cmd += " " + escape_arg(*argv++); 2177 } 2178 2179 return send_shell_command(transport, serial, cmd, false); 2180} 2181 2182static int uninstall_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2183 /* if the user choose the -k option, we refuse to do it until devices are 2184 out with the option to uninstall the remaining data somehow (adb/ui) */ 2185 int i; 2186 for (i = 1; i < argc; i++) { 2187 if (!strcmp(argv[i], "-k")) { 2188 printf( 2189 "The -k option uninstalls the application while retaining the data/cache.\n" 2190 "At the moment, there is no way to remove the remaining data.\n" 2191 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 2192 "If you truly wish to continue, execute 'adb shell pm uninstall -k'\n."); 2193 return EXIT_FAILURE; 2194 } 2195 } 2196 2197 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 2198 return pm_command(transport, serial, argc, argv); 2199} 2200 2201static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 2202 std::string cmd = "rm -f " + escape_arg(filename); 2203 return send_shell_command(transport, serial, cmd, false); 2204} 2205 2206static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2207 static const char *const DATA_DEST = "/data/local/tmp/%s"; 2208 static const char *const SD_DEST = "/sdcard/tmp/%s"; 2209 const char* where = DATA_DEST; 2210 2211 for (int i = 1; i < argc; i++) { 2212 if (!strcmp(argv[i], "-s")) { 2213 where = SD_DEST; 2214 } 2215 } 2216 2217 // Find last APK argument. 2218 // All other arguments passed through verbatim. 2219 int last_apk = -1; 2220 for (int i = argc - 1; i >= 0; i--) { 2221 if (android::base::EndsWithIgnoreCase(argv[i], ".apk")) { 2222 last_apk = i; 2223 break; 2224 } 2225 } 2226 2227 if (last_apk == -1) { 2228 fprintf(stderr, "No APK file on command line\n"); 2229 return EXIT_FAILURE; 2230 } 2231 2232 int result = -1; 2233 std::vector<const char*> apk_file = {argv[last_apk]}; 2234 std::string apk_dest = android::base::StringPrintf( 2235 where, adb_basename(argv[last_apk]).c_str()); 2236 if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk; 2237 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 2238 result = pm_command(transport, serial, argc, argv); 2239 2240cleanup_apk: 2241 delete_file(transport, serial, apk_dest); 2242 return result; 2243} 2244