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