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