blob: 23827de69d14d960a2f150e9ee051f82349b7896 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
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
Yabin Cuiaed3c612015-09-22 15:52:57 -070017#define TRACE_TAG ADB
Dan Albert33134262015-03-19 15:21:08 -070018
19#include "sysdeps.h"
20
Dan Albert76649012015-02-24 15:51:19 -080021#include <assert.h>
22#include <ctype.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023#include <errno.h>
Elliott Hughes2940ccf2015-04-17 14:07:52 -070024#include <inttypes.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080025#include <limits.h>
26#include <stdarg.h>
Dan Albert76649012015-02-24 15:51:19 -080027#include <stdint.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080031#include <sys/stat.h>
Dan Albert76649012015-02-24 15:51:19 -080032#include <sys/types.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080033
David Pursell606835a2015-09-08 17:17:02 -070034#include <memory>
Elliott Hughes2baae3a2015-04-17 10:59:34 -070035#include <string>
Josh Gao05786772015-10-30 16:57:19 -070036#include <vector>
Elliott Hughes2baae3a2015-04-17 10:59:34 -070037
Elliott Hughes4f713192015-12-04 22:00:26 -080038#include <android-base/logging.h>
39#include <android-base/stringprintf.h>
40#include <android-base/strings.h>
Elliott Hughes2baae3a2015-04-17 10:59:34 -070041
Yabin Cuid325e862014-11-17 14:48:25 -080042#if !defined(_WIN32)
Josh Gao8dcdb572015-10-23 15:03:31 -070043#include <signal.h>
Elliott Hughes0fbf9612015-11-04 13:07:47 -080044#include <sys/ioctl.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080045#include <termios.h>
Dan Albert76649012015-02-24 15:51:19 -080046#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080047#endif
48
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080049#include "adb.h"
Nick Kralevichbea3f9c2014-11-13 15:17:29 -080050#include "adb_auth.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080051#include "adb_client.h"
52#include "adb_io.h"
Elliott Hughes58305772015-04-17 13:57:15 -070053#include "adb_utils.h"
Felipe Leme78e09632016-07-19 17:07:22 -070054#include "bugreport.h"
55#include "commandline.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080056#include "file_sync_service.h"
David Pursell70ef7b42015-09-30 13:35:42 -070057#include "services.h"
David Pursell606835a2015-09-08 17:17:02 -070058#include "shell_service.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080059
Elliott Hughes3bd73c12015-05-05 13:10:43 -070060static int install_app(TransportType t, const char* serial, int argc, const char** argv);
61static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv);
62static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv);
Todd Kennedy6fa848a2015-11-03 16:53:08 -080063static int install_app_legacy(TransportType t, const char* serial, int argc, const char** argv);
64static int uninstall_app_legacy(TransportType t, const char* serial, int argc, const char** argv);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080065
Josh Gaob7b1edf2015-11-11 17:56:12 -080066static auto& gProductOutPath = *new std::string();
Matt Gumbeld7b33082012-11-14 10:16:17 -080067extern int gListenAll;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080068
Felipe Leme07ac8552016-07-26 12:14:39 -070069DefaultStandardStreamsCallback DEFAULT_STANDARD_STREAMS_CALLBACK(nullptr, nullptr);
70
Elliott Hughes58305772015-04-17 13:57:15 -070071static std::string product_file(const char *extra) {
72 if (gProductOutPath.empty()) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080073 fprintf(stderr, "adb: Product directory not specified; "
74 "use -p or define ANDROID_PRODUCT_OUT\n");
75 exit(1);
76 }
77
Elliott Hughes58305772015-04-17 13:57:15 -070078 return android::base::StringPrintf("%s%s%s",
79 gProductOutPath.c_str(), OS_PATH_SEPARATOR_STR, extra);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080080}
81
Elliott Hughes58305772015-04-17 13:57:15 -070082static void help() {
Elliott Hughes42ae2602015-08-12 08:32:10 -070083 fprintf(stderr, "%s\n", adb_version().c_str());
Felipe Leme307951e2016-07-29 17:57:00 -070084 // clang-format off
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080085 fprintf(stderr,
Matt Gumbeld7b33082012-11-14 10:16:17 -080086 " -a - directs adb to listen on all interfaces for a connection\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080087 " -d - directs command to the only connected USB device\n"
88 " returns an error if more than one USB device is present.\n"
89 " -e - directs command to the only running emulator.\n"
90 " returns an error if more than one emulator is running.\n"
Scott Andersone109d262012-04-20 11:21:14 -070091 " -s <specific device> - directs command to the device or emulator with the given\n"
Scott Anderson2ca3e6b2012-05-30 18:11:27 -070092 " serial number or qualifier. Overrides ANDROID_SERIAL\n"
Elliott Hughes31dbed72009-10-07 15:38:53 -070093 " environment variable.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080094 " -p <product name or path> - simple product name like 'sooner', or\n"
95 " a relative/absolute path to a product\n"
96 " out directory like 'out/target/product/sooner'.\n"
97 " If -p is not specified, the ANDROID_PRODUCT_OUT\n"
98 " environment variable is used, which must\n"
99 " be an absolute path.\n"
Matt Gumbeld7b33082012-11-14 10:16:17 -0800100 " -H - Name of adb server host (default: localhost)\n"
101 " -P - Port of adb server (default: 5037)\n"
Scott Andersone109d262012-04-20 11:21:14 -0700102 " devices [-l] - list all connected devices\n"
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700103 " ('-l' will also list device qualifiers)\n"
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400104 " connect <host>[:<port>] - connect to a device via TCP/IP\n"
105 " Port 5555 is used by default if no port number is specified.\n"
106 " disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.\n"
107 " Port 5555 is used by default if no port number is specified.\n"
Bernhard Reutner-Fischer6715a432011-04-26 12:46:05 +0200108 " Using this command with no additional arguments\n"
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400109 " will disconnect from all connected TCP/IP devices.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800110 "\n"
111 "device commands:\n"
Josh Gao05786772015-10-30 16:57:19 -0700112 " adb push <local>... <remote>\n"
113 " - copy files/dirs to device\n"
114 " adb pull [-a] <remote>... <local>\n"
115 " - copy files/dirs from device\n"
116 " (-a preserves file timestamp and mode)\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800117 " adb sync [ <directory> ] - copy host->device only if changed\n"
Anthony Newnam705c9442010-02-22 08:36:49 -0600118 " (-l means list but don't copy)\n"
Josh Gao7d586072015-11-20 15:37:31 -0800119 " adb shell [-e escape] [-n] [-Tt] [-x] [command]\n"
Elliott Hughes0e42c2a2015-11-10 10:54:44 -0800120 " - run remote shell command (interactive shell if no command given)\n"
121 " (-e: choose escape character, or \"none\"; default '~')\n"
Josh Gao7d586072015-11-20 15:37:31 -0800122 " (-n: don't read from stdin)\n"
Elliott Hughes0e42c2a2015-11-10 10:54:44 -0800123 " (-T: disable PTY allocation)\n"
124 " (-t: force PTY allocation)\n"
125 " (-x: disable remote exit codes and stdout/stderr separation)\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800126 " adb emu <command> - run emulator console command\n"
127 " adb logcat [ <filter-spec> ] - View device log\n"
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100128 " adb forward --list - list all forward socket connections.\n"
129 " the format is a list of lines with the following format:\n"
130 " <serial> \" \" <local> \" \" <remote> \"\\n\"\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800131 " adb forward <local> <remote> - forward socket connections\n"
132 " forward specs are one of: \n"
133 " tcp:<port>\n"
134 " localabstract:<unix domain socket name>\n"
135 " localreserved:<unix domain socket name>\n"
136 " localfilesystem:<unix domain socket name>\n"
137 " dev:<character device name>\n"
138 " jdwp:<process pid> (remote only)\n"
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100139 " adb forward --no-rebind <local> <remote>\n"
140 " - same as 'adb forward <local> <remote>' but fails\n"
141 " if <local> is already forwarded\n"
142 " adb forward --remove <local> - remove a specific forward socket connection\n"
143 " adb forward --remove-all - remove all forward socket connections\n"
David 'Digit' Turner25258692013-03-21 21:07:42 +0100144 " adb reverse --list - list all reverse socket connections from device\n"
145 " adb reverse <remote> <local> - reverse socket connections\n"
146 " reverse specs are one of:\n"
147 " tcp:<port>\n"
148 " localabstract:<unix domain socket name>\n"
149 " localreserved:<unix domain socket name>\n"
150 " localfilesystem:<unix domain socket name>\n"
Spencer Low587ea202015-11-02 17:34:49 -0800151 " adb reverse --no-rebind <remote> <local>\n"
David 'Digit' Turner25258692013-03-21 21:07:42 +0100152 " - same as 'adb reverse <remote> <local>' but fails\n"
153 " if <remote> is already reversed.\n"
154 " adb reverse --remove <remote>\n"
155 " - remove a specific reversed socket connection\n"
156 " adb reverse --remove-all - remove all reversed socket connections from device\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800157 " adb jdwp - list PIDs of processes hosting a JDWP transport\n"
Lorenzo Colitti0b3baac2015-05-28 12:03:44 +0900158 " adb install [-lrtsdg] <file>\n"
Svetoslav23d84072015-06-01 16:02:50 -0700159 " - push this package file to the device and install it\n"
160 " (-l: forward lock application)\n"
161 " (-r: replace existing application)\n"
162 " (-t: allow test packages)\n"
163 " (-s: install application on sdcard)\n"
Alex Klyubin85ed9752016-02-24 16:07:47 -0800164 " (-d: allow version code downgrade (debuggable packages only))\n"
Svetoslav23d84072015-06-01 16:02:50 -0700165 " (-g: grant all runtime permissions)\n"
Lorenzo Colitti0b3baac2015-05-28 12:03:44 +0900166 " adb install-multiple [-lrtsdpg] <file...>\n"
Anonymous Coward4474ac42012-04-24 10:43:41 -0700167 " - push this package file to the device and install it\n"
Jeff Sharkey960df972014-06-09 17:30:57 -0700168 " (-l: forward lock application)\n"
169 " (-r: replace existing application)\n"
170 " (-t: allow test packages)\n"
171 " (-s: install application on sdcard)\n"
Alex Klyubin85ed9752016-02-24 16:07:47 -0800172 " (-d: allow version code downgrade (debuggable packages only))\n"
Jeff Sharkey960df972014-06-09 17:30:57 -0700173 " (-p: partial application install)\n"
Lorenzo Colitti0b3baac2015-05-28 12:03:44 +0900174 " (-g: grant all runtime permissions)\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800175 " adb uninstall [-k] <package> - remove this app package from the device\n"
176 " ('-k' means keep the data and cache directories)\n"
Felipe Leme307951e2016-07-29 17:57:00 -0700177 " adb bugreport [<path>] - return all information from the device that should be included in a zipped bug report.\n"
178 " If <path> is a file, the bug report will be saved as that file.\n"
179 " If <path> is a directory, the bug report will be saved in that directory with the name provided by the device.\n"
180 " If <path> is omitted, the bug report will be saved in the current directory with the name provided by the device.\n"
181 " NOTE: if the device does not support zipped bug reports, the bug report will be output on stdout.\n"
Christopher Tate0c06eb52013-03-06 16:40:52 -0800182 " adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n"
Christopher Tate56885092011-10-03 18:27:01 -0700183 " - write an archive of the device's data to <file>.\n"
184 " If no -f option is supplied then the data is written\n"
185 " to \"backup.ab\" in the current directory.\n"
Christopher Tated2f54152011-04-21 12:53:28 -0700186 " (-apk|-noapk enable/disable backup of the .apks themselves\n"
Christopher Tatede034ec2011-08-09 17:05:29 -0700187 " in the archive; the default is noapk.)\n"
Christopher Tate0c06eb52013-03-06 16:40:52 -0800188 " (-obb|-noobb enable/disable backup of any installed apk expansion\n"
189 " (aka .obb) files associated with each application; the default\n"
190 " is noobb.)\n"
Christopher Tated2f54152011-04-21 12:53:28 -0700191 " (-shared|-noshared enable/disable backup of the device's\n"
192 " shared storage / SD card contents; the default is noshared.)\n"
193 " (-all means to back up all installed applications)\n"
Christopher Tate56885092011-10-03 18:27:01 -0700194 " (-system|-nosystem toggles whether -all automatically includes\n"
195 " system applications; the default is to include system apps)\n"
Christopher Tated2f54152011-04-21 12:53:28 -0700196 " (<packages...> is the list of applications to be backed up. If\n"
197 " the -all or -shared flags are passed, then the package\n"
Christopher Tate56885092011-10-03 18:27:01 -0700198 " list is optional. Applications explicitly given on the\n"
199 " command line will be included even if -nosystem would\n"
200 " ordinarily cause them to be omitted.)\n"
Christopher Tated2f54152011-04-21 12:53:28 -0700201 "\n"
Christopher Tatede034ec2011-08-09 17:05:29 -0700202 " adb restore <file> - restore device contents from the <file> backup archive\n"
Christopher Tate702967a2011-05-17 15:52:54 -0700203 "\n"
Paul Lawrence982089d2014-12-03 15:31:57 -0800204 " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n"
205 " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n"
Nick Kralevichbea3f9c2014-11-13 15:17:29 -0800206 " adb keygen <file> - generate adb public/private key. The private key is stored in <file>,\n"
207 " and the public key is stored in <file>.pub. Any existing files\n"
208 " are overwritten.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800209 " adb help - show this help message\n"
210 " adb version - show version num\n"
211 "\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800212 "scripting:\n"
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100213 " adb wait-for[-<transport>]-<state>\n"
214 " - wait for device to be in the given state:\n"
215 " device, recovery, sideload, or bootloader\n"
216 " Transport is: usb, local or any [default=any]\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800217 " adb start-server - ensure that there is a server running\n"
218 " adb kill-server - kill the server if it is running\n"
219 " adb get-state - prints: offline | bootloader | device\n"
220 " adb get-serialno - prints: <serial-number>\n"
Scott Andersone109d262012-04-20 11:21:14 -0700221 " adb get-devpath - prints: <device-path>\n"
Elliott Hughesec7a6672015-03-16 21:58:32 +0000222 " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n"
Tao Bao175b7bb2015-03-29 11:22:34 -0700223 " adb reboot [bootloader|recovery]\n"
224 " - reboots the device, optionally into the bootloader or recovery program.\n"
225 " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n"
226 " adb reboot sideload-auto-reboot\n"
227 " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n"
Elliott Hughes7e067cf2015-06-12 14:26:29 -0700228 " adb sideload <file> - sideloads the given package\n"
Mike Lockwoodff196702009-08-24 15:58:40 -0700229 " adb root - restarts the adbd daemon with root permissions\n"
Dan Pasanen98858812014-10-06 12:57:20 -0500230 " adb unroot - restarts the adbd daemon without root permissions\n"
Romain Guy311add42009-12-14 14:42:17 -0800231 " adb usb - restarts the adbd daemon listening on USB\n"
Paul Lawrenceec900bb2014-10-09 14:22:49 +0000232 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port\n"
Elliott Hughes7e067cf2015-06-12 14:26:29 -0700233 "\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800234 "networking:\n"
235 " adb ppp <tty> [parameters] - Run PPP over USB.\n"
Kenny Rootc9891992009-06-08 14:40:30 -0500236 " Note: you should not automatically start a PPP connection.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800237 " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n"
238 " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n"
239 "\n"
240 "adb sync notes: adb sync [ <directory> ]\n"
241 " <localdir> can be interpreted in several ways:\n"
242 "\n"
Elliott Hughesec7a6672015-03-16 21:58:32 +0000243 " - If <directory> is not specified, /system, /vendor (if present), /oem (if present) and /data partitions will be updated.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800244 "\n"
Elliott Hughesec7a6672015-03-16 21:58:32 +0000245 " - If it is \"system\", \"vendor\", \"oem\" or \"data\", only the corresponding partition\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800246 " is updated.\n"
Timcd643152010-02-16 20:18:29 +0000247 "\n"
Yabin Cui03468c82016-04-05 13:50:44 -0700248 "internal debugging:\n"
249 " adb reconnect Kick current connection from host side and make it reconnect.\n"
250 " adb reconnect device Kick current connection from device side and make it reconnect.\n"
Elliott Hughes7e067cf2015-06-12 14:26:29 -0700251 "environment variables:\n"
Timcd643152010-02-16 20:18:29 +0000252 " ADB_TRACE - Print debug information. A comma separated list of the following values\n"
253 " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n"
254 " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n"
Felipe Leme307951e2016-07-29 17:57:00 -0700255 " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n");
256 // clang-format on
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800257}
258
Felipe Leme78e09632016-07-19 17:07:22 -0700259int usage() {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800260 help();
261 return 1;
262}
263
Yabin Cuid325e862014-11-17 14:48:25 -0800264#if defined(_WIN32)
265
Elliott Hughesa2f2e562015-04-16 16:47:02 -0700266// Implemented in sysdeps_win32.cpp.
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800267void stdin_raw_init();
268void stdin_raw_restore();
Yabin Cuid325e862014-11-17 14:48:25 -0800269
270#else
Alistair Buxtondfa09fd2013-03-01 22:16:41 +0100271static termios g_saved_terminal_state;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800272
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800273static void stdin_raw_init() {
274 if (tcgetattr(STDIN_FILENO, &g_saved_terminal_state)) return;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275
Alistair Buxtondfa09fd2013-03-01 22:16:41 +0100276 termios tio;
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800277 if (tcgetattr(STDIN_FILENO, &tio)) return;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800278
Alistair Buxtondfa09fd2013-03-01 22:16:41 +0100279 cfmakeraw(&tio);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800280
Alistair Buxtondfa09fd2013-03-01 22:16:41 +0100281 // No timeout but request at least one character per read.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800282 tio.c_cc[VTIME] = 0;
283 tio.c_cc[VMIN] = 1;
284
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800285 tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800286}
287
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800288static void stdin_raw_restore() {
289 tcsetattr(STDIN_FILENO, TCSAFLUSH, &g_saved_terminal_state);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800290}
291#endif
292
David Pursell606835a2015-09-08 17:17:02 -0700293// Reads from |fd| and prints received data. If |use_shell_protocol| is true
294// this expects that incoming data will use the shell protocol, in which case
295// stdout/stderr are routed independently and the remote exit code will be
296// returned.
Felipe Leme07ac8552016-07-26 12:14:39 -0700297// if |callback| is non-null, stdout/stderr output will be handled by it.
298int read_and_dump(int fd, bool use_shell_protocol = false,
299 StandardStreamsCallbackInterface* callback = &DEFAULT_STANDARD_STREAMS_CALLBACK) {
David Pursell606835a2015-09-08 17:17:02 -0700300 int exit_code = 0;
Felipe Lemed1dd1252016-06-06 16:05:36 -0700301 if (fd < 0) return exit_code;
302
David Pursell606835a2015-09-08 17:17:02 -0700303 std::unique_ptr<ShellProtocol> protocol;
304 int length = 0;
David Pursell606835a2015-09-08 17:17:02 -0700305
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
Felipe Lemed1dd1252016-06-06 16:05:36 -0700317 while (true) {
David Pursell606835a2015-09-08 17:17:02 -0700318 if (use_shell_protocol) {
319 if (!protocol->Read()) {
320 break;
321 }
Felipe Leme07ac8552016-07-26 12:14:39 -0700322 length = protocol->data_length();
David Pursell606835a2015-09-08 17:17:02 -0700323 switch (protocol->id()) {
324 case ShellProtocol::kIdStdout:
Felipe Leme07ac8552016-07-26 12:14:39 -0700325 callback->OnStdout(buffer_ptr, length);
David Pursell606835a2015-09-08 17:17:02 -0700326 break;
327 case ShellProtocol::kIdStderr:
Felipe Leme07ac8552016-07-26 12:14:39 -0700328 callback->OnStderr(buffer_ptr, length);
David Pursell606835a2015-09-08 17:17:02 -0700329 break;
330 case ShellProtocol::kIdExit:
331 exit_code = protocol->data()[0];
332 continue;
333 default:
334 continue;
335 }
336 length = protocol->data_length();
337 } else {
338 D("read_and_dump(): pre adb_read(fd=%d)", fd);
339 length = adb_read(fd, raw_buffer, sizeof(raw_buffer));
340 D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length);
341 if (length <= 0) {
342 break;
343 }
Felipe Leme07ac8552016-07-26 12:14:39 -0700344 callback->OnStdout(buffer_ptr, length);
Felipe Leme44a42672016-04-01 17:43:27 -0700345 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800346 }
David Pursell606835a2015-09-08 17:17:02 -0700347
Felipe Leme07ac8552016-07-26 12:14:39 -0700348 return callback->Done(exit_code);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800349}
350
Jeff Sharkey960df972014-06-09 17:30:57 -0700351static void read_status_line(int fd, char* buf, size_t count)
352{
353 count--;
354 while (count > 0) {
355 int len = adb_read(fd, buf, count);
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700356 if (len <= 0) {
Jeff Sharkey960df972014-06-09 17:30:57 -0700357 break;
358 }
359
360 buf += len;
361 count -= len;
362 }
363 *buf = '\0';
364}
365
Christopher Tate2bcdda82016-07-06 13:22:22 -0700366static void stdinout_raw_prologue(int inFd, int outFd, int& old_stdin_mode, int& old_stdout_mode) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700367 if (inFd == STDIN_FILENO) {
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800368 stdin_raw_init();
Spencer Lowb7dfb792015-05-22 16:48:31 -0700369#ifdef _WIN32
370 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY);
371 if (old_stdin_mode == -1) {
372 fatal_errno("could not set stdin to binary");
373 }
374#endif
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700375 }
Yabin Cuid325e862014-11-17 14:48:25 -0800376
Spencer Lowb7dfb792015-05-22 16:48:31 -0700377#ifdef _WIN32
378 if (outFd == STDOUT_FILENO) {
379 old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY);
380 if (old_stdout_mode == -1) {
381 fatal_errno("could not set stdout to binary");
382 }
383 }
384#endif
Christopher Tate2bcdda82016-07-06 13:22:22 -0700385}
386
387static void stdinout_raw_epilogue(int inFd, int outFd, int old_stdin_mode, int old_stdout_mode) {
388 if (inFd == STDIN_FILENO) {
389 stdin_raw_restore();
390#ifdef _WIN32
391 if (_setmode(STDIN_FILENO, old_stdin_mode) == -1) {
392 fatal_errno("could not restore stdin mode");
393 }
394#endif
395 }
396
397#ifdef _WIN32
398 if (outFd == STDOUT_FILENO) {
399 if (_setmode(STDOUT_FILENO, old_stdout_mode) == -1) {
400 fatal_errno("could not restore stdout mode");
401 }
402 }
403#endif
404}
405
406static void copy_to_file(int inFd, int outFd) {
407 const size_t BUFSIZE = 32 * 1024;
408 char* buf = (char*) malloc(BUFSIZE);
409 if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file");
410 int len;
411 long total = 0;
412 int old_stdin_mode = -1;
413 int old_stdout_mode = -1;
414
415 D("copy_to_file(%d -> %d)", inFd, outFd);
416
417 stdinout_raw_prologue(inFd, outFd, old_stdin_mode, old_stdout_mode);
Spencer Lowb7dfb792015-05-22 16:48:31 -0700418
Elliott Hughesa7090b92015-04-17 17:03:59 -0700419 while (true) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700420 if (inFd == STDIN_FILENO) {
421 len = unix_read(inFd, buf, BUFSIZE);
422 } else {
423 len = adb_read(inFd, buf, BUFSIZE);
424 }
Christopher Tated2f54152011-04-21 12:53:28 -0700425 if (len == 0) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700426 D("copy_to_file() : read 0 bytes; exiting");
Christopher Tated2f54152011-04-21 12:53:28 -0700427 break;
428 }
429 if (len < 0) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700430 D("copy_to_file(): read failed: %s", strerror(errno));
Christopher Tated2f54152011-04-21 12:53:28 -0700431 break;
432 }
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700433 if (outFd == STDOUT_FILENO) {
434 fwrite(buf, 1, len, stdout);
435 fflush(stdout);
436 } else {
437 adb_write(outFd, buf, len);
438 }
Christopher Tatec9cd3b92011-06-01 17:56:23 -0700439 total += len;
Christopher Tated2f54152011-04-21 12:53:28 -0700440 }
Yabin Cuid325e862014-11-17 14:48:25 -0800441
Christopher Tate2bcdda82016-07-06 13:22:22 -0700442 stdinout_raw_epilogue(inFd, outFd, old_stdin_mode, old_stdout_mode);
Spencer Lowb7dfb792015-05-22 16:48:31 -0700443
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700444 D("copy_to_file() finished after %lu bytes", total);
Christopher Tate5b811fa2011-06-10 11:38:37 -0700445 free(buf);
Christopher Tated2f54152011-04-21 12:53:28 -0700446}
447
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800448static void send_window_size_change(int fd, std::unique_ptr<ShellProtocol>& shell) {
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800449 // Old devices can't handle window size changes.
450 if (shell == nullptr) return;
451
Spencer Low2e02dc62015-11-07 17:34:39 -0800452#if defined(_WIN32)
453 struct winsize {
454 unsigned short ws_row;
455 unsigned short ws_col;
456 unsigned short ws_xpixel;
457 unsigned short ws_ypixel;
458 };
459#endif
460
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800461 winsize ws;
Spencer Low2e02dc62015-11-07 17:34:39 -0800462
463#if defined(_WIN32)
464 // If stdout is redirected to a non-console, we won't be able to get the
465 // console size, but that makes sense.
466 const intptr_t intptr_handle = _get_osfhandle(STDOUT_FILENO);
467 if (intptr_handle == -1) return;
468
469 const HANDLE handle = reinterpret_cast<const HANDLE>(intptr_handle);
470
471 CONSOLE_SCREEN_BUFFER_INFO info;
472 memset(&info, 0, sizeof(info));
473 if (!GetConsoleScreenBufferInfo(handle, &info)) return;
474
475 memset(&ws, 0, sizeof(ws));
476 // The number of visible rows, excluding offscreen scroll-back rows which are in info.dwSize.Y.
477 ws.ws_row = info.srWindow.Bottom - info.srWindow.Top + 1;
478 // If the user has disabled "Wrap text output on resize", they can make the screen buffer wider
479 // than the window, in which case we should use the width of the buffer.
480 ws.ws_col = info.dwSize.X;
481#else
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800482 if (ioctl(fd, TIOCGWINSZ, &ws) == -1) return;
Spencer Low2e02dc62015-11-07 17:34:39 -0800483#endif
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800484
485 // Send the new window size as human-readable ASCII for debugging convenience.
486 size_t l = snprintf(shell->data(), shell->data_capacity(), "%dx%d,%dx%d",
487 ws.ws_row, ws.ws_col, ws.ws_xpixel, ws.ws_ypixel);
488 shell->Write(ShellProtocol::kIdWindowSizeChange, l + 1);
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800489}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800490
David Pursell606835a2015-09-08 17:17:02 -0700491// Used to pass multiple values to the stdin read thread.
492struct StdinReadArgs {
493 int stdin_fd, write_fd;
David Pursell1ed57f02015-10-06 15:30:03 -0700494 bool raw_stdin;
David Pursell606835a2015-09-08 17:17:02 -0700495 std::unique_ptr<ShellProtocol> protocol;
Elliott Hughes28416d62015-11-04 13:36:32 -0800496 char escape_char;
David Pursell606835a2015-09-08 17:17:02 -0700497};
498
David Pursell606835a2015-09-08 17:17:02 -0700499// Loops to read from stdin and push the data to the given FD.
500// The argument should be a pointer to a StdinReadArgs object. This function
501// will take ownership of the object and delete it when finished.
Josh Gaod9db09c2016-02-12 14:31:15 -0800502static void stdin_read_thread_loop(void* x) {
David Pursell606835a2015-09-08 17:17:02 -0700503 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800504
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800505#if !defined(_WIN32)
506 // Mask SIGTTIN in case we're in a backgrounded process.
Josh Gao8dcdb572015-10-23 15:03:31 -0700507 sigset_t sigset;
508 sigemptyset(&sigset);
509 sigaddset(&sigset, SIGTTIN);
510 pthread_sigmask(SIG_BLOCK, &sigset, nullptr);
511#endif
512
Spencer Low2e02dc62015-11-07 17:34:39 -0800513#if defined(_WIN32)
514 // _get_interesting_input_record_uncached() causes unix_read_interruptible()
515 // to return -1 with errno == EINTR if the window size changes.
516#else
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800517 // Unblock SIGWINCH for this thread, so our read(2) below will be
518 // interrupted if the window size changes.
519 sigset_t mask;
520 sigemptyset(&mask);
521 sigaddset(&mask, SIGWINCH);
522 pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
523#endif
524
525 // Set up the initial window size.
526 send_window_size_change(args->stdin_fd, args->protocol);
527
Elliott Hughes28416d62015-11-04 13:36:32 -0800528 char raw_buffer[BUFSIZ];
David Pursell606835a2015-09-08 17:17:02 -0700529 char* buffer_ptr = raw_buffer;
530 size_t buffer_size = sizeof(raw_buffer);
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800531 if (args->protocol != nullptr) {
David Pursell606835a2015-09-08 17:17:02 -0700532 buffer_ptr = args->protocol->data();
533 buffer_size = args->protocol->data_capacity();
534 }
535
Elliott Hughes28416d62015-11-04 13:36:32 -0800536 // If we need to parse escape sequences, make life easy.
537 if (args->raw_stdin && args->escape_char != '\0') {
538 buffer_size = 1;
539 }
540
541 enum EscapeState { kMidFlow, kStartOfLine, kInEscape };
542 EscapeState state = kStartOfLine;
543
Elliott Hughesaa245492015-08-03 10:38:08 -0700544 while (true) {
Spencer Low2e02dc62015-11-07 17:34:39 -0800545 // Use unix_read_interruptible() rather than adb_read() for stdin.
546 D("stdin_read_thread_loop(): pre unix_read_interruptible(fdi=%d,...)", args->stdin_fd);
547 int r = unix_read_interruptible(args->stdin_fd, buffer_ptr,
548 buffer_size);
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800549 if (r == -1 && errno == EINTR) {
550 send_window_size_change(args->stdin_fd, args->protocol);
551 continue;
552 }
Spencer Low2e02dc62015-11-07 17:34:39 -0800553 D("stdin_read_thread_loop(): post unix_read_interruptible(fdi=%d,...)", args->stdin_fd);
David Pursell1ed57f02015-10-06 15:30:03 -0700554 if (r <= 0) {
555 // Only devices using the shell protocol know to close subprocess
556 // stdin. For older devices we want to just leave the connection
557 // open, otherwise an unpredictable amount of return data could
558 // be lost due to the FD closing before all data has been received.
559 if (args->protocol) {
560 args->protocol->Write(ShellProtocol::kIdCloseStdin, 0);
561 }
562 break;
563 }
Elliott Hughes28416d62015-11-04 13:36:32 -0800564 // If we made stdin raw, check input for escape sequences. In
David Pursell1ed57f02015-10-06 15:30:03 -0700565 // this situation signals like Ctrl+C are sent remotely rather than
566 // interpreted locally so this provides an emergency out if the remote
567 // process starts ignoring the signal. SSH also does this, see the
568 // "escape characters" section on the ssh man page for more info.
Elliott Hughes28416d62015-11-04 13:36:32 -0800569 if (args->raw_stdin && args->escape_char != '\0') {
570 char ch = buffer_ptr[0];
571 if (ch == args->escape_char) {
572 if (state == kStartOfLine) {
573 state = kInEscape;
574 // Swallow the escape character.
575 continue;
576 } else {
577 state = kMidFlow;
578 }
579 } else {
580 if (state == kInEscape) {
581 if (ch == '.') {
582 fprintf(stderr,"\r\n[ disconnected ]\r\n");
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800583 stdin_raw_restore();
David Pursell1ed57f02015-10-06 15:30:03 -0700584 exit(0);
Elliott Hughes28416d62015-11-04 13:36:32 -0800585 } else {
586 // We swallowed an escape character that wasn't part of
587 // a valid escape sequence; time to cough it up.
588 buffer_ptr[0] = args->escape_char;
589 buffer_ptr[1] = ch;
590 ++r;
David Pursell1ed57f02015-10-06 15:30:03 -0700591 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800592 }
Elliott Hughes28416d62015-11-04 13:36:32 -0800593 state = (ch == '\n' || ch == '\r') ? kStartOfLine : kMidFlow;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800594 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800595 }
David Pursell606835a2015-09-08 17:17:02 -0700596 if (args->protocol) {
597 if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) {
598 break;
599 }
600 } else {
601 if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) {
602 break;
603 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800604 }
605 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800606}
607
David Pursell1ed57f02015-10-06 15:30:03 -0700608// Returns a shell service string with the indicated arguments and command.
609static std::string ShellServiceString(bool use_shell_protocol,
610 const std::string& type_arg,
611 const std::string& command) {
612 std::vector<std::string> args;
613 if (use_shell_protocol) {
614 args.push_back(kShellServiceArgShellProtocol);
Elliott Hughesc2252df2015-11-18 12:45:48 -0800615
616 const char* terminal_type = getenv("TERM");
617 if (terminal_type != nullptr) {
618 args.push_back(std::string("TERM=") + terminal_type);
619 }
David Pursell1ed57f02015-10-06 15:30:03 -0700620 }
621 if (!type_arg.empty()) {
622 args.push_back(type_arg);
623 }
624
625 // Shell service string can look like: shell[,arg1,arg2,...]:[command].
626 return android::base::StringPrintf("shell%s%s:%s",
627 args.empty() ? "" : ",",
628 android::base::Join(args, ',').c_str(),
629 command.c_str());
630}
631
632// Connects to a shell on the device and read/writes data.
633//
634// Note: currently this function doesn't properly clean up resources; the
635// FD connected to the adb server is never closed and the stdin read thread
636// may never exit.
637//
638// On success returns the remote exit code if |use_shell_protocol| is true,
639// 0 otherwise. On failure returns 1.
640static int RemoteShell(bool use_shell_protocol, const std::string& type_arg,
Elliott Hughes28416d62015-11-04 13:36:32 -0800641 char escape_char,
David Pursell1ed57f02015-10-06 15:30:03 -0700642 const std::string& command) {
643 std::string service_string = ShellServiceString(use_shell_protocol,
644 type_arg, command);
645
646 // Make local stdin raw if the device allocates a PTY, which happens if:
647 // 1. We are explicitly asking for a PTY shell, or
648 // 2. We don't specify shell type and are starting an interactive session.
649 bool raw_stdin = (type_arg == kShellServiceArgPty ||
650 (type_arg.empty() && command.empty()));
651
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700652 std::string error;
David Pursell4e2fd362015-09-22 10:43:08 -0700653 int fd = adb_connect(service_string, &error);
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700654 if (fd < 0) {
655 fprintf(stderr,"error: %s\n", error.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800656 return 1;
657 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800658
David Pursell606835a2015-09-08 17:17:02 -0700659 StdinReadArgs* args = new StdinReadArgs;
660 if (!args) {
661 LOG(ERROR) << "couldn't allocate StdinReadArgs object";
Elliott Hughesdc3b4592015-04-21 19:39:52 -0700662 return 1;
663 }
David Pursell1ed57f02015-10-06 15:30:03 -0700664 args->stdin_fd = STDIN_FILENO;
David Pursell606835a2015-09-08 17:17:02 -0700665 args->write_fd = fd;
David Pursell1ed57f02015-10-06 15:30:03 -0700666 args->raw_stdin = raw_stdin;
Elliott Hughes28416d62015-11-04 13:36:32 -0800667 args->escape_char = escape_char;
David Pursell606835a2015-09-08 17:17:02 -0700668 if (use_shell_protocol) {
669 args->protocol.reset(new ShellProtocol(args->write_fd));
670 }
Elliott Hughesdc3b4592015-04-21 19:39:52 -0700671
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800672 if (raw_stdin) stdin_raw_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800673
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800674#if !defined(_WIN32)
675 // Ensure our process is notified if the local window size changes.
676 // We use sigaction(2) to ensure that the SA_RESTART flag is not set,
677 // because the whole reason we're sending signals is to unblock the read(2)!
678 // That also means we don't need to do anything in the signal handler:
679 // the side effect of delivering the signal is all we need.
680 struct sigaction sa;
681 memset(&sa, 0, sizeof(sa));
682 sa.sa_handler = [](int) {};
683 sa.sa_flags = 0;
684 sigaction(SIGWINCH, &sa, nullptr);
685
686 // Now block SIGWINCH in this thread (the main thread) and all threads spawned
687 // from it. The stdin read thread will unblock this signal to ensure that it's
688 // the thread that receives the signal.
689 sigset_t mask;
690 sigemptyset(&mask);
691 sigaddset(&mask, SIGWINCH);
692 pthread_sigmask(SIG_BLOCK, &mask, nullptr);
693#endif
694
695 // TODO: combine read_and_dump with stdin_read_thread to make life simpler?
696 int exit_code = 1;
697 if (!adb_thread_create(stdin_read_thread_loop, args)) {
David Pursell606835a2015-09-08 17:17:02 -0700698 PLOG(ERROR) << "error starting stdin read thread";
David Pursell606835a2015-09-08 17:17:02 -0700699 delete args;
700 } else {
701 exit_code = read_and_dump(fd, use_shell_protocol);
702 }
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700703
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800704 // TODO: properly exit stdin_read_thread_loop and close |fd|.
David Pursell1ed57f02015-10-06 15:30:03 -0700705
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800706 // TODO: we should probably install signal handlers for this.
707 // TODO: can we use atexit? even on Windows?
708 if (raw_stdin) stdin_raw_restore();
David Pursell1ed57f02015-10-06 15:30:03 -0700709
David Pursell606835a2015-09-08 17:17:02 -0700710 return exit_code;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800711}
712
Josh Gaof3f6a1d2016-01-31 19:12:26 -0800713static int adb_shell(int argc, const char** argv) {
David Pursell0aacbbe2016-01-21 19:56:50 -0800714 FeatureSet features;
Josh Gaof3f6a1d2016-01-31 19:12:26 -0800715 std::string error;
716
717 if (!adb_get_feature_set(&features, &error)) {
718 fprintf(stderr, "error: %s\n", error.c_str());
David Pursell0aacbbe2016-01-21 19:56:50 -0800719 return 1;
720 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800721
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800722 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2);
723 if (!use_shell_protocol) {
724 D("shell protocol not supported, using raw data transfer");
725 } else {
726 D("using shell protocol");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800727 }
Elliott Hughes6452a892015-04-29 12:28:13 -0700728
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800729 // Parse shell-specific command-line options.
730 // argv[0] is always "shell".
731 --argc;
732 ++argv;
733 int t_arg_count = 0;
Elliott Hughes28416d62015-11-04 13:36:32 -0800734 char escape_char = '~';
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800735 while (argc) {
Elliott Hughes28416d62015-11-04 13:36:32 -0800736 if (!strcmp(argv[0], "-e")) {
737 if (argc < 2 || !(strlen(argv[1]) == 1 || strcmp(argv[1], "none") == 0)) {
738 fprintf(stderr, "error: -e requires a single-character argument or 'none'\n");
739 return 1;
740 }
741 escape_char = (strcmp(argv[1], "none") == 0) ? 0 : argv[1][0];
742 argc -= 2;
743 argv += 2;
744 } else if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) {
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800745 // Like ssh, -t arguments are cumulative so that multiple -t's
746 // are needed to force a PTY.
747 if (argv[0][1] == 't') {
748 ++t_arg_count;
749 } else {
750 t_arg_count = -1;
751 }
752 --argc;
753 ++argv;
754 } else if (!strcmp(argv[0], "-x")) {
755 use_shell_protocol = false;
756 --argc;
757 ++argv;
Josh Gao7d586072015-11-20 15:37:31 -0800758 } else if (!strcmp(argv[0], "-n")) {
759 close_stdin();
760
761 --argc;
762 ++argv;
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800763 } else {
764 break;
765 }
Elliott Hughes6452a892015-04-29 12:28:13 -0700766 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800767
David Pursell57dd5ae2016-01-27 16:07:52 -0800768 // Legacy shell protocol requires a remote PTY to close the subprocess properly which creates
769 // some weird interactions with -tT.
770 if (!use_shell_protocol && t_arg_count != 0) {
771 if (!CanUseFeature(features, kFeatureShell2)) {
772 fprintf(stderr, "error: target doesn't support PTY args -Tt\n");
773 } else {
774 fprintf(stderr, "error: PTY args -Tt cannot be used with -x\n");
775 }
776 return 1;
777 }
778
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800779 std::string shell_type_arg;
780 if (CanUseFeature(features, kFeatureShell2)) {
781 if (t_arg_count < 0) {
782 shell_type_arg = kShellServiceArgRaw;
783 } else if (t_arg_count == 0) {
784 // If stdin isn't a TTY, default to a raw shell; this lets
785 // things like `adb shell < my_script.sh` work as expected.
786 // Otherwise leave |shell_type_arg| blank which uses PTY for
787 // interactive shells and raw for non-interactive.
788 if (!unix_isatty(STDIN_FILENO)) {
789 shell_type_arg = kShellServiceArgRaw;
790 }
791 } else if (t_arg_count == 1) {
792 // A single -t arg isn't enough to override implicit -T.
793 if (!unix_isatty(STDIN_FILENO)) {
794 fprintf(stderr,
795 "Remote PTY will not be allocated because stdin is not a terminal.\n"
796 "Use multiple -t options to force remote PTY allocation.\n");
797 shell_type_arg = kShellServiceArgRaw;
798 } else {
799 shell_type_arg = kShellServiceArgPty;
800 }
801 } else {
802 shell_type_arg = kShellServiceArgPty;
803 }
David Pursell71c83122015-09-14 15:33:50 -0700804 }
Elliott Hughesc15b17f2015-11-03 11:18:40 -0800805
806 std::string command;
807 if (argc) {
808 // We don't escape here, just like ssh(1). http://b/20564385.
809 command = android::base::Join(std::vector<const char*>(argv, argv + argc), ' ');
810 }
811
Elliott Hughes28416d62015-11-04 13:36:32 -0800812 return RemoteShell(use_shell_protocol, shell_type_arg, escape_char, command);
David Pursell71c83122015-09-14 15:33:50 -0700813}
814
Elliott Hughes6452a892015-04-29 12:28:13 -0700815static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz,
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700816 bool show_progress)
Doug Zongker447f0612012-01-09 14:54:53 -0800817{
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700818 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -0700819 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error);
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700820 if (fd < 0) {
821 fprintf(stderr,"error: %s\n", error.c_str());
Doug Zongker447f0612012-01-09 14:54:53 -0800822 return -1;
823 }
824
825 int opt = CHUNK_SIZE;
Spencer Lowf055c192015-01-25 14:40:16 -0800826 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt));
Doug Zongker447f0612012-01-09 14:54:53 -0800827
Elliott Hughes6452a892015-04-29 12:28:13 -0700828 unsigned total = sz;
Dan Albertbac34742015-02-25 17:51:28 -0800829 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data);
Doug Zongker447f0612012-01-09 14:54:53 -0800830
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700831 if (show_progress) {
Elliott Hughes3e7048c2015-07-27 21:21:39 -0700832 const char* x = strrchr(service, ':');
833 if (x) service = x + 1;
Doug Zongker447f0612012-01-09 14:54:53 -0800834 }
835
Elliott Hughes6452a892015-04-29 12:28:13 -0700836 while (sz > 0) {
Doug Zongker447f0612012-01-09 14:54:53 -0800837 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz;
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700838 if (!WriteFdExactly(fd, ptr, xfer)) {
839 std::string error;
840 adb_status(fd, &error);
841 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str());
Spencer Low351ecd12015-10-14 17:32:44 -0700842 adb_close(fd);
Doug Zongker447f0612012-01-09 14:54:53 -0800843 return -1;
844 }
845 sz -= xfer;
846 ptr += xfer;
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700847 if (show_progress) {
Magnus Eriksson86ae6d52013-03-05 07:37:32 +0100848 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total))));
Doug Zongker447f0612012-01-09 14:54:53 -0800849 fflush(stdout);
850 }
851 }
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700852 if (show_progress) {
Doug Zongker447f0612012-01-09 14:54:53 -0800853 printf("\n");
854 }
855
Elliott Hughese67f1f82015-04-30 17:32:03 -0700856 if (!adb_status(fd, &error)) {
857 fprintf(stderr,"* error response '%s' *\n", error.c_str());
Spencer Low351ecd12015-10-14 17:32:44 -0700858 adb_close(fd);
Doug Zongker447f0612012-01-09 14:54:53 -0800859 return -1;
860 }
861
862 adb_close(fd);
863 return 0;
864}
865
Doug Zongker71fe5842014-06-26 15:35:36 -0700866#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE)
867
868/*
869 * The sideload-host protocol serves the data in a file (given on the
870 * command line) to the client, using a simple protocol:
871 *
872 * - The connect message includes the total number of bytes in the
873 * file and a block size chosen by us.
874 *
875 * - The other side sends the desired block number as eight decimal
876 * digits (eg "00000023" for block 23). Blocks are numbered from
877 * zero.
878 *
879 * - We send back the data of the requested block. The last block is
880 * likely to be partial; when the last block is requested we only
881 * send the part of the block that exists, it's not padded up to the
882 * block size.
883 *
884 * - When the other side sends "DONEDONE" instead of a block number,
885 * we hang up.
886 */
Elliott Hughes58305772015-04-17 13:57:15 -0700887static int adb_sideload_host(const char* fn) {
Doug Zongker71fe5842014-06-26 15:35:36 -0700888 unsigned sz;
889 size_t xfer = 0;
890 int status;
Dan Albertbac34742015-02-25 17:51:28 -0800891 int last_percent = -1;
892 int opt = SIDELOAD_HOST_BLOCK_SIZE;
Doug Zongker71fe5842014-06-26 15:35:36 -0700893
894 printf("loading: '%s'", fn);
895 fflush(stdout);
Dan Albertbac34742015-02-25 17:51:28 -0800896 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz));
Doug Zongker71fe5842014-06-26 15:35:36 -0700897 if (data == 0) {
898 printf("\n");
899 fprintf(stderr, "* cannot read '%s' *\n", fn);
900 return -1;
901 }
902
Elliott Hughes6452a892015-04-29 12:28:13 -0700903 std::string service =
904 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE);
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700905 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -0700906 int fd = adb_connect(service, &error);
Doug Zongker71fe5842014-06-26 15:35:36 -0700907 if (fd < 0) {
908 // Try falling back to the older sideload method. Maybe this
909 // is an older device that doesn't support sideload-host.
910 printf("\n");
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700911 status = adb_download_buffer("sideload", fn, data, sz, true);
Doug Zongker71fe5842014-06-26 15:35:36 -0700912 goto done;
913 }
914
Spencer Lowf055c192015-01-25 14:40:16 -0800915 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt));
Doug Zongker71fe5842014-06-26 15:35:36 -0700916
Elliott Hughesa7090b92015-04-17 17:03:59 -0700917 while (true) {
Elliott Hughes6452a892015-04-29 12:28:13 -0700918 char buf[9];
Dan Albertcc731cc2015-02-24 21:26:58 -0800919 if (!ReadFdExactly(fd, buf, 8)) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700920 fprintf(stderr, "* failed to read command: %s\n", strerror(errno));
Doug Zongker71fe5842014-06-26 15:35:36 -0700921 status = -1;
922 goto done;
923 }
Elliott Hughes6452a892015-04-29 12:28:13 -0700924 buf[8] = '\0';
Doug Zongker71fe5842014-06-26 15:35:36 -0700925
Elliott Hughes6452a892015-04-29 12:28:13 -0700926 if (strcmp("DONEDONE", buf) == 0) {
Doug Zongker71fe5842014-06-26 15:35:36 -0700927 status = 0;
928 break;
929 }
930
Doug Zongker71fe5842014-06-26 15:35:36 -0700931 int block = strtol(buf, NULL, 10);
932
933 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE;
934 if (offset >= sz) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700935 fprintf(stderr, "* attempt to read block %d past end\n", block);
Doug Zongker71fe5842014-06-26 15:35:36 -0700936 status = -1;
937 goto done;
938 }
939 uint8_t* start = data + offset;
940 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE;
941 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE;
942 if (offset_end > sz) {
943 to_write = sz - offset;
944 }
945
Dan Albertcc731cc2015-02-24 21:26:58 -0800946 if(!WriteFdExactly(fd, start, to_write)) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700947 adb_status(fd, &error);
948 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str());
Doug Zongker71fe5842014-06-26 15:35:36 -0700949 status = -1;
950 goto done;
951 }
952 xfer += to_write;
953
954 // For normal OTA packages, we expect to transfer every byte
955 // twice, plus a bit of overhead (one read during
956 // verification, one read of each byte for installation, plus
957 // extra access to things like the zip central directory).
958 // This estimate of the completion becomes 100% when we've
959 // transferred ~2.13 (=100/47) times the package size.
960 int percent = (int)(xfer * 47LL / (sz ? sz : 1));
961 if (percent != last_percent) {
962 printf("\rserving: '%s' (~%d%%) ", fn, percent);
963 fflush(stdout);
964 last_percent = percent;
965 }
966 }
967
Colin Cross6d6a8982014-07-07 14:12:41 -0700968 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, "");
Doug Zongker71fe5842014-06-26 15:35:36 -0700969
970 done:
971 if (fd >= 0) adb_close(fd);
972 free(data);
973 return status;
974}
975
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800976/**
977 * Run ppp in "notty" mode against a resource listed as the first parameter
978 * eg:
979 *
980 * ppp dev:/dev/omap_csmi_tty0 <ppp options>
981 *
982 */
Elliott Hughes58305772015-04-17 13:57:15 -0700983static int ppp(int argc, const char** argv) {
Yabin Cuie77b6a02014-11-11 09:24:11 -0800984#if defined(_WIN32)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800985 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]);
986 return -1;
987#else
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800988 if (argc < 2) {
989 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n",
990 argv[0]);
991
992 return 1;
993 }
994
Dan Albertbac34742015-02-25 17:51:28 -0800995 const char* adb_service_name = argv[1];
Elliott Hughes078f0fc2015-04-29 08:35:59 -0700996 std::string error;
997 int fd = adb_connect(adb_service_name, &error);
998 if (fd < 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800999 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n",
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001000 adb_service_name, error.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001001 return 1;
1002 }
1003
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001004 pid_t pid = fork();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001005
1006 if (pid < 0) {
1007 perror("from fork()");
1008 return 1;
1009 } else if (pid == 0) {
1010 int err;
1011 int i;
1012 const char **ppp_args;
1013
1014 // copy args
1015 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1);
1016 ppp_args[0] = "pppd";
1017 for (i = 2 ; i < argc ; i++) {
1018 //argv[2] and beyond become ppp_args[1] and beyond
1019 ppp_args[i - 1] = argv[i];
1020 }
1021 ppp_args[i-1] = NULL;
1022
1023 // child side
1024
1025 dup2(fd, STDIN_FILENO);
1026 dup2(fd, STDOUT_FILENO);
1027 adb_close(STDERR_FILENO);
1028 adb_close(fd);
1029
1030 err = execvp("pppd", (char * const *)ppp_args);
1031
1032 if (err < 0) {
1033 perror("execing pppd");
1034 }
1035 exit(-1);
1036 } else {
1037 // parent side
1038
1039 adb_close(fd);
1040 return 0;
1041 }
Yabin Cuie77b6a02014-11-11 09:24:11 -08001042#endif /* !defined(_WIN32) */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001043}
1044
Josh Gao3d8df3c2016-04-13 12:14:16 -07001045static bool wait_for_device(const char* service, TransportType t, const char* serial) {
1046 std::vector<std::string> components = android::base::Split(service, "-");
1047 if (components.size() < 3 || components.size() > 4) {
Leo Sartre1fbc9db2015-11-27 18:56:48 +01001048 fprintf(stderr, "adb: couldn't parse 'wait-for' command: %s\n", service);
1049 return false;
1050 }
1051
Elliott Hughes2b101112015-05-04 19:29:32 -07001052 // Was the caller vague about what they'd like us to wait for?
1053 // If so, check they weren't more specific in their choice of transport type.
Josh Gao3d8df3c2016-04-13 12:14:16 -07001054 if (components.size() == 3) {
1055 auto it = components.begin() + 2;
Elliott Hughes2b101112015-05-04 19:29:32 -07001056 if (t == kTransportUsb) {
Josh Gao3d8df3c2016-04-13 12:14:16 -07001057 components.insert(it, "usb");
Elliott Hughes2b101112015-05-04 19:29:32 -07001058 } else if (t == kTransportLocal) {
Josh Gao3d8df3c2016-04-13 12:14:16 -07001059 components.insert(it, "local");
Elliott Hughes2b101112015-05-04 19:29:32 -07001060 } else {
Josh Gao3d8df3c2016-04-13 12:14:16 -07001061 components.insert(it, "any");
Elliott Hughes2b101112015-05-04 19:29:32 -07001062 }
Josh Gao3d8df3c2016-04-13 12:14:16 -07001063 } else if (components[2] != "any" && components[2] != "local" && components[2] != "usb") {
1064 fprintf(stderr, "adb: unknown type %s; expected 'any', 'local', or 'usb'\n",
1065 components[2].c_str());
Leo Sartre1fbc9db2015-11-27 18:56:48 +01001066 return false;
1067 }
1068
Josh Gao5863fb62016-04-13 12:18:58 -07001069 if (components[3] != "any" && components[3] != "bootloader" && components[3] != "device" &&
1070 components[3] != "recovery" && components[3] != "sideload") {
Josh Gao3d8df3c2016-04-13 12:14:16 -07001071 fprintf(stderr,
1072 "adb: unknown state %s; "
Josh Gao5863fb62016-04-13 12:18:58 -07001073 "expected 'any', 'bootloader', 'device', 'recovery', or 'sideload'\n",
Josh Gao3d8df3c2016-04-13 12:14:16 -07001074 components[3].c_str());
1075 return false;
1076 }
1077
1078 std::string cmd = format_host_command(android::base::Join(components, "-").c_str(), t, serial);
Elliott Hughes424af022015-05-29 17:55:19 -07001079 return adb_command(cmd);
Elliott Hughes2b101112015-05-04 19:29:32 -07001080}
1081
Josh Gao06c73ae2016-03-04 15:16:18 -08001082static bool adb_root(const char* command) {
1083 std::string error;
1084 ScopedFd fd;
1085
1086 fd.Reset(adb_connect(android::base::StringPrintf("%s:", command), &error));
1087 if (!fd.valid()) {
1088 fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str());
1089 return false;
1090 }
1091
1092 // Figure out whether we actually did anything.
1093 char buf[256];
1094 char* cur = buf;
1095 ssize_t bytes_left = sizeof(buf);
1096 while (bytes_left > 0) {
1097 ssize_t bytes_read = adb_read(fd.fd(), cur, bytes_left);
1098 if (bytes_read == 0) {
1099 break;
1100 } else if (bytes_read < 0) {
1101 fprintf(stderr, "adb: error while reading for %s: %s\n", command, strerror(errno));
1102 return false;
1103 }
1104 cur += bytes_read;
1105 bytes_left -= bytes_read;
1106 }
1107
1108 if (bytes_left == 0) {
1109 fprintf(stderr, "adb: unexpected output length for %s\n", command);
1110 return false;
1111 }
1112
1113 fflush(stdout);
1114 WriteFdExactly(STDOUT_FILENO, buf, sizeof(buf) - bytes_left);
1115 if (cur != buf && strstr(buf, "restarting") == nullptr) {
1116 return true;
1117 }
1118
1119 // Give adbd 500ms to kill itself, then wait-for-device for it to come back up.
1120 adb_sleep_ms(500);
1121 TransportType type;
1122 const char* serial;
1123 adb_get_transport(&type, &serial);
Josh Gao9ea77952016-04-13 12:22:27 -07001124 return wait_for_device("wait-for-any", type, serial);
Josh Gao06c73ae2016-03-04 15:16:18 -08001125}
1126
Felipe Leme78e09632016-07-19 17:07:22 -07001127int send_shell_command(TransportType transport_type, const char* serial, const std::string& command,
Felipe Leme07ac8552016-07-26 12:14:39 -07001128 bool disable_shell_protocol, StandardStreamsCallbackInterface* callback) {
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001129 int fd;
David Pursell0aacbbe2016-01-21 19:56:50 -08001130 bool use_shell_protocol = false;
1131
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001132 while (true) {
David Pursell0aacbbe2016-01-21 19:56:50 -08001133 bool attempt_connection = true;
1134
Felipe Leme07ac8552016-07-26 12:14:39 -07001135 // Use shell protocol if it's supported and the caller doesn't explicitly
1136 // disable it.
David Pursell0aacbbe2016-01-21 19:56:50 -08001137 if (!disable_shell_protocol) {
1138 FeatureSet features;
Josh Gaof3f6a1d2016-01-31 19:12:26 -08001139 std::string error;
1140 if (adb_get_feature_set(&features, &error)) {
David Pursell0aacbbe2016-01-21 19:56:50 -08001141 use_shell_protocol = CanUseFeature(features, kFeatureShell2);
1142 } else {
1143 // Device was unreachable.
1144 attempt_connection = false;
1145 }
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001146 }
David Pursell0aacbbe2016-01-21 19:56:50 -08001147
1148 if (attempt_connection) {
1149 std::string error;
1150 std::string service_string = ShellServiceString(use_shell_protocol, "", command);
1151
1152 fd = adb_connect(service_string, &error);
1153 if (fd >= 0) {
1154 break;
1155 }
1156 }
1157
Felipe Leme07ac8552016-07-26 12:14:39 -07001158 fprintf(stderr, "- waiting for device -\n");
Josh Gaob6117c42016-02-24 15:16:17 -08001159 if (!wait_for_device("wait-for-device", transport_type, serial)) {
1160 return 1;
1161 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001162 }
1163
Felipe Leme07ac8552016-07-26 12:14:39 -07001164 int exit_code = read_and_dump(fd, use_shell_protocol, callback);
David Pursell71c83122015-09-14 15:33:50 -07001165
1166 if (adb_close(fd) < 0) {
1167 PLOG(ERROR) << "failure closing FD " << fd;
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001168 }
David Pursell71c83122015-09-14 15:33:50 -07001169
1170 return exit_code;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001171}
1172
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001173static int logcat(TransportType transport, const char* serial, int argc, const char** argv) {
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001174 char* log_tags = getenv("ANDROID_LOG_TAGS");
1175 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001176
David Pursell70ef7b42015-09-30 13:35:42 -07001177 std::string cmd = "export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001178
Jeff Sharkeyfd546e82014-06-10 11:31:24 -07001179 if (!strcmp(argv[0], "longcat")) {
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001180 cmd += " -v long";
Christopher Tatedb0a8802011-11-30 13:00:33 -08001181 }
1182
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001183 --argc;
1184 ++argv;
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001185 while (argc-- > 0) {
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001186 cmd += " " + escape_arg(*argv++);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001187 }
1188
David Pursell70ef7b42015-09-30 13:35:42 -07001189 // No need for shell protocol with logcat, always disable for simplicity.
1190 return send_shell_command(transport, serial, cmd, true);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001191}
1192
Christopher Tate2bcdda82016-07-06 13:22:22 -07001193static void write_zeros(int bytes, int fd) {
1194 int old_stdin_mode = -1;
1195 int old_stdout_mode = -1;
1196 char* buf = (char*) calloc(1, bytes);
1197 if (buf == nullptr) fatal("couldn't allocate buffer for write_zeros");
1198
1199 D("write_zeros(%d) -> %d", bytes, fd);
1200
1201 stdinout_raw_prologue(-1, fd, old_stdin_mode, old_stdout_mode);
1202
1203 if (fd == STDOUT_FILENO) {
1204 fwrite(buf, 1, bytes, stdout);
1205 fflush(stdout);
1206 } else {
1207 adb_write(fd, buf, bytes);
1208 }
1209
1210 stdinout_raw_prologue(-1, fd, old_stdin_mode, old_stdout_mode);
1211
1212 D("write_zeros() finished");
1213 free(buf);
1214}
1215
Dan Albertbac34742015-02-25 17:51:28 -08001216static int backup(int argc, const char** argv) {
Elliott Hughes24f165f2015-08-21 20:31:31 -07001217 const char* filename = "backup.ab";
Christopher Tated2f54152011-04-21 12:53:28 -07001218
Christopher Tatec9cd3b92011-06-01 17:56:23 -07001219 /* find, extract, and use any -f argument */
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001220 for (int i = 1; i < argc; i++) {
Christopher Tatec9cd3b92011-06-01 17:56:23 -07001221 if (!strcmp("-f", argv[i])) {
1222 if (i == argc-1) {
Elliott Hughes56e68132015-11-13 11:04:10 -08001223 fprintf(stderr, "adb: backup -f passed with no filename.\n");
1224 return EXIT_FAILURE;
Christopher Tatec9cd3b92011-06-01 17:56:23 -07001225 }
1226 filename = argv[i+1];
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001227 for (int j = i+2; j <= argc; ) {
Christopher Tatec9cd3b92011-06-01 17:56:23 -07001228 argv[i++] = argv[j++];
1229 }
1230 argc -= 2;
1231 argv[argc] = NULL;
1232 }
Christopher Tated2f54152011-04-21 12:53:28 -07001233 }
1234
Elliott Hughes56e68132015-11-13 11:04:10 -08001235 // Bare "adb backup" or "adb backup -f filename" are not valid invocations ---
1236 // a list of packages is required.
1237 if (argc < 2) {
1238 fprintf(stderr, "adb: backup either needs a list of packages or -all/-shared.\n");
1239 return EXIT_FAILURE;
1240 }
Christopher Tatebb86bc52011-08-22 17:12:08 -07001241
Christopher Tateb1dfffe2011-12-08 19:04:34 -08001242 adb_unlink(filename);
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001243 int outFd = adb_creat(filename, 0640);
Christopher Tated2f54152011-04-21 12:53:28 -07001244 if (outFd < 0) {
Elliott Hughes56e68132015-11-13 11:04:10 -08001245 fprintf(stderr, "adb: backup unable to create file '%s': %s\n", filename, strerror(errno));
1246 return EXIT_FAILURE;
Christopher Tated2f54152011-04-21 12:53:28 -07001247 }
1248
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001249 std::string cmd = "backup:";
1250 --argc;
1251 ++argv;
1252 while (argc-- > 0) {
1253 cmd += " " + escape_arg(*argv++);
Christopher Tated2f54152011-04-21 12:53:28 -07001254 }
1255
Yabin Cui7a3f8d62015-09-02 17:44:28 -07001256 D("backup. filename=%s cmd=%s", filename, cmd.c_str());
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001257 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -07001258 int fd = adb_connect(cmd, &error);
Christopher Tated2f54152011-04-21 12:53:28 -07001259 if (fd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001260 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str());
Christopher Tated2f54152011-04-21 12:53:28 -07001261 adb_close(outFd);
Elliott Hughes56e68132015-11-13 11:04:10 -08001262 return EXIT_FAILURE;
Christopher Tated2f54152011-04-21 12:53:28 -07001263 }
1264
Elliott Hughes56e68132015-11-13 11:04:10 -08001265 printf("Now unlock your device and confirm the backup operation...\n");
1266 fflush(stdout);
1267
Christopher Tated2f54152011-04-21 12:53:28 -07001268 copy_to_file(fd, outFd);
1269
1270 adb_close(fd);
1271 adb_close(outFd);
Elliott Hughes56e68132015-11-13 11:04:10 -08001272 return EXIT_SUCCESS;
Christopher Tated2f54152011-04-21 12:53:28 -07001273}
1274
Dan Albertbac34742015-02-25 17:51:28 -08001275static int restore(int argc, const char** argv) {
Christopher Tate702967a2011-05-17 15:52:54 -07001276 if (argc != 2) return usage();
1277
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001278 const char* filename = argv[1];
1279 int tarFd = adb_open(filename, O_RDONLY);
Christopher Tate702967a2011-05-17 15:52:54 -07001280 if (tarFd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001281 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno));
Christopher Tate702967a2011-05-17 15:52:54 -07001282 return -1;
1283 }
1284
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001285 std::string error;
1286 int fd = adb_connect("restore:", &error);
Christopher Tate702967a2011-05-17 15:52:54 -07001287 if (fd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001288 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str());
Christopher Tate702967a2011-05-17 15:52:54 -07001289 adb_close(tarFd);
1290 return -1;
1291 }
1292
Christopher Tatebffa4ca2012-01-06 15:43:03 -08001293 printf("Now unlock your device and confirm the restore operation.\n");
Christopher Tate702967a2011-05-17 15:52:54 -07001294 copy_to_file(tarFd, fd);
1295
Christopher Tate2bcdda82016-07-06 13:22:22 -07001296 // Provide an in-band EOD marker in case the archive file is malformed
1297 write_zeros(512*2, fd);
1298
Josh Gao5767d0d2016-03-04 15:51:03 -08001299 // Wait until the other side finishes, or it'll get sent SIGHUP.
1300 copy_to_file(fd, STDOUT_FILENO);
1301
Christopher Tate702967a2011-05-17 15:52:54 -07001302 adb_close(fd);
1303 adb_close(tarFd);
1304 return 0;
1305}
1306
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001307/* <hint> may be:
1308 * - A simple product name
1309 * e.g., "sooner"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001310 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir
1311 * e.g., "out/target/product/sooner"
1312 * - An absolute path to the PRODUCT_OUT dir
1313 * e.g., "/src/device/out/target/product/sooner"
1314 *
1315 * Given <hint>, try to construct an absolute path to the
1316 * ANDROID_PRODUCT_OUT dir.
1317 */
Elliott Hughes5c742702015-07-30 17:42:01 -07001318static std::string find_product_out_path(const std::string& hint) {
1319 if (hint.empty()) {
Elliott Hughes58305772015-04-17 13:57:15 -07001320 return "";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001321 }
1322
Elliott Hughes58305772015-04-17 13:57:15 -07001323 // If it's already absolute, don't bother doing any work.
Elliott Hughes5c742702015-07-30 17:42:01 -07001324 if (adb_is_absolute_host_path(hint.c_str())) {
Elliott Hughes58305772015-04-17 13:57:15 -07001325 return hint;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001326 }
1327
Elliott Hughes58305772015-04-17 13:57:15 -07001328 // If there are any slashes in it, assume it's a relative path;
1329 // make it absolute.
Elliott Hughes5c742702015-07-30 17:42:01 -07001330 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) {
Elliott Hughesa7090b92015-04-17 17:03:59 -07001331 std::string cwd;
1332 if (!getcwd(&cwd)) {
Felipe Leme307951e2016-07-29 17:57:00 -07001333 perror("adb: getcwd failed");
Elliott Hughes58305772015-04-17 13:57:15 -07001334 return "";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001335 }
Elliott Hughes5c742702015-07-30 17:42:01 -07001336 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001337 }
1338
Elliott Hughes58305772015-04-17 13:57:15 -07001339 // It's a string without any slashes. Try to do something with it.
1340 //
1341 // Try to find the root of the build tree, and build a PRODUCT_OUT
1342 // path from there.
Elliott Hughesa7090b92015-04-17 17:03:59 -07001343 char* top = getenv("ANDROID_BUILD_TOP");
Elliott Hughes58305772015-04-17 13:57:15 -07001344 if (top == nullptr) {
Elliott Hughesa7090b92015-04-17 17:03:59 -07001345 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n");
Elliott Hughes58305772015-04-17 13:57:15 -07001346 return "";
1347 }
Elliott Hughesa7090b92015-04-17 17:03:59 -07001348
1349 std::string path = top;
Elliott Hughes58305772015-04-17 13:57:15 -07001350 path += OS_PATH_SEPARATOR_STR;
1351 path += "out";
1352 path += OS_PATH_SEPARATOR_STR;
1353 path += "target";
1354 path += OS_PATH_SEPARATOR_STR;
1355 path += "product";
1356 path += OS_PATH_SEPARATOR_STR;
1357 path += hint;
1358 if (!directory_exists(path)) {
1359 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; "
Elliott Hughes5c742702015-07-30 17:42:01 -07001360 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str());
Elliott Hughesa7090b92015-04-17 17:03:59 -07001361 return "";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001362 }
Elliott Hughes58305772015-04-17 13:57:15 -07001363 return path;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001364}
1365
Josh Gao05786772015-10-30 16:57:19 -07001366static void parse_push_pull_args(const char** arg, int narg,
1367 std::vector<const char*>* srcs,
1368 const char** dst, bool* copy_attrs) {
1369 *copy_attrs = false;
Mark Lindner76f2a932014-03-11 17:55:59 -07001370
Josh Gao05786772015-10-30 16:57:19 -07001371 srcs->clear();
1372 bool ignore_flags = false;
Lajos Molnarde8ff4a2013-04-19 12:41:09 -07001373 while (narg > 0) {
Josh Gao05786772015-10-30 16:57:19 -07001374 if (ignore_flags || *arg[0] != '-') {
1375 srcs->push_back(*arg);
Lajos Molnarde8ff4a2013-04-19 12:41:09 -07001376 } else {
Josh Gao05786772015-10-30 16:57:19 -07001377 if (!strcmp(*arg, "-p")) {
1378 // Silently ignore for backwards compatibility.
1379 } else if (!strcmp(*arg, "-a")) {
1380 *copy_attrs = true;
1381 } else if (!strcmp(*arg, "--")) {
1382 ignore_flags = true;
1383 } else {
1384 fprintf(stderr, "adb: unrecognized option '%s'\n", *arg);
1385 exit(1);
1386 }
Lajos Molnarde8ff4a2013-04-19 12:41:09 -07001387 }
Mark Lindner76f2a932014-03-11 17:55:59 -07001388 ++arg;
1389 --narg;
1390 }
1391
Josh Gao05786772015-10-30 16:57:19 -07001392 if (srcs->size() > 1) {
1393 *dst = srcs->back();
1394 srcs->pop_back();
Mark Lindner76f2a932014-03-11 17:55:59 -07001395 }
1396}
1397
Elliott Hughes6452a892015-04-29 12:28:13 -07001398static int adb_connect_command(const std::string& command) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001399 std::string error;
1400 int fd = adb_connect(command, &error);
Elliott Hughes5677c232015-05-07 23:37:40 -07001401 if (fd < 0) {
1402 fprintf(stderr, "error: %s\n", error.c_str());
1403 return 1;
Tao Bao175b7bb2015-03-29 11:22:34 -07001404 }
Elliott Hughes5677c232015-05-07 23:37:40 -07001405 read_and_dump(fd);
1406 adb_close(fd);
1407 return 0;
Tao Bao175b7bb2015-03-29 11:22:34 -07001408}
1409
Elliott Hughes6452a892015-04-29 12:28:13 -07001410static int adb_query_command(const std::string& command) {
1411 std::string result;
1412 std::string error;
1413 if (!adb_query(command, &result, &error)) {
1414 fprintf(stderr, "error: %s\n", error.c_str());
1415 return 1;
1416 }
1417 printf("%s\n", result.c_str());
1418 return 0;
1419}
1420
Spencer Lowa13df302015-09-07 16:20:13 -07001421// Disallow stdin, stdout, and stderr.
1422static bool _is_valid_ack_reply_fd(const int ack_reply_fd) {
1423#ifdef _WIN32
1424 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd);
1425 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) &&
1426 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) &&
1427 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle);
1428#else
1429 return ack_reply_fd > 2;
1430#endif
1431}
1432
Elliott Hughesab52c182015-05-01 17:04:38 -07001433int adb_commandline(int argc, const char **argv) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001434 int no_daemon = 0;
1435 int is_daemon = 0;
David 'Digit' Turner305b4b02011-01-31 14:23:56 +01001436 int is_server = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001437 int r;
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001438 TransportType transport_type = kTransportAny;
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001439 int ack_reply_fd = -1;
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001440
Elliott Hughes65433da2015-11-18 18:07:48 -08001441#if !defined(_WIN32)
1442 // We'd rather have EPIPE than SIGPIPE.
1443 signal(SIGPIPE, SIG_IGN);
1444#endif
1445
Elliott Hughes58305772015-04-17 13:57:15 -07001446 // If defined, this should be an absolute path to
1447 // the directory containing all of the various system images
1448 // for a particular product. If not defined, and the adb
1449 // command requires this information, then the user must
1450 // specify the path using "-p".
1451 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT");
1452 if (ANDROID_PRODUCT_OUT != nullptr) {
1453 gProductOutPath = ANDROID_PRODUCT_OUT;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001454 }
1455 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint
1456
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001457 /* Validate and assign the server port */
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001458 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT");
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001459 int server_port = DEFAULT_ADB_PORT;
1460 if (server_port_str && strlen(server_port_str) > 0) {
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001461 server_port = strtol(server_port_str, nullptr, 0);
Matt Gumbeld7b33082012-11-14 10:16:17 -08001462 if (server_port <= 0 || server_port > 65535) {
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001463 fprintf(stderr,
Spencer Lowf18fc082015-08-11 17:05:02 -07001464 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n",
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001465 server_port_str);
1466 return usage();
1467 }
1468 }
1469
Elliott Hughes8d28e192015-10-07 14:55:10 -07001470 // We need to check for -d and -e before we look at $ANDROID_SERIAL.
1471 const char* serial = nullptr;
1472
Riley Andrews98f58e82014-12-05 17:37:24 -08001473 while (argc > 0) {
1474 if (!strcmp(argv[0],"server")) {
David 'Digit' Turner305b4b02011-01-31 14:23:56 +01001475 is_server = 1;
Riley Andrews98f58e82014-12-05 17:37:24 -08001476 } else if (!strcmp(argv[0],"nodaemon")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001477 no_daemon = 1;
1478 } else if (!strcmp(argv[0], "fork-server")) {
1479 /* this is a special flag used only when the ADB client launches the ADB Server */
1480 is_daemon = 1;
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001481 } else if (!strcmp(argv[0], "--reply-fd")) {
1482 if (argc < 2) return usage();
1483 const char* reply_fd_str = argv[1];
1484 argc--;
1485 argv++;
1486 ack_reply_fd = strtol(reply_fd_str, nullptr, 10);
Spencer Lowa13df302015-09-07 16:20:13 -07001487 if (!_is_valid_ack_reply_fd(ack_reply_fd)) {
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001488 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str);
1489 return usage();
1490 }
Riley Andrews98f58e82014-12-05 17:37:24 -08001491 } else if (!strncmp(argv[0], "-p", 2)) {
Elliott Hughes048b27c2015-07-31 13:18:22 -07001492 const char* product = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001493 if (argv[0][2] == '\0') {
1494 if (argc < 2) return usage();
1495 product = argv[1];
1496 argc--;
1497 argv++;
1498 } else {
Vairavan Srinivasan81273232012-08-04 16:40:50 -07001499 product = argv[0] + 2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001500 }
Elliott Hughes048b27c2015-07-31 13:18:22 -07001501 gProductOutPath = find_product_out_path(product);
Elliott Hughes58305772015-04-17 13:57:15 -07001502 if (gProductOutPath.empty()) {
1503 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001504 return usage();
1505 }
1506 } else if (argv[0][0]=='-' && argv[0][1]=='s') {
1507 if (isdigit(argv[0][2])) {
1508 serial = argv[0] + 2;
1509 } else {
Riley Andrews98f58e82014-12-05 17:37:24 -08001510 if (argc < 2 || argv[0][2] != '\0') return usage();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001511 serial = argv[1];
1512 argc--;
1513 argv++;
1514 }
1515 } else if (!strcmp(argv[0],"-d")) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001516 transport_type = kTransportUsb;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001517 } else if (!strcmp(argv[0],"-e")) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001518 transport_type = kTransportLocal;
Matt Gumbeld7b33082012-11-14 10:16:17 -08001519 } else if (!strcmp(argv[0],"-a")) {
1520 gListenAll = 1;
Riley Andrews98f58e82014-12-05 17:37:24 -08001521 } else if (!strncmp(argv[0], "-H", 2)) {
Matt Gumbeld7b33082012-11-14 10:16:17 -08001522 const char *hostname = NULL;
1523 if (argv[0][2] == '\0') {
1524 if (argc < 2) return usage();
1525 hostname = argv[1];
1526 argc--;
1527 argv++;
1528 } else {
1529 hostname = argv[0] + 2;
1530 }
1531 adb_set_tcp_name(hostname);
1532
Riley Andrews98f58e82014-12-05 17:37:24 -08001533 } else if (!strncmp(argv[0], "-P", 2)) {
Matt Gumbeld7b33082012-11-14 10:16:17 -08001534 if (argv[0][2] == '\0') {
1535 if (argc < 2) return usage();
1536 server_port_str = argv[1];
1537 argc--;
1538 argv++;
1539 } else {
1540 server_port_str = argv[0] + 2;
1541 }
1542 if (strlen(server_port_str) > 0) {
1543 server_port = (int) strtol(server_port_str, NULL, 0);
1544 if (server_port <= 0 || server_port > 65535) {
1545 fprintf(stderr,
1546 "adb: port number must be a positive number less than 65536. Got \"%s\"\n",
1547 server_port_str);
1548 return usage();
1549 }
1550 } else {
1551 fprintf(stderr,
1552 "adb: port number must be a positive number less than 65536. Got empty string.\n");
1553 return usage();
1554 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001555 } else {
1556 /* out of recognized modifiers and flags */
1557 break;
1558 }
1559 argc--;
1560 argv++;
1561 }
1562
Elliott Hughes8d28e192015-10-07 14:55:10 -07001563 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL.
1564 if (transport_type == kTransportAny && serial == nullptr) {
1565 serial = getenv("ANDROID_SERIAL");
1566 }
1567
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001568 adb_set_transport(transport_type, serial);
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001569 adb_set_tcp_specifics(server_port);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001570
David 'Digit' Turner305b4b02011-01-31 14:23:56 +01001571 if (is_server) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001572 if (no_daemon || is_daemon) {
Spencer Low5c398d22015-08-08 15:07:07 -07001573 if (is_daemon && (ack_reply_fd == -1)) {
Siva Velusamy9f2d1a92015-08-07 10:10:29 -07001574 fprintf(stderr, "reply fd for adb server to client communication not specified.\n");
1575 return usage();
1576 }
Elliott Hughes65433da2015-11-18 18:07:48 -08001577 r = adb_server_main(is_daemon, server_port, ack_reply_fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001578 } else {
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001579 r = launch_server(server_port);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001580 }
Riley Andrews98f58e82014-12-05 17:37:24 -08001581 if (r) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001582 fprintf(stderr,"* could not start server *\n");
1583 }
1584 return r;
1585 }
1586
Riley Andrews98f58e82014-12-05 17:37:24 -08001587 if (argc == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001588 return usage();
1589 }
1590
Riley Andrewsc8514c82014-12-05 17:32:46 -08001591 /* handle wait-for-* prefix */
1592 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {
Dan Albertbac34742015-02-25 17:51:28 -08001593 const char* service = argv[0];
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001594
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001595 if (!wait_for_device(service, transport_type, serial)) {
Riley Andrewsc8514c82014-12-05 17:32:46 -08001596 return 1;
1597 }
1598
Elliott Hughes2b101112015-05-04 19:29:32 -07001599 // Allow a command to be run after wait-for-device,
1600 // e.g. 'adb wait-for-device shell'.
Riley Andrewsc8514c82014-12-05 17:32:46 -08001601 if (argc == 1) {
1602 return 0;
1603 }
1604
1605 /* Fall through */
1606 argc--;
1607 argv++;
1608 }
1609
1610 /* adb_connect() commands */
Riley Andrews98f58e82014-12-05 17:37:24 -08001611 if (!strcmp(argv[0], "devices")) {
Dan Albertbac34742015-02-25 17:51:28 -08001612 const char *listopt;
Elliott Hughes6452a892015-04-29 12:28:13 -07001613 if (argc < 2) {
Scott Andersone109d262012-04-20 11:21:14 -07001614 listopt = "";
Elliott Hughes6452a892015-04-29 12:28:13 -07001615 } else if (argc == 2 && !strcmp(argv[1], "-l")) {
Scott Andersone109d262012-04-20 11:21:14 -07001616 listopt = argv[1];
Elliott Hughes6452a892015-04-29 12:28:13 -07001617 } else {
Scott Andersone109d262012-04-20 11:21:14 -07001618 fprintf(stderr, "Usage: adb devices [-l]\n");
1619 return 1;
1620 }
Elliott Hughes6452a892015-04-29 12:28:13 -07001621
1622 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt);
1623 printf("List of devices attached\n");
1624 return adb_query_command(query);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001625 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001626 else if (!strcmp(argv[0], "connect")) {
Mike Lockwoodff196702009-08-24 15:58:40 -07001627 if (argc != 2) {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001628 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n");
Mike Lockwoodff196702009-08-24 15:58:40 -07001629 return 1;
1630 }
Elliott Hughes6452a892015-04-29 12:28:13 -07001631
1632 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]);
1633 return adb_query_command(query);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001634 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001635 else if (!strcmp(argv[0], "disconnect")) {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001636 if (argc > 2) {
1637 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n");
1638 return 1;
1639 }
Elliott Hughes6452a892015-04-29 12:28:13 -07001640
1641 std::string query = android::base::StringPrintf("host:disconnect:%s",
1642 (argc == 2) ? argv[1] : "");
1643 return adb_query_command(query);
Mike Lockwoodff196702009-08-24 15:58:40 -07001644 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001645 else if (!strcmp(argv[0], "emu")) {
Spencer Low142ec752015-05-06 16:13:42 -07001646 return adb_send_emulator_command(argc, argv, serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001647 }
Elliott Hughesc15b17f2015-11-03 11:18:40 -08001648 else if (!strcmp(argv[0], "shell")) {
Josh Gaof3f6a1d2016-01-31 19:12:26 -08001649 return adb_shell(argc, argv);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001650 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001651 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001652 int exec_in = !strcmp(argv[0], "exec-in");
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001653
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001654 std::string cmd = "exec:";
1655 cmd += argv[1];
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001656 argc -= 2;
1657 argv += 2;
1658 while (argc-- > 0) {
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001659 cmd += " " + escape_arg(*argv++);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001660 }
1661
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001662 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -07001663 int fd = adb_connect(cmd, &error);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001664 if (fd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001665 fprintf(stderr, "error: %s\n", error.c_str());
Jeff Sharkey5d9d4342014-05-26 18:30:43 -07001666 return -1;
1667 }
1668
1669 if (exec_in) {
1670 copy_to_file(STDIN_FILENO, fd);
1671 } else {
1672 copy_to_file(fd, STDOUT_FILENO);
1673 }
1674
1675 adb_close(fd);
1676 return 0;
1677 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001678 else if (!strcmp(argv[0], "kill-server")) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001679 std::string error;
1680 int fd = _adb_connect("host:kill", &error);
Spencer Lowf18fc082015-08-11 17:05:02 -07001681 if (fd == -2) {
1682 // Failed to make network connection to server. Don't output the
1683 // network error since that is expected.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001684 fprintf(stderr,"* server not running *\n");
Spencer Lowf18fc082015-08-11 17:05:02 -07001685 // Successful exit code because the server is already "killed".
1686 return 0;
1687 } else if (fd == -1) {
1688 // Some other error.
1689 fprintf(stderr, "error: %s\n", error.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001690 return 1;
Spencer Lowf18fc082015-08-11 17:05:02 -07001691 } else {
1692 // Successfully connected, kill command sent, okay status came back.
1693 // Server should exit() in a moment, if not already.
Spencer Low351ecd12015-10-14 17:32:44 -07001694 ReadOrderlyShutdown(fd);
Spencer Lowf18fc082015-08-11 17:05:02 -07001695 adb_close(fd);
1696 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001697 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001698 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001699 else if (!strcmp(argv[0], "sideload")) {
1700 if (argc != 2) return usage();
Doug Zongker71fe5842014-06-26 15:35:36 -07001701 if (adb_sideload_host(argv[1])) {
Doug Zongker447f0612012-01-09 14:54:53 -08001702 return 1;
1703 } else {
1704 return 0;
1705 }
1706 }
Elliott Hughes19d80b82015-07-21 16:13:40 -07001707 else if (!strcmp(argv[0], "tcpip") && argc > 1) {
1708 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1]));
1709 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001710 else if (!strcmp(argv[0], "remount") ||
1711 !strcmp(argv[0], "reboot") ||
1712 !strcmp(argv[0], "reboot-bootloader") ||
Riley Andrewsc8514c82014-12-05 17:32:46 -08001713 !strcmp(argv[0], "usb") ||
Riley Andrewsc8514c82014-12-05 17:32:46 -08001714 !strcmp(argv[0], "disable-verity") ||
1715 !strcmp(argv[0], "enable-verity")) {
Elliott Hughes5677c232015-05-07 23:37:40 -07001716 std::string command;
Tao Bao175b7bb2015-03-29 11:22:34 -07001717 if (!strcmp(argv[0], "reboot-bootloader")) {
Elliott Hughes5677c232015-05-07 23:37:40 -07001718 command = "reboot:bootloader";
Tao Bao175b7bb2015-03-29 11:22:34 -07001719 } else if (argc > 1) {
Elliott Hughes5677c232015-05-07 23:37:40 -07001720 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]);
Tao Bao175b7bb2015-03-29 11:22:34 -07001721 } else {
Elliott Hughes5677c232015-05-07 23:37:40 -07001722 command = android::base::StringPrintf("%s:", argv[0]);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -07001723 }
Tao Bao175b7bb2015-03-29 11:22:34 -07001724 return adb_connect_command(command);
Josh Gao06c73ae2016-03-04 15:16:18 -08001725 } else if (!strcmp(argv[0], "root") || !strcmp(argv[0], "unroot")) {
1726 return adb_root(argv[0]) ? 0 : 1;
1727 } else if (!strcmp(argv[0], "bugreport")) {
Felipe Leme78e09632016-07-19 17:07:22 -07001728 Bugreport bugreport;
1729 return bugreport.DoIt(transport_type, serial, argc, argv);
Felipe Leme44a42672016-04-01 17:43:27 -07001730 } else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) {
Elliott Hughes424af022015-05-29 17:55:19 -07001731 bool reverse = !strcmp(argv[0], "reverse");
1732 ++argv;
1733 --argc;
1734 if (argc < 1) return usage();
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001735
1736 // Determine the <host-prefix> for this command.
Elliott Hughes424af022015-05-29 17:55:19 -07001737 std::string host_prefix;
David 'Digit' Turner25258692013-03-21 21:07:42 +01001738 if (reverse) {
Elliott Hughes424af022015-05-29 17:55:19 -07001739 host_prefix = "reverse";
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001740 } else {
David 'Digit' Turner25258692013-03-21 21:07:42 +01001741 if (serial) {
Elliott Hughes424af022015-05-29 17:55:19 -07001742 host_prefix = android::base::StringPrintf("host-serial:%s", serial);
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001743 } else if (transport_type == kTransportUsb) {
Elliott Hughes424af022015-05-29 17:55:19 -07001744 host_prefix = "host-usb";
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001745 } else if (transport_type == kTransportLocal) {
Elliott Hughes424af022015-05-29 17:55:19 -07001746 host_prefix = "host-local";
David 'Digit' Turner25258692013-03-21 21:07:42 +01001747 } else {
Elliott Hughes424af022015-05-29 17:55:19 -07001748 host_prefix = "host";
David 'Digit' Turner25258692013-03-21 21:07:42 +01001749 }
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001750 }
1751
Elliott Hughes424af022015-05-29 17:55:19 -07001752 std::string cmd;
1753 if (strcmp(argv[0], "--list") == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -07001754 if (argc != 1) return usage();
Elliott Hughes424af022015-05-29 17:55:19 -07001755 return adb_query_command(host_prefix + ":list-forward");
1756 } else if (strcmp(argv[0], "--remove-all") == 0) {
1757 if (argc != 1) return usage();
1758 cmd = host_prefix + ":killforward-all";
1759 } else if (strcmp(argv[0], "--remove") == 0) {
1760 // forward --remove <local>
Elliott Hughesab52c182015-05-01 17:04:38 -07001761 if (argc != 2) return usage();
Elliott Hughes424af022015-05-29 17:55:19 -07001762 cmd = host_prefix + ":killforward:" + argv[1];
1763 } else if (strcmp(argv[0], "--no-rebind") == 0) {
1764 // forward --no-rebind <local> <remote>
Elliott Hughesab52c182015-05-01 17:04:38 -07001765 if (argc != 3) return usage();
Elliott Hughes424af022015-05-29 17:55:19 -07001766 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2];
1767 } else {
1768 // forward <local> <remote>
1769 if (argc != 2) return usage();
1770 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1];
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001771 }
1772
Elliott Hughes424af022015-05-29 17:55:19 -07001773 return adb_command(cmd) ? 0 : 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001774 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001775 /* do_sync_*() commands */
Riley Andrewsc8514c82014-12-05 17:32:46 -08001776 else if (!strcmp(argv[0], "ls")) {
1777 if (argc != 2) return usage();
Elliott Hughesaa245492015-08-03 10:38:08 -07001778 return do_sync_ls(argv[1]) ? 0 : 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001779 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001780 else if (!strcmp(argv[0], "push")) {
Josh Gao05786772015-10-30 16:57:19 -07001781 bool copy_attrs = false;
1782 std::vector<const char*> srcs;
1783 const char* dst = nullptr;
Mark Lindner76f2a932014-03-11 17:55:59 -07001784
Josh Gao05786772015-10-30 16:57:19 -07001785 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs);
1786 if (srcs.empty() || !dst) return usage();
1787 return do_sync_push(srcs, dst) ? 0 : 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001788 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001789 else if (!strcmp(argv[0], "pull")) {
Josh Gao05786772015-10-30 16:57:19 -07001790 bool copy_attrs = false;
1791 std::vector<const char*> srcs;
1792 const char* dst = ".";
Mark Lindner76f2a932014-03-11 17:55:59 -07001793
Josh Gao05786772015-10-30 16:57:19 -07001794 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, &copy_attrs);
1795 if (srcs.empty()) return usage();
1796 return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001797 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001798 else if (!strcmp(argv[0], "install")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001799 if (argc < 2) return usage();
David Pursell0aacbbe2016-01-21 19:56:50 -08001800 FeatureSet features;
Josh Gaof3f6a1d2016-01-31 19:12:26 -08001801 std::string error;
1802 if (!adb_get_feature_set(&features, &error)) {
1803 fprintf(stderr, "error: %s\n", error.c_str());
David Pursell0aacbbe2016-01-21 19:56:50 -08001804 return 1;
1805 }
1806
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001807 if (CanUseFeature(features, kFeatureCmd)) {
1808 return install_app(transport_type, serial, argc, argv);
1809 }
1810 return install_app_legacy(transport_type, serial, argc, argv);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001811 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001812 else if (!strcmp(argv[0], "install-multiple")) {
Jeff Sharkey960df972014-06-09 17:30:57 -07001813 if (argc < 2) return usage();
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001814 return install_multiple_app(transport_type, serial, argc, argv);
Jeff Sharkey960df972014-06-09 17:30:57 -07001815 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001816 else if (!strcmp(argv[0], "uninstall")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001817 if (argc < 2) return usage();
David Pursell0aacbbe2016-01-21 19:56:50 -08001818 FeatureSet features;
Josh Gaof3f6a1d2016-01-31 19:12:26 -08001819 std::string error;
1820 if (!adb_get_feature_set(&features, &error)) {
1821 fprintf(stderr, "error: %s\n", error.c_str());
David Pursell0aacbbe2016-01-21 19:56:50 -08001822 return 1;
1823 }
1824
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001825 if (CanUseFeature(features, kFeatureCmd)) {
1826 return uninstall_app(transport_type, serial, argc, argv);
1827 }
1828 return uninstall_app_legacy(transport_type, serial, argc, argv);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001829 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001830 else if (!strcmp(argv[0], "sync")) {
Elliott Hughesd236d072015-04-21 10:17:07 -07001831 std::string src;
Elliott Hughes58305772015-04-17 13:57:15 -07001832 bool list_only = false;
Riley Andrews98f58e82014-12-05 17:37:24 -08001833 if (argc < 2) {
Elliott Hughes58305772015-04-17 13:57:15 -07001834 // No local path was specified.
Elliott Hughesd236d072015-04-21 10:17:07 -07001835 src = "";
Anthony Newnam705c9442010-02-22 08:36:49 -06001836 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
Elliott Hughesd236d072015-04-21 10:17:07 -07001837 list_only = true;
Anthony Newnam705c9442010-02-22 08:36:49 -06001838 if (argc == 3) {
Elliott Hughesd236d072015-04-21 10:17:07 -07001839 src = argv[2];
Anthony Newnam705c9442010-02-22 08:36:49 -06001840 } else {
Elliott Hughesd236d072015-04-21 10:17:07 -07001841 src = "";
Anthony Newnam705c9442010-02-22 08:36:49 -06001842 }
Riley Andrews98f58e82014-12-05 17:37:24 -08001843 } else if (argc == 2) {
Elliott Hughes58305772015-04-17 13:57:15 -07001844 // A local path or "android"/"data" arg was specified.
Elliott Hughesd236d072015-04-21 10:17:07 -07001845 src = argv[1];
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001846 } else {
1847 return usage();
1848 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001849
Elliott Hughesd236d072015-04-21 10:17:07 -07001850 if (src != "" &&
1851 src != "system" && src != "data" && src != "vendor" && src != "oem") {
Elliott Hughes58305772015-04-17 13:57:15 -07001852 return usage();
1853 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001854
Elliott Hughes58305772015-04-17 13:57:15 -07001855 std::string system_src_path = product_file("system");
1856 std::string data_src_path = product_file("data");
1857 std::string vendor_src_path = product_file("vendor");
1858 std::string oem_src_path = product_file("oem");
Elliott Hughes58305772015-04-17 13:57:15 -07001859
Elliott Hughesaa245492015-08-03 10:38:08 -07001860 bool okay = true;
1861 if (okay && (src.empty() || src == "system")) {
1862 okay = do_sync_sync(system_src_path, "/system", list_only);
Elliott Hughes58305772015-04-17 13:57:15 -07001863 }
Elliott Hughesaa245492015-08-03 10:38:08 -07001864 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) {
1865 okay = do_sync_sync(vendor_src_path, "/vendor", list_only);
Elliott Hughes58305772015-04-17 13:57:15 -07001866 }
Elliott Hughesaa245492015-08-03 10:38:08 -07001867 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) {
1868 okay = do_sync_sync(oem_src_path, "/oem", list_only);
Elliott Hughes58305772015-04-17 13:57:15 -07001869 }
Elliott Hughesaa245492015-08-03 10:38:08 -07001870 if (okay && (src.empty() || src == "data")) {
1871 okay = do_sync_sync(data_src_path, "/data", list_only);
Elliott Hughes58305772015-04-17 13:57:15 -07001872 }
Elliott Hughesaa245492015-08-03 10:38:08 -07001873 return okay ? 0 : 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001874 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001875 /* passthrough commands */
Riley Andrewsc8514c82014-12-05 17:32:46 -08001876 else if (!strcmp(argv[0],"get-state") ||
Scott Andersone109d262012-04-20 11:21:14 -07001877 !strcmp(argv[0],"get-serialno") ||
1878 !strcmp(argv[0],"get-devpath"))
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001879 {
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001880 return adb_query_command(format_host_command(argv[0], transport_type, serial));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001881 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001882 /* other commands */
Riley Andrewsc8514c82014-12-05 17:32:46 -08001883 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001884 return logcat(transport_type, serial, argc, argv);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001885 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001886 else if (!strcmp(argv[0],"ppp")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001887 return ppp(argc, argv);
1888 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001889 else if (!strcmp(argv[0], "start-server")) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07001890 std::string error;
Spencer Lowf18fc082015-08-11 17:05:02 -07001891 const int result = adb_connect("host:start-server", &error);
1892 if (result < 0) {
1893 fprintf(stderr, "error: %s\n", error.c_str());
1894 }
1895 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001896 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001897 else if (!strcmp(argv[0], "backup")) {
Christopher Tated2f54152011-04-21 12:53:28 -07001898 return backup(argc, argv);
1899 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001900 else if (!strcmp(argv[0], "restore")) {
Christopher Tate702967a2011-05-17 15:52:54 -07001901 return restore(argc, argv);
1902 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001903 else if (!strcmp(argv[0], "keygen")) {
Nick Kralevichbea3f9c2014-11-13 15:17:29 -08001904 if (argc < 2) return usage();
Yabin Cuiaed3c612015-09-22 15:52:57 -07001905 // Always print key generation information for keygen command.
1906 adb_trace_enable(AUTH);
Nick Kralevichbea3f9c2014-11-13 15:17:29 -08001907 return adb_auth_keygen(argv[1]);
1908 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001909 else if (!strcmp(argv[0], "jdwp")) {
Tao Bao175b7bb2015-03-29 11:22:34 -07001910 return adb_connect_command("jdwp");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001911 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001912 /* "adb /?" is a common idiom under Windows */
Riley Andrewsc8514c82014-12-05 17:32:46 -08001913 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001914 help();
1915 return 0;
1916 }
Riley Andrewsc8514c82014-12-05 17:32:46 -08001917 else if (!strcmp(argv[0], "version")) {
Elliott Hughes42ae2602015-08-12 08:32:10 -07001918 fprintf(stdout, "%s", adb_version().c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001919 return 0;
1920 }
Dan Albert90d4b732015-05-20 18:58:41 -07001921 else if (!strcmp(argv[0], "features")) {
David Pursell4e2fd362015-09-22 10:43:08 -07001922 // Only list the features common to both the adb client and the device.
David Pursell0aacbbe2016-01-21 19:56:50 -08001923 FeatureSet features;
Josh Gaof3f6a1d2016-01-31 19:12:26 -08001924 std::string error;
1925 if (!adb_get_feature_set(&features, &error)) {
1926 fprintf(stderr, "error: %s\n", error.c_str());
David Pursell0aacbbe2016-01-21 19:56:50 -08001927 return 1;
1928 }
1929
David Pursell4e2fd362015-09-22 10:43:08 -07001930 for (const std::string& name : features) {
David Pursell70ef7b42015-09-30 13:35:42 -07001931 if (CanUseFeature(features, name)) {
David Pursell4e2fd362015-09-22 10:43:08 -07001932 printf("%s\n", name.c_str());
1933 }
1934 }
1935 return 0;
Yabin Cui03468c82016-04-05 13:50:44 -07001936 } else if (!strcmp(argv[0], "reconnect")) {
1937 if (argc == 1) {
1938 return adb_query_command("host:reconnect");
1939 } else if (argc == 2 && !strcmp(argv[1], "device")) {
1940 std::string err;
1941 adb_connect("reconnect", &err);
1942 return 0;
1943 }
Dan Albert90d4b732015-05-20 18:58:41 -07001944 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001945
1946 usage();
1947 return 1;
1948}
1949
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001950static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) {
1951 // 'adb uninstall' takes the same arguments as 'cmd package uninstall' on device
1952 std::string cmd = "cmd package";
Elliott Hughes2baae3a2015-04-17 10:59:34 -07001953 while (argc-- > 0) {
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001954 // deny the '-k' option until the remaining data/cache can be removed with adb/UI
1955 if (strcmp(*argv, "-k") == 0) {
1956 printf(
1957 "The -k option uninstalls the application while retaining the data/cache.\n"
1958 "At the moment, there is no way to remove the remaining data.\n"
1959 "You will have to reinstall the application with the same signature, and fully uninstall it.\n"
1960 "If you truly wish to continue, execute 'adb shell cmd package uninstall -k'.\n");
1961 return EXIT_FAILURE;
1962 }
Elliott Hughes6c34bba2015-04-17 20:11:08 -07001963 cmd += " " + escape_arg(*argv++);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001964 }
1965
David Pursell70ef7b42015-09-30 13:35:42 -07001966 return send_shell_command(transport, serial, cmd, false);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001967}
1968
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001969static int install_app(TransportType transport, const char* serial, int argc, const char** argv) {
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001970 // The last argument must be the APK file
1971 const char* file = argv[argc - 1];
1972 const char* dot = strrchr(file, '.');
1973 bool found_apk = false;
Jeff Sharkey960df972014-06-09 17:30:57 -07001974 struct stat sb;
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001975 if (dot && !strcasecmp(dot, ".apk")) {
1976 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
1977 fprintf(stderr, "Invalid APK file: %s\n", file);
1978 return EXIT_FAILURE;
Kenny Root597ea5b2011-08-05 11:19:45 -07001979 }
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001980 found_apk = true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001981 }
1982
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001983 if (!found_apk) {
Jeff Sharkey960df972014-06-09 17:30:57 -07001984 fprintf(stderr, "Missing APK file\n");
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001985 return EXIT_FAILURE;
Kenny Root597ea5b2011-08-05 11:19:45 -07001986 }
1987
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001988 int localFd = adb_open(file, O_RDONLY);
1989 if (localFd < 0) {
1990 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno));
1991 return 1;
1992 }
Kenny Root597ea5b2011-08-05 11:19:45 -07001993
Todd Kennedy6fa848a2015-11-03 16:53:08 -08001994 std::string error;
1995 std::string cmd = "exec:cmd package";
1996
1997 // don't copy the APK name, but, copy the rest of the arguments as-is
1998 while (argc-- > 1) {
1999 cmd += " " + escape_arg(std::string(*argv++));
2000 }
2001
2002 // add size parameter [required for streaming installs]
2003 // do last to override any user specified value
2004 cmd += " " + android::base::StringPrintf("-S %" PRIu64, static_cast<uint64_t>(sb.st_size));
2005
2006 int remoteFd = adb_connect(cmd, &error);
2007 if (remoteFd < 0) {
2008 fprintf(stderr, "Connect error for write: %s\n", error.c_str());
2009 adb_close(localFd);
2010 return 1;
2011 }
2012
2013 char buf[BUFSIZ];
2014 copy_to_file(localFd, remoteFd);
2015 read_status_line(remoteFd, buf, sizeof(buf));
2016
2017 adb_close(localFd);
2018 adb_close(remoteFd);
2019
2020 if (strncmp("Success", buf, 7)) {
Elliott Hughesfe018852015-12-17 14:04:38 -08002021 fprintf(stderr, "Failed to install %s: %s", file, buf);
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002022 return 1;
2023 }
2024 fputs(buf, stderr);
2025 return 0;
Jeff Sharkey960df972014-06-09 17:30:57 -07002026}
2027
Elliott Hughes3bd73c12015-05-05 13:10:43 -07002028static int install_multiple_app(TransportType transport, const char* serial, int argc,
Elliott Hughes58305772015-04-17 13:57:15 -07002029 const char** argv)
Jeff Sharkey960df972014-06-09 17:30:57 -07002030{
Jeff Sharkey960df972014-06-09 17:30:57 -07002031 int i;
2032 struct stat sb;
Elliott Hughes2940ccf2015-04-17 14:07:52 -07002033 uint64_t total_size = 0;
Jeff Sharkey960df972014-06-09 17:30:57 -07002034
2035 // Find all APK arguments starting at end.
2036 // All other arguments passed through verbatim.
2037 int first_apk = -1;
2038 for (i = argc - 1; i >= 0; i--) {
Dan Albertbac34742015-02-25 17:51:28 -08002039 const char* file = argv[i];
Elliott Hughes3e7048c2015-07-27 21:21:39 -07002040 const char* dot = strrchr(file, '.');
Jeff Sharkey960df972014-06-09 17:30:57 -07002041 if (dot && !strcasecmp(dot, ".apk")) {
2042 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
2043 fprintf(stderr, "Invalid APK file: %s\n", file);
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002044 return EXIT_FAILURE;
Jeff Sharkey960df972014-06-09 17:30:57 -07002045 }
2046
2047 total_size += sb.st_size;
2048 first_apk = i;
2049 } else {
2050 break;
2051 }
Kenny Root597ea5b2011-08-05 11:19:45 -07002052 }
2053
Jeff Sharkey960df972014-06-09 17:30:57 -07002054 if (first_apk == -1) {
2055 fprintf(stderr, "Missing APK file\n");
2056 return 1;
2057 }
Kenny Root597ea5b2011-08-05 11:19:45 -07002058
Elliott Hughes2940ccf2015-04-17 14:07:52 -07002059 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size);
Jeff Sharkey960df972014-06-09 17:30:57 -07002060 for (i = 1; i < first_apk; i++) {
Elliott Hughes6c34bba2015-04-17 20:11:08 -07002061 cmd += " " + escape_arg(argv[i]);
Jeff Sharkey960df972014-06-09 17:30:57 -07002062 }
2063
2064 // Create install session
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002065 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -07002066 int fd = adb_connect(cmd, &error);
Jeff Sharkey960df972014-06-09 17:30:57 -07002067 if (fd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002068 fprintf(stderr, "Connect error for create: %s\n", error.c_str());
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002069 return EXIT_FAILURE;
Jeff Sharkey960df972014-06-09 17:30:57 -07002070 }
Elliott Hughes2baae3a2015-04-17 10:59:34 -07002071 char buf[BUFSIZ];
Jeff Sharkey960df972014-06-09 17:30:57 -07002072 read_status_line(fd, buf, sizeof(buf));
2073 adb_close(fd);
2074
2075 int session_id = -1;
2076 if (!strncmp("Success", buf, 7)) {
2077 char* start = strrchr(buf, '[');
2078 char* end = strrchr(buf, ']');
2079 if (start && end) {
2080 *end = '\0';
2081 session_id = strtol(start + 1, NULL, 10);
2082 }
2083 }
2084 if (session_id < 0) {
2085 fprintf(stderr, "Failed to create session\n");
Christopher Tate71bbc672014-07-14 16:45:13 -07002086 fputs(buf, stderr);
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002087 return EXIT_FAILURE;
Jeff Sharkey960df972014-06-09 17:30:57 -07002088 }
2089
2090 // Valid session, now stream the APKs
2091 int success = 1;
2092 for (i = first_apk; i < argc; i++) {
Dan Albertbac34742015-02-25 17:51:28 -08002093 const char* file = argv[i];
Jeff Sharkey960df972014-06-09 17:30:57 -07002094 if (stat(file, &sb) == -1) {
2095 fprintf(stderr, "Failed to stat %s\n", file);
2096 success = 0;
2097 goto finalize_session;
2098 }
2099
Elliott Hughes2940ccf2015-04-17 14:07:52 -07002100 std::string cmd = android::base::StringPrintf(
2101 "exec:pm install-write -S %" PRIu64 " %d %d_%s -",
Elliott Hughes5c742702015-07-30 17:42:01 -07002102 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str());
Jeff Sharkey960df972014-06-09 17:30:57 -07002103
2104 int localFd = adb_open(file, O_RDONLY);
2105 if (localFd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002106 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno));
Jeff Sharkey960df972014-06-09 17:30:57 -07002107 success = 0;
2108 goto finalize_session;
2109 }
2110
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002111 std::string error;
Elliott Hughes6452a892015-04-29 12:28:13 -07002112 int remoteFd = adb_connect(cmd, &error);
Jeff Sharkey960df972014-06-09 17:30:57 -07002113 if (remoteFd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002114 fprintf(stderr, "Connect error for write: %s\n", error.c_str());
Jeff Sharkey960df972014-06-09 17:30:57 -07002115 adb_close(localFd);
2116 success = 0;
2117 goto finalize_session;
2118 }
2119
2120 copy_to_file(localFd, remoteFd);
2121 read_status_line(remoteFd, buf, sizeof(buf));
2122
2123 adb_close(localFd);
2124 adb_close(remoteFd);
2125
2126 if (strncmp("Success", buf, 7)) {
2127 fprintf(stderr, "Failed to write %s\n", file);
Christopher Tate71bbc672014-07-14 16:45:13 -07002128 fputs(buf, stderr);
Jeff Sharkey960df972014-06-09 17:30:57 -07002129 success = 0;
2130 goto finalize_session;
2131 }
2132 }
2133
2134finalize_session:
Jeff Sharkeyac77e1f2014-07-25 09:58:25 -07002135 // Commit session if we streamed everything okay; otherwise abandon
Elliott Hughes6452a892015-04-29 12:28:13 -07002136 std::string service =
2137 android::base::StringPrintf("exec:pm install-%s %d",
2138 success ? "commit" : "abandon", session_id);
2139 fd = adb_connect(service, &error);
Jeff Sharkey960df972014-06-09 17:30:57 -07002140 if (fd < 0) {
Elliott Hughes078f0fc2015-04-29 08:35:59 -07002141 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str());
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002142 return EXIT_FAILURE;
Jeff Sharkey960df972014-06-09 17:30:57 -07002143 }
2144 read_status_line(fd, buf, sizeof(buf));
2145 adb_close(fd);
2146
2147 if (!strncmp("Success", buf, 7)) {
Christopher Tate71bbc672014-07-14 16:45:13 -07002148 fputs(buf, stderr);
Jeff Sharkey960df972014-06-09 17:30:57 -07002149 return 0;
2150 } else {
2151 fprintf(stderr, "Failed to finalize session\n");
Christopher Tate71bbc672014-07-14 16:45:13 -07002152 fputs(buf, stderr);
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002153 return EXIT_FAILURE;
Jeff Sharkey960df972014-06-09 17:30:57 -07002154 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08002155}
Todd Kennedy6fa848a2015-11-03 16:53:08 -08002156
2157static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) {
2158 std::string cmd = "pm";
2159
2160 while (argc-- > 0) {
2161 cmd += " " + escape_arg(*argv++);
2162 }
2163
2164 return send_shell_command(transport, serial, cmd, false);
2165}
2166
2167static int uninstall_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) {
2168 /* if the user choose the -k option, we refuse to do it until devices are
2169 out with the option to uninstall the remaining data somehow (adb/ui) */
2170 int i;
2171 for (i = 1; i < argc; i++) {
2172 if (!strcmp(argv[i], "-k")) {
2173 printf(
2174 "The -k option uninstalls the application while retaining the data/cache.\n"
2175 "At the moment, there is no way to remove the remaining data.\n"
2176 "You will have to reinstall the application with the same signature, and fully uninstall it.\n"
2177 "If you truly wish to continue, execute 'adb shell pm uninstall -k'\n.");
2178 return EXIT_FAILURE;
2179 }
2180 }
2181
2182 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */
2183 return pm_command(transport, serial, argc, argv);
2184}
2185
2186static int delete_file(TransportType transport, const char* serial, const std::string& filename) {
2187 std::string cmd = "rm -f " + escape_arg(filename);
2188 return send_shell_command(transport, serial, cmd, false);
2189}
2190
2191static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) {
2192 static const char *const DATA_DEST = "/data/local/tmp/%s";
2193 static const char *const SD_DEST = "/sdcard/tmp/%s";
2194 const char* where = DATA_DEST;
2195 int i;
2196 struct stat sb;
2197
2198 for (i = 1; i < argc; i++) {
2199 if (!strcmp(argv[i], "-s")) {
2200 where = SD_DEST;
2201 }
2202 }
2203
2204 // Find last APK argument.
2205 // All other arguments passed through verbatim.
2206 int last_apk = -1;
2207 for (i = argc - 1; i >= 0; i--) {
2208 const char* file = argv[i];
2209 const char* dot = strrchr(file, '.');
2210 if (dot && !strcasecmp(dot, ".apk")) {
2211 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
2212 fprintf(stderr, "Invalid APK file: %s\n", file);
2213 return EXIT_FAILURE;
2214 }
2215
2216 last_apk = i;
2217 break;
2218 }
2219 }
2220
2221 if (last_apk == -1) {
2222 fprintf(stderr, "Missing APK file\n");
2223 return EXIT_FAILURE;
2224 }
2225
2226 int result = -1;
2227 std::vector<const char*> apk_file = {argv[last_apk]};
2228 std::string apk_dest = android::base::StringPrintf(
2229 where, adb_basename(argv[last_apk]).c_str());
2230 if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk;
2231 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
2232 result = pm_command(transport, serial, argc, argv);
2233
2234cleanup_apk:
2235 delete_file(transport, serial, apk_dest);
2236 return result;
2237}