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