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