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 60 static int install_app(TransportType t, const char* serial, int argc, const char** argv); 61 static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv); 62 static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv); 63 static int install_app_legacy(TransportType t, const char* serial, int argc, const char** argv); 64 static int uninstall_app_legacy(TransportType t, const char* serial, int argc, const char** argv); 65 66 static auto& gProductOutPath = *new std::string(); 67 extern int gListenAll; 68 69 DefaultStandardStreamsCallback DEFAULT_STANDARD_STREAMS_CALLBACK(nullptr, nullptr); 70 71 static 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 82 static 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 259 int usage() { 260 help(); 261 return 1; 262 } 263 264 #if defined(_WIN32) 265 266 // Implemented in sysdeps_win32.cpp. 267 void stdin_raw_init(); 268 void stdin_raw_restore(); 269 270 #else 271 static termios g_saved_terminal_state; 272 273 static 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 288 static 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. 298 int 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 351 static 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 366 static 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 387 static 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 406 static 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 448 static 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. 492 struct 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. 502 static 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. 609 static 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. 640 static 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 713 static 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 815 static 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 */ 887 static 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 */ 983 static 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 1045 static 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 1082 static 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 1127 int 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 1173 static 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 1193 static 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 1216 static 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 1275 static 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 */ 1318 static 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 1366 static 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 1398 static 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 1410 static 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. 1422 static 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 1433 int adb_commandline(int argc, const char **argv) { 1434 int no_daemon = 0; 1435 int is_daemon = 0; 1436 int is_server = 0; 1437 int r; 1438 TransportType transport_type = kTransportAny; 1439 int ack_reply_fd = -1; 1440 1441 #if !defined(_WIN32) 1442 // We'd rather have EPIPE than SIGPIPE. 1443 signal(SIGPIPE, SIG_IGN); 1444 #endif 1445 1446 // If defined, this should be an absolute path to 1447 // the directory containing all of the various system images 1448 // for a particular product. If not defined, and the adb 1449 // command requires this information, then the user must 1450 // specify the path using "-p". 1451 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1452 if (ANDROID_PRODUCT_OUT != nullptr) { 1453 gProductOutPath = ANDROID_PRODUCT_OUT; 1454 } 1455 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1456 1457 /* Validate and assign the server port */ 1458 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1459 int server_port = DEFAULT_ADB_PORT; 1460 if (server_port_str && strlen(server_port_str) > 0) { 1461 server_port = strtol(server_port_str, nullptr, 0); 1462 if (server_port <= 0 || server_port > 65535) { 1463 fprintf(stderr, 1464 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1465 server_port_str); 1466 return usage(); 1467 } 1468 } 1469 1470 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1471 const char* serial = nullptr; 1472 1473 while (argc > 0) { 1474 if (!strcmp(argv[0],"server")) { 1475 is_server = 1; 1476 } else if (!strcmp(argv[0],"nodaemon")) { 1477 no_daemon = 1; 1478 } else if (!strcmp(argv[0], "fork-server")) { 1479 /* this is a special flag used only when the ADB client launches the ADB Server */ 1480 is_daemon = 1; 1481 } else if (!strcmp(argv[0], "--reply-fd")) { 1482 if (argc < 2) return usage(); 1483 const char* reply_fd_str = argv[1]; 1484 argc--; 1485 argv++; 1486 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1487 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1488 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1489 return usage(); 1490 } 1491 } else if (!strncmp(argv[0], "-p", 2)) { 1492 const char* product = nullptr; 1493 if (argv[0][2] == '\0') { 1494 if (argc < 2) return usage(); 1495 product = argv[1]; 1496 argc--; 1497 argv++; 1498 } else { 1499 product = argv[0] + 2; 1500 } 1501 gProductOutPath = find_product_out_path(product); 1502 if (gProductOutPath.empty()) { 1503 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1504 return usage(); 1505 } 1506 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1507 if (isdigit(argv[0][2])) { 1508 serial = argv[0] + 2; 1509 } else { 1510 if (argc < 2 || argv[0][2] != '\0') return usage(); 1511 serial = argv[1]; 1512 argc--; 1513 argv++; 1514 } 1515 } else if (!strcmp(argv[0],"-d")) { 1516 transport_type = kTransportUsb; 1517 } else if (!strcmp(argv[0],"-e")) { 1518 transport_type = kTransportLocal; 1519 } else if (!strcmp(argv[0],"-a")) { 1520 gListenAll = 1; 1521 } else if (!strncmp(argv[0], "-H", 2)) { 1522 const char *hostname = NULL; 1523 if (argv[0][2] == '\0') { 1524 if (argc < 2) return usage(); 1525 hostname = argv[1]; 1526 argc--; 1527 argv++; 1528 } else { 1529 hostname = argv[0] + 2; 1530 } 1531 adb_set_tcp_name(hostname); 1532 1533 } else if (!strncmp(argv[0], "-P", 2)) { 1534 if (argv[0][2] == '\0') { 1535 if (argc < 2) return usage(); 1536 server_port_str = argv[1]; 1537 argc--; 1538 argv++; 1539 } else { 1540 server_port_str = argv[0] + 2; 1541 } 1542 if (strlen(server_port_str) > 0) { 1543 server_port = (int) strtol(server_port_str, NULL, 0); 1544 if (server_port <= 0 || server_port > 65535) { 1545 fprintf(stderr, 1546 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1547 server_port_str); 1548 return usage(); 1549 } 1550 } else { 1551 fprintf(stderr, 1552 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1553 return usage(); 1554 } 1555 } else { 1556 /* out of recognized modifiers and flags */ 1557 break; 1558 } 1559 argc--; 1560 argv++; 1561 } 1562 1563 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1564 if (transport_type == kTransportAny && serial == nullptr) { 1565 serial = getenv("ANDROID_SERIAL"); 1566 } 1567 1568 adb_set_transport(transport_type, serial); 1569 adb_set_tcp_specifics(server_port); 1570 1571 if (is_server) { 1572 if (no_daemon || is_daemon) { 1573 if (is_daemon && (ack_reply_fd == -1)) { 1574 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1575 return usage(); 1576 } 1577 r = adb_server_main(is_daemon, server_port, ack_reply_fd); 1578 } else { 1579 r = launch_server(server_port); 1580 } 1581 if (r) { 1582 fprintf(stderr,"* could not start server *\n"); 1583 } 1584 return r; 1585 } 1586 1587 if (argc == 0) { 1588 return usage(); 1589 } 1590 1591 /* handle wait-for-* prefix */ 1592 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1593 const char* service = argv[0]; 1594 1595 if (!wait_for_device(service, transport_type, serial)) { 1596 return 1; 1597 } 1598 1599 // Allow a command to be run after wait-for-device, 1600 // e.g. 'adb wait-for-device shell'. 1601 if (argc == 1) { 1602 return 0; 1603 } 1604 1605 /* Fall through */ 1606 argc--; 1607 argv++; 1608 } 1609 1610 /* adb_connect() commands */ 1611 if (!strcmp(argv[0], "devices")) { 1612 const char *listopt; 1613 if (argc < 2) { 1614 listopt = ""; 1615 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1616 listopt = argv[1]; 1617 } else { 1618 fprintf(stderr, "Usage: adb devices [-l]\n"); 1619 return 1; 1620 } 1621 1622 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1623 printf("List of devices attached\n"); 1624 return adb_query_command(query); 1625 } 1626 else if (!strcmp(argv[0], "connect")) { 1627 if (argc != 2) { 1628 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1629 return 1; 1630 } 1631 1632 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1633 return adb_query_command(query); 1634 } 1635 else if (!strcmp(argv[0], "disconnect")) { 1636 if (argc > 2) { 1637 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1638 return 1; 1639 } 1640 1641 std::string query = android::base::StringPrintf("host:disconnect:%s", 1642 (argc == 2) ? argv[1] : ""); 1643 return adb_query_command(query); 1644 } 1645 else if (!strcmp(argv[0], "emu")) { 1646 return adb_send_emulator_command(argc, argv, serial); 1647 } 1648 else if (!strcmp(argv[0], "shell")) { 1649 return adb_shell(argc, argv); 1650 } 1651 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1652 int exec_in = !strcmp(argv[0], "exec-in"); 1653 1654 std::string cmd = "exec:"; 1655 cmd += argv[1]; 1656 argc -= 2; 1657 argv += 2; 1658 while (argc-- > 0) { 1659 cmd += " " + escape_arg(*argv++); 1660 } 1661 1662 std::string error; 1663 int fd = adb_connect(cmd, &error); 1664 if (fd < 0) { 1665 fprintf(stderr, "error: %s\n", error.c_str()); 1666 return -1; 1667 } 1668 1669 if (exec_in) { 1670 copy_to_file(STDIN_FILENO, fd); 1671 } else { 1672 copy_to_file(fd, STDOUT_FILENO); 1673 } 1674 1675 adb_close(fd); 1676 return 0; 1677 } 1678 else if (!strcmp(argv[0], "kill-server")) { 1679 std::string error; 1680 int fd = _adb_connect("host:kill", &error); 1681 if (fd == -2) { 1682 // Failed to make network connection to server. Don't output the 1683 // network error since that is expected. 1684 fprintf(stderr,"* server not running *\n"); 1685 // Successful exit code because the server is already "killed". 1686 return 0; 1687 } else if (fd == -1) { 1688 // Some other error. 1689 fprintf(stderr, "error: %s\n", error.c_str()); 1690 return 1; 1691 } else { 1692 // Successfully connected, kill command sent, okay status came back. 1693 // Server should exit() in a moment, if not already. 1694 ReadOrderlyShutdown(fd); 1695 adb_close(fd); 1696 return 0; 1697 } 1698 } 1699 else if (!strcmp(argv[0], "sideload")) { 1700 if (argc != 2) return usage(); 1701 if (adb_sideload_host(argv[1])) { 1702 return 1; 1703 } else { 1704 return 0; 1705 } 1706 } 1707 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1708 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1709 } 1710 else if (!strcmp(argv[0], "remount") || 1711 !strcmp(argv[0], "reboot") || 1712 !strcmp(argv[0], "reboot-bootloader") || 1713 !strcmp(argv[0], "usb") || 1714 !strcmp(argv[0], "disable-verity") || 1715 !strcmp(argv[0], "enable-verity")) { 1716 std::string command; 1717 if (!strcmp(argv[0], "reboot-bootloader")) { 1718 command = "reboot:bootloader"; 1719 } else if (argc > 1) { 1720 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1721 } else { 1722 command = android::base::StringPrintf("%s:", argv[0]); 1723 } 1724 return adb_connect_command(command); 1725 } else if (!strcmp(argv[0], "root") || !strcmp(argv[0], "unroot")) { 1726 return adb_root(argv[0]) ? 0 : 1; 1727 } else if (!strcmp(argv[0], "bugreport")) { 1728 Bugreport bugreport; 1729 return bugreport.DoIt(transport_type, serial, argc, argv); 1730 } else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1731 bool reverse = !strcmp(argv[0], "reverse"); 1732 ++argv; 1733 --argc; 1734 if (argc < 1) return usage(); 1735 1736 // Determine the <host-prefix> for this command. 1737 std::string host_prefix; 1738 if (reverse) { 1739 host_prefix = "reverse"; 1740 } else { 1741 if (serial) { 1742 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1743 } else if (transport_type == kTransportUsb) { 1744 host_prefix = "host-usb"; 1745 } else if (transport_type == kTransportLocal) { 1746 host_prefix = "host-local"; 1747 } else { 1748 host_prefix = "host"; 1749 } 1750 } 1751 1752 std::string cmd; 1753 if (strcmp(argv[0], "--list") == 0) { 1754 if (argc != 1) return usage(); 1755 return adb_query_command(host_prefix + ":list-forward"); 1756 } else if (strcmp(argv[0], "--remove-all") == 0) { 1757 if (argc != 1) return usage(); 1758 cmd = host_prefix + ":killforward-all"; 1759 } else if (strcmp(argv[0], "--remove") == 0) { 1760 // forward --remove <local> 1761 if (argc != 2) return usage(); 1762 cmd = host_prefix + ":killforward:" + argv[1]; 1763 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1764 // forward --no-rebind <local> <remote> 1765 if (argc != 3) return usage(); 1766 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1767 } else { 1768 // forward <local> <remote> 1769 if (argc != 2) return usage(); 1770 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1771 } 1772 1773 return adb_command(cmd) ? 0 : 1; 1774 } 1775 /* do_sync_*() commands */ 1776 else if (!strcmp(argv[0], "ls")) { 1777 if (argc != 2) return usage(); 1778 return do_sync_ls(argv[1]) ? 0 : 1; 1779 } 1780 else if (!strcmp(argv[0], "push")) { 1781 bool copy_attrs = false; 1782 std::vector<const char*> srcs; 1783 const char* dst = nullptr; 1784 1785 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1786 if (srcs.empty() || !dst) return usage(); 1787 return do_sync_push(srcs, dst) ? 0 : 1; 1788 } 1789 else if (!strcmp(argv[0], "pull")) { 1790 bool copy_attrs = false; 1791 std::vector<const char*> srcs; 1792 const char* dst = "."; 1793 1794 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1795 if (srcs.empty()) return usage(); 1796 return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1; 1797 } 1798 else if (!strcmp(argv[0], "install")) { 1799 if (argc < 2) return usage(); 1800 FeatureSet features; 1801 std::string error; 1802 if (!adb_get_feature_set(&features, &error)) { 1803 fprintf(stderr, "error: %s\n", error.c_str()); 1804 return 1; 1805 } 1806 1807 if (CanUseFeature(features, kFeatureCmd)) { 1808 return install_app(transport_type, serial, argc, argv); 1809 } 1810 return install_app_legacy(transport_type, serial, argc, argv); 1811 } 1812 else if (!strcmp(argv[0], "install-multiple")) { 1813 if (argc < 2) return usage(); 1814 return install_multiple_app(transport_type, serial, argc, argv); 1815 } 1816 else if (!strcmp(argv[0], "uninstall")) { 1817 if (argc < 2) return usage(); 1818 FeatureSet features; 1819 std::string error; 1820 if (!adb_get_feature_set(&features, &error)) { 1821 fprintf(stderr, "error: %s\n", error.c_str()); 1822 return 1; 1823 } 1824 1825 if (CanUseFeature(features, kFeatureCmd)) { 1826 return uninstall_app(transport_type, serial, argc, argv); 1827 } 1828 return uninstall_app_legacy(transport_type, serial, argc, argv); 1829 } 1830 else if (!strcmp(argv[0], "sync")) { 1831 std::string src; 1832 bool list_only = false; 1833 if (argc < 2) { 1834 // No local path was specified. 1835 src = ""; 1836 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1837 list_only = true; 1838 if (argc == 3) { 1839 src = argv[2]; 1840 } else { 1841 src = ""; 1842 } 1843 } else if (argc == 2) { 1844 // A local path or "android"/"data" arg was specified. 1845 src = argv[1]; 1846 } else { 1847 return usage(); 1848 } 1849 1850 if (src != "" && 1851 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1852 return usage(); 1853 } 1854 1855 std::string system_src_path = product_file("system"); 1856 std::string data_src_path = product_file("data"); 1857 std::string vendor_src_path = product_file("vendor"); 1858 std::string oem_src_path = product_file("oem"); 1859 1860 bool okay = true; 1861 if (okay && (src.empty() || src == "system")) { 1862 okay = do_sync_sync(system_src_path, "/system", list_only); 1863 } 1864 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1865 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1866 } 1867 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1868 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1869 } 1870 if (okay && (src.empty() || src == "data")) { 1871 okay = do_sync_sync(data_src_path, "/data", list_only); 1872 } 1873 return okay ? 0 : 1; 1874 } 1875 /* passthrough commands */ 1876 else if (!strcmp(argv[0],"get-state") || 1877 !strcmp(argv[0],"get-serialno") || 1878 !strcmp(argv[0],"get-devpath")) 1879 { 1880 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1881 } 1882 /* other commands */ 1883 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1884 return logcat(transport_type, serial, argc, argv); 1885 } 1886 else if (!strcmp(argv[0],"ppp")) { 1887 return ppp(argc, argv); 1888 } 1889 else if (!strcmp(argv[0], "start-server")) { 1890 std::string error; 1891 const int result = adb_connect("host:start-server", &error); 1892 if (result < 0) { 1893 fprintf(stderr, "error: %s\n", error.c_str()); 1894 } 1895 return result; 1896 } 1897 else if (!strcmp(argv[0], "backup")) { 1898 return backup(argc, argv); 1899 } 1900 else if (!strcmp(argv[0], "restore")) { 1901 return restore(argc, argv); 1902 } 1903 else if (!strcmp(argv[0], "keygen")) { 1904 if (argc < 2) return usage(); 1905 // Always print key generation information for keygen command. 1906 adb_trace_enable(AUTH); 1907 return adb_auth_keygen(argv[1]); 1908 } 1909 else if (!strcmp(argv[0], "jdwp")) { 1910 return adb_connect_command("jdwp"); 1911 } 1912 /* "adb /?" is a common idiom under Windows */ 1913 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1914 help(); 1915 return 0; 1916 } 1917 else if (!strcmp(argv[0], "version")) { 1918 fprintf(stdout, "%s", adb_version().c_str()); 1919 return 0; 1920 } 1921 else if (!strcmp(argv[0], "features")) { 1922 // Only list the features common to both the adb client and the device. 1923 FeatureSet features; 1924 std::string error; 1925 if (!adb_get_feature_set(&features, &error)) { 1926 fprintf(stderr, "error: %s\n", error.c_str()); 1927 return 1; 1928 } 1929 1930 for (const std::string& name : features) { 1931 if (CanUseFeature(features, name)) { 1932 printf("%s\n", name.c_str()); 1933 } 1934 } 1935 return 0; 1936 } else if (!strcmp(argv[0], "reconnect")) { 1937 if (argc == 1) { 1938 return adb_query_command("host:reconnect"); 1939 } else if (argc == 2 && !strcmp(argv[1], "device")) { 1940 std::string err; 1941 adb_connect("reconnect", &err); 1942 return 0; 1943 } 1944 } 1945 1946 usage(); 1947 return 1; 1948 } 1949 1950 static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1951 // 'adb uninstall' takes the same arguments as 'cmd package uninstall' on device 1952 std::string cmd = "cmd package"; 1953 while (argc-- > 0) { 1954 // deny the '-k' option until the remaining data/cache can be removed with adb/UI 1955 if (strcmp(*argv, "-k") == 0) { 1956 printf( 1957 "The -k option uninstalls the application while retaining the data/cache.\n" 1958 "At the moment, there is no way to remove the remaining data.\n" 1959 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1960 "If you truly wish to continue, execute 'adb shell cmd package uninstall -k'.\n"); 1961 return EXIT_FAILURE; 1962 } 1963 cmd += " " + escape_arg(*argv++); 1964 } 1965 1966 return send_shell_command(transport, serial, cmd, false); 1967 } 1968 1969 static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1970 // The last argument must be the APK file 1971 const char* file = argv[argc - 1]; 1972 const char* dot = strrchr(file, '.'); 1973 bool found_apk = false; 1974 struct stat sb; 1975 if (dot && !strcasecmp(dot, ".apk")) { 1976 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1977 fprintf(stderr, "Invalid APK file: %s\n", file); 1978 return EXIT_FAILURE; 1979 } 1980 found_apk = true; 1981 } 1982 1983 if (!found_apk) { 1984 fprintf(stderr, "Missing APK file\n"); 1985 return EXIT_FAILURE; 1986 } 1987 1988 int localFd = adb_open(file, O_RDONLY); 1989 if (localFd < 0) { 1990 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1991 return 1; 1992 } 1993 1994 std::string error; 1995 std::string cmd = "exec:cmd package"; 1996 1997 // don't copy the APK name, but, copy the rest of the arguments as-is 1998 while (argc-- > 1) { 1999 cmd += " " + escape_arg(std::string(*argv++)); 2000 } 2001 2002 // add size parameter [required for streaming installs] 2003 // do last to override any user specified value 2004 cmd += " " + android::base::StringPrintf("-S %" PRIu64, static_cast<uint64_t>(sb.st_size)); 2005 2006 int remoteFd = adb_connect(cmd, &error); 2007 if (remoteFd < 0) { 2008 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 2009 adb_close(localFd); 2010 return 1; 2011 } 2012 2013 char buf[BUFSIZ]; 2014 copy_to_file(localFd, remoteFd); 2015 read_status_line(remoteFd, buf, sizeof(buf)); 2016 2017 adb_close(localFd); 2018 adb_close(remoteFd); 2019 2020 if (strncmp("Success", buf, 7)) { 2021 fprintf(stderr, "Failed to install %s: %s", file, buf); 2022 return 1; 2023 } 2024 fputs(buf, stderr); 2025 return 0; 2026 } 2027 2028 static int install_multiple_app(TransportType transport, const char* serial, int argc, 2029 const char** argv) 2030 { 2031 int i; 2032 struct stat sb; 2033 uint64_t total_size = 0; 2034 2035 // Find all APK arguments starting at end. 2036 // All other arguments passed through verbatim. 2037 int first_apk = -1; 2038 for (i = argc - 1; i >= 0; i--) { 2039 const char* file = argv[i]; 2040 const char* dot = strrchr(file, '.'); 2041 if (dot && !strcasecmp(dot, ".apk")) { 2042 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 2043 fprintf(stderr, "Invalid APK file: %s\n", file); 2044 return EXIT_FAILURE; 2045 } 2046 2047 total_size += sb.st_size; 2048 first_apk = i; 2049 } else { 2050 break; 2051 } 2052 } 2053 2054 if (first_apk == -1) { 2055 fprintf(stderr, "Missing APK file\n"); 2056 return 1; 2057 } 2058 2059 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 2060 for (i = 1; i < first_apk; i++) { 2061 cmd += " " + escape_arg(argv[i]); 2062 } 2063 2064 // Create install session 2065 std::string error; 2066 int fd = adb_connect(cmd, &error); 2067 if (fd < 0) { 2068 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 2069 return EXIT_FAILURE; 2070 } 2071 char buf[BUFSIZ]; 2072 read_status_line(fd, buf, sizeof(buf)); 2073 adb_close(fd); 2074 2075 int session_id = -1; 2076 if (!strncmp("Success", buf, 7)) { 2077 char* start = strrchr(buf, '['); 2078 char* end = strrchr(buf, ']'); 2079 if (start && end) { 2080 *end = '\0'; 2081 session_id = strtol(start + 1, NULL, 10); 2082 } 2083 } 2084 if (session_id < 0) { 2085 fprintf(stderr, "Failed to create session\n"); 2086 fputs(buf, stderr); 2087 return EXIT_FAILURE; 2088 } 2089 2090 // Valid session, now stream the APKs 2091 int success = 1; 2092 for (i = first_apk; i < argc; i++) { 2093 const char* file = argv[i]; 2094 if (stat(file, &sb) == -1) { 2095 fprintf(stderr, "Failed to stat %s\n", file); 2096 success = 0; 2097 goto finalize_session; 2098 } 2099 2100 std::string cmd = android::base::StringPrintf( 2101 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 2102 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 2103 2104 int localFd = adb_open(file, O_RDONLY); 2105 if (localFd < 0) { 2106 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 2107 success = 0; 2108 goto finalize_session; 2109 } 2110 2111 std::string error; 2112 int remoteFd = adb_connect(cmd, &error); 2113 if (remoteFd < 0) { 2114 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 2115 adb_close(localFd); 2116 success = 0; 2117 goto finalize_session; 2118 } 2119 2120 copy_to_file(localFd, remoteFd); 2121 read_status_line(remoteFd, buf, sizeof(buf)); 2122 2123 adb_close(localFd); 2124 adb_close(remoteFd); 2125 2126 if (strncmp("Success", buf, 7)) { 2127 fprintf(stderr, "Failed to write %s\n", file); 2128 fputs(buf, stderr); 2129 success = 0; 2130 goto finalize_session; 2131 } 2132 } 2133 2134 finalize_session: 2135 // Commit session if we streamed everything okay; otherwise abandon 2136 std::string service = 2137 android::base::StringPrintf("exec:pm install-%s %d", 2138 success ? "commit" : "abandon", session_id); 2139 fd = adb_connect(service, &error); 2140 if (fd < 0) { 2141 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 2142 return EXIT_FAILURE; 2143 } 2144 read_status_line(fd, buf, sizeof(buf)); 2145 adb_close(fd); 2146 2147 if (!strncmp("Success", buf, 7)) { 2148 fputs(buf, stderr); 2149 return 0; 2150 } else { 2151 fprintf(stderr, "Failed to finalize session\n"); 2152 fputs(buf, stderr); 2153 return EXIT_FAILURE; 2154 } 2155 } 2156 2157 static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 2158 std::string cmd = "pm"; 2159 2160 while (argc-- > 0) { 2161 cmd += " " + escape_arg(*argv++); 2162 } 2163 2164 return send_shell_command(transport, serial, cmd, false); 2165 } 2166 2167 static int uninstall_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2168 /* if the user choose the -k option, we refuse to do it until devices are 2169 out with the option to uninstall the remaining data somehow (adb/ui) */ 2170 int i; 2171 for (i = 1; i < argc; i++) { 2172 if (!strcmp(argv[i], "-k")) { 2173 printf( 2174 "The -k option uninstalls the application while retaining the data/cache.\n" 2175 "At the moment, there is no way to remove the remaining data.\n" 2176 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 2177 "If you truly wish to continue, execute 'adb shell pm uninstall -k'\n."); 2178 return EXIT_FAILURE; 2179 } 2180 } 2181 2182 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 2183 return pm_command(transport, serial, argc, argv); 2184 } 2185 2186 static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 2187 std::string cmd = "rm -f " + escape_arg(filename); 2188 return send_shell_command(transport, serial, cmd, false); 2189 } 2190 2191 static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2192 static const char *const DATA_DEST = "/data/local/tmp/%s"; 2193 static const char *const SD_DEST = "/sdcard/tmp/%s"; 2194 const char* where = DATA_DEST; 2195 int i; 2196 struct stat sb; 2197 2198 for (i = 1; i < argc; i++) { 2199 if (!strcmp(argv[i], "-s")) { 2200 where = SD_DEST; 2201 } 2202 } 2203 2204 // Find last APK argument. 2205 // All other arguments passed through verbatim. 2206 int last_apk = -1; 2207 for (i = argc - 1; i >= 0; i--) { 2208 const char* file = argv[i]; 2209 const char* dot = strrchr(file, '.'); 2210 if (dot && !strcasecmp(dot, ".apk")) { 2211 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 2212 fprintf(stderr, "Invalid APK file: %s\n", file); 2213 return EXIT_FAILURE; 2214 } 2215 2216 last_apk = i; 2217 break; 2218 } 2219 } 2220 2221 if (last_apk == -1) { 2222 fprintf(stderr, "Missing APK file\n"); 2223 return EXIT_FAILURE; 2224 } 2225 2226 int result = -1; 2227 std::vector<const char*> apk_file = {argv[last_apk]}; 2228 std::string apk_dest = android::base::StringPrintf( 2229 where, adb_basename(argv[last_apk]).c_str()); 2230 if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk; 2231 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 2232 result = pm_command(transport, serial, argc, argv); 2233 2234 cleanup_apk: 2235 delete_file(transport, serial, apk_dest); 2236 return result; 2237 } 2238
