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