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