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