commandline.cpp revision 1fbc9dbd0f78d755e42a7100a8a24d2ff31c7f6a
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 446// Returns the FeatureSet for the indicated transport. 447static FeatureSet GetFeatureSet(TransportType transport_type, const char* serial) { 448 std::string result, error; 449 if (adb_query(format_host_command("features", transport_type, serial), &result, &error)) { 450 return StringToFeatureSet(result); 451 } 452 return FeatureSet(); 453} 454 455static void send_window_size_change(int fd, std::unique_ptr<ShellProtocol>& shell) { 456#if !defined(_WIN32) 457 // Old devices can't handle window size changes. 458 if (shell == nullptr) return; 459 460 winsize ws; 461 if (ioctl(fd, TIOCGWINSZ, &ws) == -1) return; 462 463 // Send the new window size as human-readable ASCII for debugging convenience. 464 size_t l = snprintf(shell->data(), shell->data_capacity(), "%dx%d,%dx%d", 465 ws.ws_row, ws.ws_col, ws.ws_xpixel, ws.ws_ypixel); 466 shell->Write(ShellProtocol::kIdWindowSizeChange, l + 1); 467#endif 468} 469 470// Used to pass multiple values to the stdin read thread. 471struct StdinReadArgs { 472 int stdin_fd, write_fd; 473 bool raw_stdin; 474 std::unique_ptr<ShellProtocol> protocol; 475 char escape_char; 476}; 477 478// Loops to read from stdin and push the data to the given FD. 479// The argument should be a pointer to a StdinReadArgs object. This function 480// will take ownership of the object and delete it when finished. 481static void* stdin_read_thread_loop(void* x) { 482 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x)); 483 484#if !defined(_WIN32) 485 // Mask SIGTTIN in case we're in a backgrounded process. 486 sigset_t sigset; 487 sigemptyset(&sigset); 488 sigaddset(&sigset, SIGTTIN); 489 pthread_sigmask(SIG_BLOCK, &sigset, nullptr); 490#endif 491 492#if !defined(_WIN32) 493 // Unblock SIGWINCH for this thread, so our read(2) below will be 494 // interrupted if the window size changes. 495 sigset_t mask; 496 sigemptyset(&mask); 497 sigaddset(&mask, SIGWINCH); 498 pthread_sigmask(SIG_UNBLOCK, &mask, nullptr); 499#endif 500 501 // Set up the initial window size. 502 send_window_size_change(args->stdin_fd, args->protocol); 503 504 char raw_buffer[BUFSIZ]; 505 char* buffer_ptr = raw_buffer; 506 size_t buffer_size = sizeof(raw_buffer); 507 if (args->protocol != nullptr) { 508 buffer_ptr = args->protocol->data(); 509 buffer_size = args->protocol->data_capacity(); 510 } 511 512 // If we need to parse escape sequences, make life easy. 513 if (args->raw_stdin && args->escape_char != '\0') { 514 buffer_size = 1; 515 } 516 517 enum EscapeState { kMidFlow, kStartOfLine, kInEscape }; 518 EscapeState state = kStartOfLine; 519 520 while (true) { 521 // Use unix_read() rather than adb_read() for stdin. 522 D("stdin_read_thread_loop(): pre unix_read(fdi=%d,...)", args->stdin_fd); 523#if !defined(_WIN32) 524#undef read 525 int r = read(args->stdin_fd, buffer_ptr, buffer_size); 526 if (r == -1 && errno == EINTR) { 527 send_window_size_change(args->stdin_fd, args->protocol); 528 continue; 529 } 530#define read ___xxx_read 531#else 532 int r = unix_read(args->stdin_fd, buffer_ptr, buffer_size); 533#endif 534 D("stdin_read_thread_loop(): post unix_read(fdi=%d,...)", args->stdin_fd); 535 if (r <= 0) { 536 // Only devices using the shell protocol know to close subprocess 537 // stdin. For older devices we want to just leave the connection 538 // open, otherwise an unpredictable amount of return data could 539 // be lost due to the FD closing before all data has been received. 540 if (args->protocol) { 541 args->protocol->Write(ShellProtocol::kIdCloseStdin, 0); 542 } 543 break; 544 } 545 // If we made stdin raw, check input for escape sequences. In 546 // this situation signals like Ctrl+C are sent remotely rather than 547 // interpreted locally so this provides an emergency out if the remote 548 // process starts ignoring the signal. SSH also does this, see the 549 // "escape characters" section on the ssh man page for more info. 550 if (args->raw_stdin && args->escape_char != '\0') { 551 char ch = buffer_ptr[0]; 552 if (ch == args->escape_char) { 553 if (state == kStartOfLine) { 554 state = kInEscape; 555 // Swallow the escape character. 556 continue; 557 } else { 558 state = kMidFlow; 559 } 560 } else { 561 if (state == kInEscape) { 562 if (ch == '.') { 563 fprintf(stderr,"\r\n[ disconnected ]\r\n"); 564 stdin_raw_restore(); 565 exit(0); 566 } else { 567 // We swallowed an escape character that wasn't part of 568 // a valid escape sequence; time to cough it up. 569 buffer_ptr[0] = args->escape_char; 570 buffer_ptr[1] = ch; 571 ++r; 572 } 573 } 574 state = (ch == '\n' || ch == '\r') ? kStartOfLine : kMidFlow; 575 } 576 } 577 if (args->protocol) { 578 if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) { 579 break; 580 } 581 } else { 582 if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) { 583 break; 584 } 585 } 586 } 587 588 return nullptr; 589} 590 591// Returns a shell service string with the indicated arguments and command. 592static std::string ShellServiceString(bool use_shell_protocol, 593 const std::string& type_arg, 594 const std::string& command) { 595 std::vector<std::string> args; 596 if (use_shell_protocol) { 597 args.push_back(kShellServiceArgShellProtocol); 598 599 const char* terminal_type = getenv("TERM"); 600 if (terminal_type != nullptr) { 601 args.push_back(std::string("TERM=") + terminal_type); 602 } 603 } 604 if (!type_arg.empty()) { 605 args.push_back(type_arg); 606 } 607 608 // Shell service string can look like: shell[,arg1,arg2,...]:[command]. 609 return android::base::StringPrintf("shell%s%s:%s", 610 args.empty() ? "" : ",", 611 android::base::Join(args, ',').c_str(), 612 command.c_str()); 613} 614 615// Connects to a shell on the device and read/writes data. 616// 617// Note: currently this function doesn't properly clean up resources; the 618// FD connected to the adb server is never closed and the stdin read thread 619// may never exit. 620// 621// On success returns the remote exit code if |use_shell_protocol| is true, 622// 0 otherwise. On failure returns 1. 623static int RemoteShell(bool use_shell_protocol, const std::string& type_arg, 624 char escape_char, 625 const std::string& command) { 626 std::string service_string = ShellServiceString(use_shell_protocol, 627 type_arg, command); 628 629 // Make local stdin raw if the device allocates a PTY, which happens if: 630 // 1. We are explicitly asking for a PTY shell, or 631 // 2. We don't specify shell type and are starting an interactive session. 632 bool raw_stdin = (type_arg == kShellServiceArgPty || 633 (type_arg.empty() && command.empty())); 634 635 std::string error; 636 int fd = adb_connect(service_string, &error); 637 if (fd < 0) { 638 fprintf(stderr,"error: %s\n", error.c_str()); 639 return 1; 640 } 641 642 StdinReadArgs* args = new StdinReadArgs; 643 if (!args) { 644 LOG(ERROR) << "couldn't allocate StdinReadArgs object"; 645 return 1; 646 } 647 args->stdin_fd = STDIN_FILENO; 648 args->write_fd = fd; 649 args->raw_stdin = raw_stdin; 650 args->escape_char = escape_char; 651 if (use_shell_protocol) { 652 args->protocol.reset(new ShellProtocol(args->write_fd)); 653 } 654 655 if (raw_stdin) stdin_raw_init(); 656 657#if !defined(_WIN32) 658 // Ensure our process is notified if the local window size changes. 659 // We use sigaction(2) to ensure that the SA_RESTART flag is not set, 660 // because the whole reason we're sending signals is to unblock the read(2)! 661 // That also means we don't need to do anything in the signal handler: 662 // the side effect of delivering the signal is all we need. 663 struct sigaction sa; 664 memset(&sa, 0, sizeof(sa)); 665 sa.sa_handler = [](int) {}; 666 sa.sa_flags = 0; 667 sigaction(SIGWINCH, &sa, nullptr); 668 669 // Now block SIGWINCH in this thread (the main thread) and all threads spawned 670 // from it. The stdin read thread will unblock this signal to ensure that it's 671 // the thread that receives the signal. 672 sigset_t mask; 673 sigemptyset(&mask); 674 sigaddset(&mask, SIGWINCH); 675 pthread_sigmask(SIG_BLOCK, &mask, nullptr); 676#endif 677 678 // TODO: combine read_and_dump with stdin_read_thread to make life simpler? 679 int exit_code = 1; 680 if (!adb_thread_create(stdin_read_thread_loop, args)) { 681 PLOG(ERROR) << "error starting stdin read thread"; 682 delete args; 683 } else { 684 exit_code = read_and_dump(fd, use_shell_protocol); 685 } 686 687 // TODO: properly exit stdin_read_thread_loop and close |fd|. 688 689 // TODO: we should probably install signal handlers for this. 690 // TODO: can we use atexit? even on Windows? 691 if (raw_stdin) stdin_raw_restore(); 692 693 return exit_code; 694} 695 696static int adb_shell(int argc, const char** argv, 697 TransportType transport_type, const char* serial) { 698 FeatureSet features = GetFeatureSet(transport_type, serial); 699 700 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); 701 if (!use_shell_protocol) { 702 D("shell protocol not supported, using raw data transfer"); 703 } else { 704 D("using shell protocol"); 705 } 706 707 // Parse shell-specific command-line options. 708 // argv[0] is always "shell". 709 --argc; 710 ++argv; 711 int t_arg_count = 0; 712 char escape_char = '~'; 713 while (argc) { 714 if (!strcmp(argv[0], "-e")) { 715 if (argc < 2 || !(strlen(argv[1]) == 1 || strcmp(argv[1], "none") == 0)) { 716 fprintf(stderr, "error: -e requires a single-character argument or 'none'\n"); 717 return 1; 718 } 719 escape_char = (strcmp(argv[1], "none") == 0) ? 0 : argv[1][0]; 720 argc -= 2; 721 argv += 2; 722 } else if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { 723 if (!CanUseFeature(features, kFeatureShell2)) { 724 fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); 725 return 1; 726 } 727 // Like ssh, -t arguments are cumulative so that multiple -t's 728 // are needed to force a PTY. 729 if (argv[0][1] == 't') { 730 ++t_arg_count; 731 } else { 732 t_arg_count = -1; 733 } 734 --argc; 735 ++argv; 736 } else if (!strcmp(argv[0], "-x")) { 737 use_shell_protocol = false; 738 --argc; 739 ++argv; 740 } else if (!strcmp(argv[0], "-n")) { 741 close_stdin(); 742 743 --argc; 744 ++argv; 745 } else { 746 break; 747 } 748 } 749 750 std::string shell_type_arg; 751 if (CanUseFeature(features, kFeatureShell2)) { 752 if (t_arg_count < 0) { 753 shell_type_arg = kShellServiceArgRaw; 754 } else if (t_arg_count == 0) { 755 // If stdin isn't a TTY, default to a raw shell; this lets 756 // things like `adb shell < my_script.sh` work as expected. 757 // Otherwise leave |shell_type_arg| blank which uses PTY for 758 // interactive shells and raw for non-interactive. 759 if (!unix_isatty(STDIN_FILENO)) { 760 shell_type_arg = kShellServiceArgRaw; 761 } 762 } else if (t_arg_count == 1) { 763 // A single -t arg isn't enough to override implicit -T. 764 if (!unix_isatty(STDIN_FILENO)) { 765 fprintf(stderr, 766 "Remote PTY will not be allocated because stdin is not a terminal.\n" 767 "Use multiple -t options to force remote PTY allocation.\n"); 768 shell_type_arg = kShellServiceArgRaw; 769 } else { 770 shell_type_arg = kShellServiceArgPty; 771 } 772 } else { 773 shell_type_arg = kShellServiceArgPty; 774 } 775 } 776 777 std::string command; 778 if (argc) { 779 // We don't escape here, just like ssh(1). http://b/20564385. 780 command = android::base::Join(std::vector<const char*>(argv, argv + argc), ' '); 781 } 782 783 return RemoteShell(use_shell_protocol, shell_type_arg, escape_char, command); 784} 785 786static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 787 bool show_progress) 788{ 789 std::string error; 790 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 791 if (fd < 0) { 792 fprintf(stderr,"error: %s\n", error.c_str()); 793 return -1; 794 } 795 796 int opt = CHUNK_SIZE; 797 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 798 799 unsigned total = sz; 800 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 801 802 if (show_progress) { 803 const char* x = strrchr(service, ':'); 804 if (x) service = x + 1; 805 } 806 807 while (sz > 0) { 808 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 809 if (!WriteFdExactly(fd, ptr, xfer)) { 810 std::string error; 811 adb_status(fd, &error); 812 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 813 adb_close(fd); 814 return -1; 815 } 816 sz -= xfer; 817 ptr += xfer; 818 if (show_progress) { 819 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 820 fflush(stdout); 821 } 822 } 823 if (show_progress) { 824 printf("\n"); 825 } 826 827 if (!adb_status(fd, &error)) { 828 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 829 adb_close(fd); 830 return -1; 831 } 832 833 adb_close(fd); 834 return 0; 835} 836 837#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 838 839/* 840 * The sideload-host protocol serves the data in a file (given on the 841 * command line) to the client, using a simple protocol: 842 * 843 * - The connect message includes the total number of bytes in the 844 * file and a block size chosen by us. 845 * 846 * - The other side sends the desired block number as eight decimal 847 * digits (eg "00000023" for block 23). Blocks are numbered from 848 * zero. 849 * 850 * - We send back the data of the requested block. The last block is 851 * likely to be partial; when the last block is requested we only 852 * send the part of the block that exists, it's not padded up to the 853 * block size. 854 * 855 * - When the other side sends "DONEDONE" instead of a block number, 856 * we hang up. 857 */ 858static int adb_sideload_host(const char* fn) { 859 unsigned sz; 860 size_t xfer = 0; 861 int status; 862 int last_percent = -1; 863 int opt = SIDELOAD_HOST_BLOCK_SIZE; 864 865 printf("loading: '%s'", fn); 866 fflush(stdout); 867 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 868 if (data == 0) { 869 printf("\n"); 870 fprintf(stderr, "* cannot read '%s' *\n", fn); 871 return -1; 872 } 873 874 std::string service = 875 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 876 std::string error; 877 int fd = adb_connect(service, &error); 878 if (fd < 0) { 879 // Try falling back to the older sideload method. Maybe this 880 // is an older device that doesn't support sideload-host. 881 printf("\n"); 882 status = adb_download_buffer("sideload", fn, data, sz, true); 883 goto done; 884 } 885 886 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 887 888 while (true) { 889 char buf[9]; 890 if (!ReadFdExactly(fd, buf, 8)) { 891 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 892 status = -1; 893 goto done; 894 } 895 buf[8] = '\0'; 896 897 if (strcmp("DONEDONE", buf) == 0) { 898 status = 0; 899 break; 900 } 901 902 int block = strtol(buf, NULL, 10); 903 904 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 905 if (offset >= sz) { 906 fprintf(stderr, "* attempt to read block %d past end\n", block); 907 status = -1; 908 goto done; 909 } 910 uint8_t* start = data + offset; 911 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 912 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 913 if (offset_end > sz) { 914 to_write = sz - offset; 915 } 916 917 if(!WriteFdExactly(fd, start, to_write)) { 918 adb_status(fd, &error); 919 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 920 status = -1; 921 goto done; 922 } 923 xfer += to_write; 924 925 // For normal OTA packages, we expect to transfer every byte 926 // twice, plus a bit of overhead (one read during 927 // verification, one read of each byte for installation, plus 928 // extra access to things like the zip central directory). 929 // This estimate of the completion becomes 100% when we've 930 // transferred ~2.13 (=100/47) times the package size. 931 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 932 if (percent != last_percent) { 933 printf("\rserving: '%s' (~%d%%) ", fn, percent); 934 fflush(stdout); 935 last_percent = percent; 936 } 937 } 938 939 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 940 941 done: 942 if (fd >= 0) adb_close(fd); 943 free(data); 944 return status; 945} 946 947/** 948 * Run ppp in "notty" mode against a resource listed as the first parameter 949 * eg: 950 * 951 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 952 * 953 */ 954static int ppp(int argc, const char** argv) { 955#if defined(_WIN32) 956 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 957 return -1; 958#else 959 if (argc < 2) { 960 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 961 argv[0]); 962 963 return 1; 964 } 965 966 const char* adb_service_name = argv[1]; 967 std::string error; 968 int fd = adb_connect(adb_service_name, &error); 969 if (fd < 0) { 970 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 971 adb_service_name, error.c_str()); 972 return 1; 973 } 974 975 pid_t pid = fork(); 976 977 if (pid < 0) { 978 perror("from fork()"); 979 return 1; 980 } else if (pid == 0) { 981 int err; 982 int i; 983 const char **ppp_args; 984 985 // copy args 986 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 987 ppp_args[0] = "pppd"; 988 for (i = 2 ; i < argc ; i++) { 989 //argv[2] and beyond become ppp_args[1] and beyond 990 ppp_args[i - 1] = argv[i]; 991 } 992 ppp_args[i-1] = NULL; 993 994 // child side 995 996 dup2(fd, STDIN_FILENO); 997 dup2(fd, STDOUT_FILENO); 998 adb_close(STDERR_FILENO); 999 adb_close(fd); 1000 1001 err = execvp("pppd", (char * const *)ppp_args); 1002 1003 if (err < 0) { 1004 perror("execing pppd"); 1005 } 1006 exit(-1); 1007 } else { 1008 // parent side 1009 1010 adb_close(fd); 1011 return 0; 1012 } 1013#endif /* !defined(_WIN32) */ 1014} 1015 1016static bool check_wait_for_device_syntax(const char* service) { 1017 // TODO: when we have libc++ for Windows, use a regular expression instead. 1018 // wait-for-((any|local|usb)-)?(bootloader|device|recovery|sideload) 1019 1020 char type[20]; 1021 char state[20]; 1022 int length = 0; 1023 if (sscanf(service, "wait-for-%20[a-z]-%20[a-z]%n", type, state, &length) < 2 || 1024 length != static_cast<int>(strlen(service))) { 1025 fprintf(stderr, "adb: couldn't parse 'wait-for' command: %s\n", service); 1026 return false; 1027 } 1028 1029 if (strcmp(type, "any") != 0 && strcmp(type, "local") != 0 && strcmp(type, "usb") != 0) { 1030 fprintf(stderr, "adb: unknown type %s; expected 'any', 'local', or 'usb'\n", type); 1031 return false; 1032 } 1033 if (strcmp(state, "bootloader") != 0 && strcmp(state, "device") != 0 && 1034 strcmp(state, "recovery") != 0 && strcmp(state, "sideload") != 0) { 1035 fprintf(stderr, "adb: unknown state %s; " 1036 "expected 'bootloader', 'device', 'recovery', or 'sideload'\n", state); 1037 return false; 1038 } 1039 return true; 1040} 1041 1042static bool wait_for_device(const char* service, TransportType t, const char* serial) { 1043 // Was the caller vague about what they'd like us to wait for? 1044 // If so, check they weren't more specific in their choice of transport type. 1045 if (strcmp(service, "wait-for-device") == 0) { 1046 if (t == kTransportUsb) { 1047 service = "wait-for-usb-device"; 1048 } else if (t == kTransportLocal) { 1049 service = "wait-for-local-device"; 1050 } else { 1051 service = "wait-for-any-device"; 1052 } 1053 } 1054 1055 if (!check_wait_for_device_syntax(service)) { 1056 return false; 1057 } 1058 1059 std::string cmd = format_host_command(service, t, serial); 1060 return adb_command(cmd); 1061} 1062 1063// Connects to the device "shell" service with |command| and prints the 1064// resulting output. 1065static int send_shell_command(TransportType transport_type, const char* serial, 1066 const std::string& command, 1067 bool disable_shell_protocol) { 1068 // Only use shell protocol if it's supported and the caller doesn't want 1069 // to explicitly disable it. 1070 bool use_shell_protocol = false; 1071 if (!disable_shell_protocol) { 1072 FeatureSet features = GetFeatureSet(transport_type, serial); 1073 use_shell_protocol = CanUseFeature(features, kFeatureShell2); 1074 } 1075 1076 std::string service_string = ShellServiceString(use_shell_protocol, "", command); 1077 1078 int fd; 1079 while (true) { 1080 std::string error; 1081 fd = adb_connect(service_string, &error); 1082 if (fd >= 0) { 1083 break; 1084 } 1085 fprintf(stderr,"- waiting for device -\n"); 1086 adb_sleep_ms(1000); 1087 wait_for_device("wait-for-device", transport_type, serial); 1088 } 1089 1090 int exit_code = read_and_dump(fd, use_shell_protocol); 1091 1092 if (adb_close(fd) < 0) { 1093 PLOG(ERROR) << "failure closing FD " << fd; 1094 } 1095 1096 return exit_code; 1097} 1098 1099static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 1100 char* log_tags = getenv("ANDROID_LOG_TAGS"); 1101 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 1102 1103 std::string cmd = "export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 1104 1105 if (!strcmp(argv[0], "longcat")) { 1106 cmd += " -v long"; 1107 } 1108 1109 --argc; 1110 ++argv; 1111 while (argc-- > 0) { 1112 cmd += " " + escape_arg(*argv++); 1113 } 1114 1115 // No need for shell protocol with logcat, always disable for simplicity. 1116 return send_shell_command(transport, serial, cmd, true); 1117} 1118 1119static int backup(int argc, const char** argv) { 1120 const char* filename = "backup.ab"; 1121 1122 /* find, extract, and use any -f argument */ 1123 for (int i = 1; i < argc; i++) { 1124 if (!strcmp("-f", argv[i])) { 1125 if (i == argc-1) { 1126 fprintf(stderr, "adb: backup -f passed with no filename.\n"); 1127 return EXIT_FAILURE; 1128 } 1129 filename = argv[i+1]; 1130 for (int j = i+2; j <= argc; ) { 1131 argv[i++] = argv[j++]; 1132 } 1133 argc -= 2; 1134 argv[argc] = NULL; 1135 } 1136 } 1137 1138 // Bare "adb backup" or "adb backup -f filename" are not valid invocations --- 1139 // a list of packages is required. 1140 if (argc < 2) { 1141 fprintf(stderr, "adb: backup either needs a list of packages or -all/-shared.\n"); 1142 return EXIT_FAILURE; 1143 } 1144 1145 adb_unlink(filename); 1146 int outFd = adb_creat(filename, 0640); 1147 if (outFd < 0) { 1148 fprintf(stderr, "adb: backup unable to create file '%s': %s\n", filename, strerror(errno)); 1149 return EXIT_FAILURE; 1150 } 1151 1152 std::string cmd = "backup:"; 1153 --argc; 1154 ++argv; 1155 while (argc-- > 0) { 1156 cmd += " " + escape_arg(*argv++); 1157 } 1158 1159 D("backup. filename=%s cmd=%s", filename, cmd.c_str()); 1160 std::string error; 1161 int fd = adb_connect(cmd, &error); 1162 if (fd < 0) { 1163 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 1164 adb_close(outFd); 1165 return EXIT_FAILURE; 1166 } 1167 1168 printf("Now unlock your device and confirm the backup operation...\n"); 1169 fflush(stdout); 1170 1171 copy_to_file(fd, outFd); 1172 1173 adb_close(fd); 1174 adb_close(outFd); 1175 return EXIT_SUCCESS; 1176} 1177 1178static int restore(int argc, const char** argv) { 1179 if (argc != 2) return usage(); 1180 1181 const char* filename = argv[1]; 1182 int tarFd = adb_open(filename, O_RDONLY); 1183 if (tarFd < 0) { 1184 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 1185 return -1; 1186 } 1187 1188 std::string error; 1189 int fd = adb_connect("restore:", &error); 1190 if (fd < 0) { 1191 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 1192 adb_close(tarFd); 1193 return -1; 1194 } 1195 1196 printf("Now unlock your device and confirm the restore operation.\n"); 1197 copy_to_file(tarFd, fd); 1198 1199 adb_close(fd); 1200 adb_close(tarFd); 1201 return 0; 1202} 1203 1204/* <hint> may be: 1205 * - A simple product name 1206 * e.g., "sooner" 1207 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 1208 * e.g., "out/target/product/sooner" 1209 * - An absolute path to the PRODUCT_OUT dir 1210 * e.g., "/src/device/out/target/product/sooner" 1211 * 1212 * Given <hint>, try to construct an absolute path to the 1213 * ANDROID_PRODUCT_OUT dir. 1214 */ 1215static std::string find_product_out_path(const std::string& hint) { 1216 if (hint.empty()) { 1217 return ""; 1218 } 1219 1220 // If it's already absolute, don't bother doing any work. 1221 if (adb_is_absolute_host_path(hint.c_str())) { 1222 return hint; 1223 } 1224 1225 // If there are any slashes in it, assume it's a relative path; 1226 // make it absolute. 1227 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { 1228 std::string cwd; 1229 if (!getcwd(&cwd)) { 1230 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 1231 return ""; 1232 } 1233 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); 1234 } 1235 1236 // It's a string without any slashes. Try to do something with it. 1237 // 1238 // Try to find the root of the build tree, and build a PRODUCT_OUT 1239 // path from there. 1240 char* top = getenv("ANDROID_BUILD_TOP"); 1241 if (top == nullptr) { 1242 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 1243 return ""; 1244 } 1245 1246 std::string path = top; 1247 path += OS_PATH_SEPARATOR_STR; 1248 path += "out"; 1249 path += OS_PATH_SEPARATOR_STR; 1250 path += "target"; 1251 path += OS_PATH_SEPARATOR_STR; 1252 path += "product"; 1253 path += OS_PATH_SEPARATOR_STR; 1254 path += hint; 1255 if (!directory_exists(path)) { 1256 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 1257 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); 1258 return ""; 1259 } 1260 return path; 1261} 1262 1263static void parse_push_pull_args(const char** arg, int narg, 1264 std::vector<const char*>* srcs, 1265 const char** dst, bool* copy_attrs) { 1266 *copy_attrs = false; 1267 1268 srcs->clear(); 1269 bool ignore_flags = false; 1270 while (narg > 0) { 1271 if (ignore_flags || *arg[0] != '-') { 1272 srcs->push_back(*arg); 1273 } else { 1274 if (!strcmp(*arg, "-p")) { 1275 // Silently ignore for backwards compatibility. 1276 } else if (!strcmp(*arg, "-a")) { 1277 *copy_attrs = true; 1278 } else if (!strcmp(*arg, "--")) { 1279 ignore_flags = true; 1280 } else { 1281 fprintf(stderr, "adb: unrecognized option '%s'\n", *arg); 1282 exit(1); 1283 } 1284 } 1285 ++arg; 1286 --narg; 1287 } 1288 1289 if (srcs->size() > 1) { 1290 *dst = srcs->back(); 1291 srcs->pop_back(); 1292 } 1293} 1294 1295static int adb_connect_command(const std::string& command) { 1296 std::string error; 1297 int fd = adb_connect(command, &error); 1298 if (fd < 0) { 1299 fprintf(stderr, "error: %s\n", error.c_str()); 1300 return 1; 1301 } 1302 read_and_dump(fd); 1303 adb_close(fd); 1304 return 0; 1305} 1306 1307static int adb_query_command(const std::string& command) { 1308 std::string result; 1309 std::string error; 1310 if (!adb_query(command, &result, &error)) { 1311 fprintf(stderr, "error: %s\n", error.c_str()); 1312 return 1; 1313 } 1314 printf("%s\n", result.c_str()); 1315 return 0; 1316} 1317 1318// Disallow stdin, stdout, and stderr. 1319static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { 1320#ifdef _WIN32 1321 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); 1322 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && 1323 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && 1324 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); 1325#else 1326 return ack_reply_fd > 2; 1327#endif 1328} 1329 1330int adb_commandline(int argc, const char **argv) { 1331 int no_daemon = 0; 1332 int is_daemon = 0; 1333 int is_server = 0; 1334 int r; 1335 TransportType transport_type = kTransportAny; 1336 int ack_reply_fd = -1; 1337 1338#if !defined(_WIN32) 1339 // We'd rather have EPIPE than SIGPIPE. 1340 signal(SIGPIPE, SIG_IGN); 1341#endif 1342 1343 // If defined, this should be an absolute path to 1344 // the directory containing all of the various system images 1345 // for a particular product. If not defined, and the adb 1346 // command requires this information, then the user must 1347 // specify the path using "-p". 1348 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1349 if (ANDROID_PRODUCT_OUT != nullptr) { 1350 gProductOutPath = ANDROID_PRODUCT_OUT; 1351 } 1352 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1353 1354 /* Validate and assign the server port */ 1355 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1356 int server_port = DEFAULT_ADB_PORT; 1357 if (server_port_str && strlen(server_port_str) > 0) { 1358 server_port = strtol(server_port_str, nullptr, 0); 1359 if (server_port <= 0 || server_port > 65535) { 1360 fprintf(stderr, 1361 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1362 server_port_str); 1363 return usage(); 1364 } 1365 } 1366 1367 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1368 const char* serial = nullptr; 1369 1370 while (argc > 0) { 1371 if (!strcmp(argv[0],"server")) { 1372 is_server = 1; 1373 } else if (!strcmp(argv[0],"nodaemon")) { 1374 no_daemon = 1; 1375 } else if (!strcmp(argv[0], "fork-server")) { 1376 /* this is a special flag used only when the ADB client launches the ADB Server */ 1377 is_daemon = 1; 1378 } else if (!strcmp(argv[0], "--reply-fd")) { 1379 if (argc < 2) return usage(); 1380 const char* reply_fd_str = argv[1]; 1381 argc--; 1382 argv++; 1383 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1384 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1385 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1386 return usage(); 1387 } 1388 } else if (!strncmp(argv[0], "-p", 2)) { 1389 const char* product = nullptr; 1390 if (argv[0][2] == '\0') { 1391 if (argc < 2) return usage(); 1392 product = argv[1]; 1393 argc--; 1394 argv++; 1395 } else { 1396 product = argv[0] + 2; 1397 } 1398 gProductOutPath = find_product_out_path(product); 1399 if (gProductOutPath.empty()) { 1400 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1401 return usage(); 1402 } 1403 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1404 if (isdigit(argv[0][2])) { 1405 serial = argv[0] + 2; 1406 } else { 1407 if (argc < 2 || argv[0][2] != '\0') return usage(); 1408 serial = argv[1]; 1409 argc--; 1410 argv++; 1411 } 1412 } else if (!strcmp(argv[0],"-d")) { 1413 transport_type = kTransportUsb; 1414 } else if (!strcmp(argv[0],"-e")) { 1415 transport_type = kTransportLocal; 1416 } else if (!strcmp(argv[0],"-a")) { 1417 gListenAll = 1; 1418 } else if (!strncmp(argv[0], "-H", 2)) { 1419 const char *hostname = NULL; 1420 if (argv[0][2] == '\0') { 1421 if (argc < 2) return usage(); 1422 hostname = argv[1]; 1423 argc--; 1424 argv++; 1425 } else { 1426 hostname = argv[0] + 2; 1427 } 1428 adb_set_tcp_name(hostname); 1429 1430 } else if (!strncmp(argv[0], "-P", 2)) { 1431 if (argv[0][2] == '\0') { 1432 if (argc < 2) return usage(); 1433 server_port_str = argv[1]; 1434 argc--; 1435 argv++; 1436 } else { 1437 server_port_str = argv[0] + 2; 1438 } 1439 if (strlen(server_port_str) > 0) { 1440 server_port = (int) strtol(server_port_str, NULL, 0); 1441 if (server_port <= 0 || server_port > 65535) { 1442 fprintf(stderr, 1443 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1444 server_port_str); 1445 return usage(); 1446 } 1447 } else { 1448 fprintf(stderr, 1449 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1450 return usage(); 1451 } 1452 } else { 1453 /* out of recognized modifiers and flags */ 1454 break; 1455 } 1456 argc--; 1457 argv++; 1458 } 1459 1460 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1461 if (transport_type == kTransportAny && serial == nullptr) { 1462 serial = getenv("ANDROID_SERIAL"); 1463 } 1464 1465 adb_set_transport(transport_type, serial); 1466 adb_set_tcp_specifics(server_port); 1467 1468 if (is_server) { 1469 if (no_daemon || is_daemon) { 1470 if (is_daemon && (ack_reply_fd == -1)) { 1471 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1472 return usage(); 1473 } 1474 r = adb_server_main(is_daemon, server_port, ack_reply_fd); 1475 } else { 1476 r = launch_server(server_port); 1477 } 1478 if (r) { 1479 fprintf(stderr,"* could not start server *\n"); 1480 } 1481 return r; 1482 } 1483 1484 if (argc == 0) { 1485 return usage(); 1486 } 1487 1488 /* handle wait-for-* prefix */ 1489 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1490 const char* service = argv[0]; 1491 1492 if (!wait_for_device(service, transport_type, serial)) { 1493 return 1; 1494 } 1495 1496 // Allow a command to be run after wait-for-device, 1497 // e.g. 'adb wait-for-device shell'. 1498 if (argc == 1) { 1499 return 0; 1500 } 1501 1502 /* Fall through */ 1503 argc--; 1504 argv++; 1505 } 1506 1507 /* adb_connect() commands */ 1508 if (!strcmp(argv[0], "devices")) { 1509 const char *listopt; 1510 if (argc < 2) { 1511 listopt = ""; 1512 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1513 listopt = argv[1]; 1514 } else { 1515 fprintf(stderr, "Usage: adb devices [-l]\n"); 1516 return 1; 1517 } 1518 1519 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1520 printf("List of devices attached\n"); 1521 return adb_query_command(query); 1522 } 1523 else if (!strcmp(argv[0], "connect")) { 1524 if (argc != 2) { 1525 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1526 return 1; 1527 } 1528 1529 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1530 return adb_query_command(query); 1531 } 1532 else if (!strcmp(argv[0], "disconnect")) { 1533 if (argc > 2) { 1534 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1535 return 1; 1536 } 1537 1538 std::string query = android::base::StringPrintf("host:disconnect:%s", 1539 (argc == 2) ? argv[1] : ""); 1540 return adb_query_command(query); 1541 } 1542 else if (!strcmp(argv[0], "emu")) { 1543 return adb_send_emulator_command(argc, argv, serial); 1544 } 1545 else if (!strcmp(argv[0], "shell")) { 1546 return adb_shell(argc, argv, transport_type, serial); 1547 } 1548 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1549 int exec_in = !strcmp(argv[0], "exec-in"); 1550 1551 std::string cmd = "exec:"; 1552 cmd += argv[1]; 1553 argc -= 2; 1554 argv += 2; 1555 while (argc-- > 0) { 1556 cmd += " " + escape_arg(*argv++); 1557 } 1558 1559 std::string error; 1560 int fd = adb_connect(cmd, &error); 1561 if (fd < 0) { 1562 fprintf(stderr, "error: %s\n", error.c_str()); 1563 return -1; 1564 } 1565 1566 if (exec_in) { 1567 copy_to_file(STDIN_FILENO, fd); 1568 } else { 1569 copy_to_file(fd, STDOUT_FILENO); 1570 } 1571 1572 adb_close(fd); 1573 return 0; 1574 } 1575 else if (!strcmp(argv[0], "kill-server")) { 1576 std::string error; 1577 int fd = _adb_connect("host:kill", &error); 1578 if (fd == -2) { 1579 // Failed to make network connection to server. Don't output the 1580 // network error since that is expected. 1581 fprintf(stderr,"* server not running *\n"); 1582 // Successful exit code because the server is already "killed". 1583 return 0; 1584 } else if (fd == -1) { 1585 // Some other error. 1586 fprintf(stderr, "error: %s\n", error.c_str()); 1587 return 1; 1588 } else { 1589 // Successfully connected, kill command sent, okay status came back. 1590 // Server should exit() in a moment, if not already. 1591 ReadOrderlyShutdown(fd); 1592 adb_close(fd); 1593 return 0; 1594 } 1595 } 1596 else if (!strcmp(argv[0], "sideload")) { 1597 if (argc != 2) return usage(); 1598 if (adb_sideload_host(argv[1])) { 1599 return 1; 1600 } else { 1601 return 0; 1602 } 1603 } 1604 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1605 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1606 } 1607 else if (!strcmp(argv[0], "remount") || 1608 !strcmp(argv[0], "reboot") || 1609 !strcmp(argv[0], "reboot-bootloader") || 1610 !strcmp(argv[0], "usb") || 1611 !strcmp(argv[0], "root") || 1612 !strcmp(argv[0], "unroot") || 1613 !strcmp(argv[0], "disable-verity") || 1614 !strcmp(argv[0], "enable-verity")) { 1615 std::string command; 1616 if (!strcmp(argv[0], "reboot-bootloader")) { 1617 command = "reboot:bootloader"; 1618 } else if (argc > 1) { 1619 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1620 } else { 1621 command = android::base::StringPrintf("%s:", argv[0]); 1622 } 1623 return adb_connect_command(command); 1624 } 1625 else if (!strcmp(argv[0], "bugreport")) { 1626 if (argc != 1) return usage(); 1627 // No need for shell protocol with bugreport, always disable for 1628 // simplicity. 1629 return send_shell_command(transport_type, serial, "bugreport", true); 1630 } 1631 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1632 bool reverse = !strcmp(argv[0], "reverse"); 1633 ++argv; 1634 --argc; 1635 if (argc < 1) return usage(); 1636 1637 // Determine the <host-prefix> for this command. 1638 std::string host_prefix; 1639 if (reverse) { 1640 host_prefix = "reverse"; 1641 } else { 1642 if (serial) { 1643 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1644 } else if (transport_type == kTransportUsb) { 1645 host_prefix = "host-usb"; 1646 } else if (transport_type == kTransportLocal) { 1647 host_prefix = "host-local"; 1648 } else { 1649 host_prefix = "host"; 1650 } 1651 } 1652 1653 std::string cmd; 1654 if (strcmp(argv[0], "--list") == 0) { 1655 if (argc != 1) return usage(); 1656 return adb_query_command(host_prefix + ":list-forward"); 1657 } else if (strcmp(argv[0], "--remove-all") == 0) { 1658 if (argc != 1) return usage(); 1659 cmd = host_prefix + ":killforward-all"; 1660 } else if (strcmp(argv[0], "--remove") == 0) { 1661 // forward --remove <local> 1662 if (argc != 2) return usage(); 1663 cmd = host_prefix + ":killforward:" + argv[1]; 1664 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1665 // forward --no-rebind <local> <remote> 1666 if (argc != 3) return usage(); 1667 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1668 } else { 1669 // forward <local> <remote> 1670 if (argc != 2) return usage(); 1671 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1672 } 1673 1674 return adb_command(cmd) ? 0 : 1; 1675 } 1676 /* do_sync_*() commands */ 1677 else if (!strcmp(argv[0], "ls")) { 1678 if (argc != 2) return usage(); 1679 return do_sync_ls(argv[1]) ? 0 : 1; 1680 } 1681 else if (!strcmp(argv[0], "push")) { 1682 bool copy_attrs = false; 1683 std::vector<const char*> srcs; 1684 const char* dst = nullptr; 1685 1686 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1687 if (srcs.empty() || !dst) return usage(); 1688 return do_sync_push(srcs, dst) ? 0 : 1; 1689 } 1690 else if (!strcmp(argv[0], "pull")) { 1691 bool copy_attrs = false; 1692 std::vector<const char*> srcs; 1693 const char* dst = "."; 1694 1695 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1696 if (srcs.empty()) return usage(); 1697 return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1; 1698 } 1699 else if (!strcmp(argv[0], "install")) { 1700 if (argc < 2) return usage(); 1701 FeatureSet features = GetFeatureSet(transport_type, serial); 1702 if (CanUseFeature(features, kFeatureCmd)) { 1703 return install_app(transport_type, serial, argc, argv); 1704 } 1705 return install_app_legacy(transport_type, serial, argc, argv); 1706 } 1707 else if (!strcmp(argv[0], "install-multiple")) { 1708 if (argc < 2) return usage(); 1709 return install_multiple_app(transport_type, serial, argc, argv); 1710 } 1711 else if (!strcmp(argv[0], "uninstall")) { 1712 if (argc < 2) return usage(); 1713 FeatureSet features = GetFeatureSet(transport_type, serial); 1714 if (CanUseFeature(features, kFeatureCmd)) { 1715 return uninstall_app(transport_type, serial, argc, argv); 1716 } 1717 return uninstall_app_legacy(transport_type, serial, argc, argv); 1718 } 1719 else if (!strcmp(argv[0], "sync")) { 1720 std::string src; 1721 bool list_only = false; 1722 if (argc < 2) { 1723 // No local path was specified. 1724 src = ""; 1725 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1726 list_only = true; 1727 if (argc == 3) { 1728 src = argv[2]; 1729 } else { 1730 src = ""; 1731 } 1732 } else if (argc == 2) { 1733 // A local path or "android"/"data" arg was specified. 1734 src = argv[1]; 1735 } else { 1736 return usage(); 1737 } 1738 1739 if (src != "" && 1740 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1741 return usage(); 1742 } 1743 1744 std::string system_src_path = product_file("system"); 1745 std::string data_src_path = product_file("data"); 1746 std::string vendor_src_path = product_file("vendor"); 1747 std::string oem_src_path = product_file("oem"); 1748 1749 bool okay = true; 1750 if (okay && (src.empty() || src == "system")) { 1751 okay = do_sync_sync(system_src_path, "/system", list_only); 1752 } 1753 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1754 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1755 } 1756 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1757 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1758 } 1759 if (okay && (src.empty() || src == "data")) { 1760 okay = do_sync_sync(data_src_path, "/data", list_only); 1761 } 1762 return okay ? 0 : 1; 1763 } 1764 /* passthrough commands */ 1765 else if (!strcmp(argv[0],"get-state") || 1766 !strcmp(argv[0],"get-serialno") || 1767 !strcmp(argv[0],"get-devpath")) 1768 { 1769 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1770 } 1771 /* other commands */ 1772 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1773 return logcat(transport_type, serial, argc, argv); 1774 } 1775 else if (!strcmp(argv[0],"ppp")) { 1776 return ppp(argc, argv); 1777 } 1778 else if (!strcmp(argv[0], "start-server")) { 1779 std::string error; 1780 const int result = adb_connect("host:start-server", &error); 1781 if (result < 0) { 1782 fprintf(stderr, "error: %s\n", error.c_str()); 1783 } 1784 return result; 1785 } 1786 else if (!strcmp(argv[0], "backup")) { 1787 return backup(argc, argv); 1788 } 1789 else if (!strcmp(argv[0], "restore")) { 1790 return restore(argc, argv); 1791 } 1792 else if (!strcmp(argv[0], "keygen")) { 1793 if (argc < 2) return usage(); 1794 // Always print key generation information for keygen command. 1795 adb_trace_enable(AUTH); 1796 return adb_auth_keygen(argv[1]); 1797 } 1798 else if (!strcmp(argv[0], "jdwp")) { 1799 return adb_connect_command("jdwp"); 1800 } 1801 /* "adb /?" is a common idiom under Windows */ 1802 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1803 help(); 1804 return 0; 1805 } 1806 else if (!strcmp(argv[0], "version")) { 1807 fprintf(stdout, "%s", adb_version().c_str()); 1808 return 0; 1809 } 1810 else if (!strcmp(argv[0], "features")) { 1811 // Only list the features common to both the adb client and the device. 1812 FeatureSet features = GetFeatureSet(transport_type, serial); 1813 for (const std::string& name : features) { 1814 if (CanUseFeature(features, name)) { 1815 printf("%s\n", name.c_str()); 1816 } 1817 } 1818 return 0; 1819 } 1820 1821 usage(); 1822 return 1; 1823} 1824 1825static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1826 // 'adb uninstall' takes the same arguments as 'cmd package uninstall' on device 1827 std::string cmd = "cmd package"; 1828 while (argc-- > 0) { 1829 // deny the '-k' option until the remaining data/cache can be removed with adb/UI 1830 if (strcmp(*argv, "-k") == 0) { 1831 printf( 1832 "The -k option uninstalls the application while retaining the data/cache.\n" 1833 "At the moment, there is no way to remove the remaining data.\n" 1834 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1835 "If you truly wish to continue, execute 'adb shell cmd package uninstall -k'.\n"); 1836 return EXIT_FAILURE; 1837 } 1838 cmd += " " + escape_arg(*argv++); 1839 } 1840 1841 return send_shell_command(transport, serial, cmd, false); 1842} 1843 1844static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1845 // The last argument must be the APK file 1846 const char* file = argv[argc - 1]; 1847 const char* dot = strrchr(file, '.'); 1848 bool found_apk = false; 1849 struct stat sb; 1850 if (dot && !strcasecmp(dot, ".apk")) { 1851 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1852 fprintf(stderr, "Invalid APK file: %s\n", file); 1853 return EXIT_FAILURE; 1854 } 1855 found_apk = true; 1856 } 1857 1858 if (!found_apk) { 1859 fprintf(stderr, "Missing APK file\n"); 1860 return EXIT_FAILURE; 1861 } 1862 1863 int localFd = adb_open(file, O_RDONLY); 1864 if (localFd < 0) { 1865 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1866 return 1; 1867 } 1868 1869 std::string error; 1870 std::string cmd = "exec:cmd package"; 1871 1872 // don't copy the APK name, but, copy the rest of the arguments as-is 1873 while (argc-- > 1) { 1874 cmd += " " + escape_arg(std::string(*argv++)); 1875 } 1876 1877 // add size parameter [required for streaming installs] 1878 // do last to override any user specified value 1879 cmd += " " + android::base::StringPrintf("-S %" PRIu64, static_cast<uint64_t>(sb.st_size)); 1880 1881 int remoteFd = adb_connect(cmd, &error); 1882 if (remoteFd < 0) { 1883 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1884 adb_close(localFd); 1885 return 1; 1886 } 1887 1888 char buf[BUFSIZ]; 1889 copy_to_file(localFd, remoteFd); 1890 read_status_line(remoteFd, buf, sizeof(buf)); 1891 1892 adb_close(localFd); 1893 adb_close(remoteFd); 1894 1895 if (strncmp("Success", buf, 7)) { 1896 fprintf(stderr, "Failed to write %s\n", file); 1897 fputs(buf, stderr); 1898 return 1; 1899 } 1900 fputs(buf, stderr); 1901 return 0; 1902} 1903 1904static int install_multiple_app(TransportType transport, const char* serial, int argc, 1905 const char** argv) 1906{ 1907 int i; 1908 struct stat sb; 1909 uint64_t total_size = 0; 1910 1911 // Find all APK arguments starting at end. 1912 // All other arguments passed through verbatim. 1913 int first_apk = -1; 1914 for (i = argc - 1; i >= 0; i--) { 1915 const char* file = argv[i]; 1916 const char* dot = strrchr(file, '.'); 1917 if (dot && !strcasecmp(dot, ".apk")) { 1918 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1919 fprintf(stderr, "Invalid APK file: %s\n", file); 1920 return EXIT_FAILURE; 1921 } 1922 1923 total_size += sb.st_size; 1924 first_apk = i; 1925 } else { 1926 break; 1927 } 1928 } 1929 1930 if (first_apk == -1) { 1931 fprintf(stderr, "Missing APK file\n"); 1932 return 1; 1933 } 1934 1935 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1936 for (i = 1; i < first_apk; i++) { 1937 cmd += " " + escape_arg(argv[i]); 1938 } 1939 1940 // Create install session 1941 std::string error; 1942 int fd = adb_connect(cmd, &error); 1943 if (fd < 0) { 1944 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1945 return EXIT_FAILURE; 1946 } 1947 char buf[BUFSIZ]; 1948 read_status_line(fd, buf, sizeof(buf)); 1949 adb_close(fd); 1950 1951 int session_id = -1; 1952 if (!strncmp("Success", buf, 7)) { 1953 char* start = strrchr(buf, '['); 1954 char* end = strrchr(buf, ']'); 1955 if (start && end) { 1956 *end = '\0'; 1957 session_id = strtol(start + 1, NULL, 10); 1958 } 1959 } 1960 if (session_id < 0) { 1961 fprintf(stderr, "Failed to create session\n"); 1962 fputs(buf, stderr); 1963 return EXIT_FAILURE; 1964 } 1965 1966 // Valid session, now stream the APKs 1967 int success = 1; 1968 for (i = first_apk; i < argc; i++) { 1969 const char* file = argv[i]; 1970 if (stat(file, &sb) == -1) { 1971 fprintf(stderr, "Failed to stat %s\n", file); 1972 success = 0; 1973 goto finalize_session; 1974 } 1975 1976 std::string cmd = android::base::StringPrintf( 1977 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1978 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 1979 1980 int localFd = adb_open(file, O_RDONLY); 1981 if (localFd < 0) { 1982 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1983 success = 0; 1984 goto finalize_session; 1985 } 1986 1987 std::string error; 1988 int remoteFd = adb_connect(cmd, &error); 1989 if (remoteFd < 0) { 1990 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1991 adb_close(localFd); 1992 success = 0; 1993 goto finalize_session; 1994 } 1995 1996 copy_to_file(localFd, remoteFd); 1997 read_status_line(remoteFd, buf, sizeof(buf)); 1998 1999 adb_close(localFd); 2000 adb_close(remoteFd); 2001 2002 if (strncmp("Success", buf, 7)) { 2003 fprintf(stderr, "Failed to write %s\n", file); 2004 fputs(buf, stderr); 2005 success = 0; 2006 goto finalize_session; 2007 } 2008 } 2009 2010finalize_session: 2011 // Commit session if we streamed everything okay; otherwise abandon 2012 std::string service = 2013 android::base::StringPrintf("exec:pm install-%s %d", 2014 success ? "commit" : "abandon", session_id); 2015 fd = adb_connect(service, &error); 2016 if (fd < 0) { 2017 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 2018 return EXIT_FAILURE; 2019 } 2020 read_status_line(fd, buf, sizeof(buf)); 2021 adb_close(fd); 2022 2023 if (!strncmp("Success", buf, 7)) { 2024 fputs(buf, stderr); 2025 return 0; 2026 } else { 2027 fprintf(stderr, "Failed to finalize session\n"); 2028 fputs(buf, stderr); 2029 return EXIT_FAILURE; 2030 } 2031} 2032 2033static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 2034 std::string cmd = "pm"; 2035 2036 while (argc-- > 0) { 2037 cmd += " " + escape_arg(*argv++); 2038 } 2039 2040 return send_shell_command(transport, serial, cmd, false); 2041} 2042 2043static int uninstall_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2044 /* if the user choose the -k option, we refuse to do it until devices are 2045 out with the option to uninstall the remaining data somehow (adb/ui) */ 2046 int i; 2047 for (i = 1; i < argc; i++) { 2048 if (!strcmp(argv[i], "-k")) { 2049 printf( 2050 "The -k option uninstalls the application while retaining the data/cache.\n" 2051 "At the moment, there is no way to remove the remaining data.\n" 2052 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 2053 "If you truly wish to continue, execute 'adb shell pm uninstall -k'\n."); 2054 return EXIT_FAILURE; 2055 } 2056 } 2057 2058 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 2059 return pm_command(transport, serial, argc, argv); 2060} 2061 2062static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 2063 std::string cmd = "rm -f " + escape_arg(filename); 2064 return send_shell_command(transport, serial, cmd, false); 2065} 2066 2067static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { 2068 static const char *const DATA_DEST = "/data/local/tmp/%s"; 2069 static const char *const SD_DEST = "/sdcard/tmp/%s"; 2070 const char* where = DATA_DEST; 2071 int i; 2072 struct stat sb; 2073 2074 for (i = 1; i < argc; i++) { 2075 if (!strcmp(argv[i], "-s")) { 2076 where = SD_DEST; 2077 } 2078 } 2079 2080 // Find last APK argument. 2081 // All other arguments passed through verbatim. 2082 int last_apk = -1; 2083 for (i = argc - 1; i >= 0; i--) { 2084 const char* file = argv[i]; 2085 const char* dot = strrchr(file, '.'); 2086 if (dot && !strcasecmp(dot, ".apk")) { 2087 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 2088 fprintf(stderr, "Invalid APK file: %s\n", file); 2089 return EXIT_FAILURE; 2090 } 2091 2092 last_apk = i; 2093 break; 2094 } 2095 } 2096 2097 if (last_apk == -1) { 2098 fprintf(stderr, "Missing APK file\n"); 2099 return EXIT_FAILURE; 2100 } 2101 2102 int result = -1; 2103 std::vector<const char*> apk_file = {argv[last_apk]}; 2104 std::string apk_dest = android::base::StringPrintf( 2105 where, adb_basename(argv[last_apk]).c_str()); 2106 if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk; 2107 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 2108 result = pm_command(transport, serial, argc, argv); 2109 2110cleanup_apk: 2111 delete_file(transport, serial, apk_dest); 2112 return result; 2113} 2114