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