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