The Android Open Source Project | dd7bc33 | 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 | |
Dan Albert | 3313426 | 2015-03-19 15:21:08 -0700 | [diff] [blame] | 17 | #define TRACE_TAG TRACE_ADB |
| 18 | |
| 19 | #include "sysdeps.h" |
| 20 | #include "adb.h" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 21 | |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 22 | #include <ctype.h> |
| 23 | #include <errno.h> |
| 24 | #include <stdarg.h> |
| 25 | #include <stddef.h> |
| 26 | #include <stdint.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 27 | #include <stdio.h> |
| 28 | #include <stdlib.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 29 | #include <string.h> |
Mike Lockwood | 1f546e6 | 2009-05-25 18:17:55 -0400 | [diff] [blame] | 30 | #include <sys/time.h> |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 31 | #include <time.h> |
| 32 | |
| 33 | #include <string> |
Dan Albert | e246219 | 2015-03-19 13:25:27 -0700 | [diff] [blame] | 34 | #include <vector> |
| 35 | #include <unordered_map> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 36 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 37 | #include <base/logging.h> |
Elliott Hughes | 7b50609 | 2015-04-20 08:09:20 -0700 | [diff] [blame] | 38 | #include <base/stringprintf.h> |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 39 | #include <base/strings.h> |
Elliott Hughes | 7b50609 | 2015-04-20 08:09:20 -0700 | [diff] [blame] | 40 | |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 41 | #include "adb_auth.h" |
Dan Albert | cc731cc | 2015-02-24 21:26:58 -0800 | [diff] [blame] | 42 | #include "adb_io.h" |
Dan Albert | e9fca14 | 2015-02-18 18:03:26 -0800 | [diff] [blame] | 43 | #include "adb_listeners.h" |
Dan Albert | 7664901 | 2015-02-24 15:51:19 -0800 | [diff] [blame] | 44 | #include "transport.h" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 45 | |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 46 | #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) |
| 47 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 48 | #if !ADB_HOST |
Nick Kralevich | 893a4a4 | 2013-05-23 09:54:13 -0700 | [diff] [blame] | 49 | #include <cutils/properties.h> |
Nick Kralevich | e2864bf | 2013-02-28 14:12:58 -0800 | [diff] [blame] | 50 | #include <sys/capability.h> |
Jeff Sharkey | 885342a | 2012-08-14 21:00:22 -0700 | [diff] [blame] | 51 | #include <sys/mount.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 52 | #endif |
| 53 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 54 | ADB_MUTEX_DEFINE(D_lock); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 55 | |
| 56 | int HOST = 0; |
| 57 | |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 58 | #if !ADB_HOST |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 59 | const char* adb_device_banner = "device"; |
| 60 | static android::base::LogdLogger gLogdLogger; |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 61 | #endif |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 62 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 63 | void AdbLogger(android::base::LogId id, android::base::LogSeverity severity, |
| 64 | const char* tag, const char* file, unsigned int line, |
| 65 | const char* message) { |
| 66 | android::base::StderrLogger(id, severity, tag, file, line, message); |
| 67 | #if !ADB_HOST |
| 68 | gLogdLogger(id, severity, tag, file, line, message); |
| 69 | #endif |
| 70 | } |
| 71 | |
| 72 | void fatal(const char *fmt, ...) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 73 | va_list ap; |
| 74 | va_start(ap, fmt); |
| 75 | fprintf(stderr, "error: "); |
| 76 | vfprintf(stderr, fmt, ap); |
| 77 | fprintf(stderr, "\n"); |
| 78 | va_end(ap); |
| 79 | exit(-1); |
| 80 | } |
| 81 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 82 | void fatal_errno(const char* fmt, ...) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 83 | va_list ap; |
| 84 | va_start(ap, fmt); |
| 85 | fprintf(stderr, "error: %s: ", strerror(errno)); |
| 86 | vfprintf(stderr, fmt, ap); |
| 87 | fprintf(stderr, "\n"); |
| 88 | va_end(ap); |
| 89 | exit(-1); |
| 90 | } |
| 91 | |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 92 | #if !ADB_HOST |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 93 | static std::string get_log_file_name() { |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 94 | struct tm now; |
| 95 | time_t t; |
| 96 | tzset(); |
| 97 | time(&t); |
| 98 | localtime_r(&t, &now); |
| 99 | |
Dan Albert | 8743ef9 | 2015-03-19 22:53:30 -0700 | [diff] [blame] | 100 | char timestamp[PATH_MAX]; |
| 101 | strftime(timestamp, sizeof(timestamp), "%Y-%m-%d-%H-%M-%S", &now); |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 102 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 103 | return android::base::StringPrintf("/data/adb/adb-%s-%d", timestamp, |
| 104 | getpid()); |
| 105 | } |
| 106 | |
| 107 | void start_device_log(void) { |
| 108 | int fd = unix_open(get_log_file_name().c_str(), |
| 109 | O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640); |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 110 | if (fd == -1) { |
| 111 | return; |
| 112 | } |
| 113 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 114 | // Redirect stdout and stderr to the log file. |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 115 | dup2(fd, STDOUT_FILENO); |
| 116 | dup2(fd, STDERR_FILENO); |
| 117 | fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid()); |
| 118 | adb_close(fd); |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 119 | } |
| 120 | #endif |
| 121 | |
| 122 | int adb_trace_mask; |
| 123 | |
| 124 | std::string get_trace_setting_from_env() { |
| 125 | const char* setting = getenv("ADB_TRACE"); |
| 126 | if (setting == nullptr) { |
| 127 | setting = ""; |
| 128 | } |
| 129 | |
| 130 | return std::string(setting); |
| 131 | } |
| 132 | |
| 133 | #if !ADB_HOST |
| 134 | std::string get_trace_setting_from_prop() { |
| 135 | char buf[PROPERTY_VALUE_MAX]; |
| 136 | property_get("persist.adb.trace_mask", buf, ""); |
| 137 | return std::string(buf); |
| 138 | } |
| 139 | #endif |
| 140 | |
| 141 | std::string get_trace_setting() { |
| 142 | #if ADB_HOST |
| 143 | return get_trace_setting_from_env(); |
| 144 | #else |
| 145 | return get_trace_setting_from_prop(); |
| 146 | #endif |
| 147 | } |
| 148 | |
Dan Albert | e246219 | 2015-03-19 13:25:27 -0700 | [diff] [blame] | 149 | // Split the space separated list of tags from the trace setting and build the |
| 150 | // trace mask from it. note that '1' and 'all' are special cases to enable all |
| 151 | // tracing. |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 152 | // |
| 153 | // adb's trace setting comes from the ADB_TRACE environment variable, whereas |
| 154 | // adbd's comes from the system property persist.adb.trace_mask. |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 155 | static void setup_trace_mask() { |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 156 | const std::string trace_setting = get_trace_setting(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 157 | |
Dan Albert | e246219 | 2015-03-19 13:25:27 -0700 | [diff] [blame] | 158 | std::unordered_map<std::string, int> trace_flags = { |
| 159 | {"1", 0}, |
| 160 | {"all", 0}, |
| 161 | {"adb", TRACE_ADB}, |
| 162 | {"sockets", TRACE_SOCKETS}, |
| 163 | {"packets", TRACE_PACKETS}, |
| 164 | {"rwx", TRACE_RWX}, |
| 165 | {"usb", TRACE_USB}, |
| 166 | {"sync", TRACE_SYNC}, |
| 167 | {"sysdeps", TRACE_SYSDEPS}, |
| 168 | {"transport", TRACE_TRANSPORT}, |
| 169 | {"jdwp", TRACE_JDWP}, |
| 170 | {"services", TRACE_SERVICES}, |
| 171 | {"auth", TRACE_AUTH}}; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 172 | |
Dan Albert | e246219 | 2015-03-19 13:25:27 -0700 | [diff] [blame] | 173 | std::vector<std::string> elements = android::base::Split(trace_setting, " "); |
| 174 | for (const auto& elem : elements) { |
| 175 | const auto& flag = trace_flags.find(elem); |
| 176 | if (flag == trace_flags.end()) { |
| 177 | D("Unknown trace flag: %s", flag->first.c_str()); |
| 178 | continue; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 179 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 180 | |
Dan Albert | e246219 | 2015-03-19 13:25:27 -0700 | [diff] [blame] | 181 | if (flag->second == 0) { |
| 182 | // 0 is used for the special values "1" and "all" that enable all |
| 183 | // tracing. |
| 184 | adb_trace_mask = ~0; |
| 185 | return; |
| 186 | } else { |
| 187 | adb_trace_mask |= 1 << flag->second; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 188 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 189 | } |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 190 | } |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 191 | |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 192 | void adb_trace_init(char** argv) { |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 193 | #if !ADB_HOST |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 194 | if (isatty(STDOUT_FILENO) == 0) { |
| 195 | start_device_log(); |
| 196 | } |
Dan Albert | ea2175a | 2015-03-08 21:12:08 -0700 | [diff] [blame] | 197 | #endif |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 198 | |
| 199 | setup_trace_mask(); |
| 200 | android::base::InitLogging(argv, AdbLogger); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 201 | } |
| 202 | |
Dan Albert | bac3474 | 2015-02-25 17:51:28 -0800 | [diff] [blame] | 203 | apacket* get_apacket(void) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 204 | { |
Dan Albert | bac3474 | 2015-02-25 17:51:28 -0800 | [diff] [blame] | 205 | apacket* p = reinterpret_cast<apacket*>(malloc(sizeof(apacket))); |
| 206 | if (p == nullptr) { |
| 207 | fatal("failed to allocate an apacket"); |
| 208 | } |
| 209 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 210 | memset(p, 0, sizeof(apacket) - MAX_PAYLOAD); |
| 211 | return p; |
| 212 | } |
| 213 | |
| 214 | void put_apacket(apacket *p) |
| 215 | { |
| 216 | free(p); |
| 217 | } |
| 218 | |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 219 | void handle_online(atransport *t) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 220 | { |
| 221 | D("adb: online\n"); |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 222 | t->online = 1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | void handle_offline(atransport *t) |
| 226 | { |
| 227 | D("adb: offline\n"); |
| 228 | //Close the associated usb |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 229 | t->online = 0; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 230 | run_transport_disconnects(t); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 231 | } |
| 232 | |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 233 | #if DEBUG_PACKETS |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 234 | #define DUMPMAX 32 |
| 235 | void print_packet(const char *label, apacket *p) |
| 236 | { |
| 237 | char *tag; |
| 238 | char *x; |
| 239 | unsigned count; |
| 240 | |
| 241 | switch(p->msg.command){ |
| 242 | case A_SYNC: tag = "SYNC"; break; |
| 243 | case A_CNXN: tag = "CNXN" ; break; |
| 244 | case A_OPEN: tag = "OPEN"; break; |
| 245 | case A_OKAY: tag = "OKAY"; break; |
| 246 | case A_CLSE: tag = "CLSE"; break; |
| 247 | case A_WRTE: tag = "WRTE"; break; |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 248 | case A_AUTH: tag = "AUTH"; break; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 249 | default: tag = "????"; break; |
| 250 | } |
| 251 | |
| 252 | fprintf(stderr, "%s: %s %08x %08x %04x \"", |
| 253 | label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length); |
| 254 | count = p->msg.data_length; |
| 255 | x = (char*) p->data; |
| 256 | if(count > DUMPMAX) { |
| 257 | count = DUMPMAX; |
| 258 | tag = "\n"; |
| 259 | } else { |
| 260 | tag = "\"\n"; |
| 261 | } |
| 262 | while(count-- > 0){ |
| 263 | if((*x >= ' ') && (*x < 127)) { |
| 264 | fputc(*x, stderr); |
| 265 | } else { |
| 266 | fputc('.', stderr); |
| 267 | } |
| 268 | x++; |
| 269 | } |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 270 | fputs(tag, stderr); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 271 | } |
| 272 | #endif |
| 273 | |
| 274 | static void send_ready(unsigned local, unsigned remote, atransport *t) |
| 275 | { |
| 276 | D("Calling send_ready \n"); |
| 277 | apacket *p = get_apacket(); |
| 278 | p->msg.command = A_OKAY; |
| 279 | p->msg.arg0 = local; |
| 280 | p->msg.arg1 = remote; |
| 281 | send_packet(p, t); |
| 282 | } |
| 283 | |
| 284 | static void send_close(unsigned local, unsigned remote, atransport *t) |
| 285 | { |
| 286 | D("Calling send_close \n"); |
| 287 | apacket *p = get_apacket(); |
| 288 | p->msg.command = A_CLSE; |
| 289 | p->msg.arg0 = local; |
| 290 | p->msg.arg1 = remote; |
| 291 | send_packet(p, t); |
| 292 | } |
| 293 | |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 294 | static size_t fill_connect_data(char *buf, size_t bufsize) |
| 295 | { |
| 296 | #if ADB_HOST |
| 297 | return snprintf(buf, bufsize, "host::") + 1; |
| 298 | #else |
| 299 | static const char *cnxn_props[] = { |
| 300 | "ro.product.name", |
| 301 | "ro.product.model", |
| 302 | "ro.product.device", |
| 303 | }; |
| 304 | static const int num_cnxn_props = ARRAY_SIZE(cnxn_props); |
| 305 | int i; |
| 306 | size_t remaining = bufsize; |
| 307 | size_t len; |
| 308 | |
| 309 | len = snprintf(buf, remaining, "%s::", adb_device_banner); |
| 310 | remaining -= len; |
| 311 | buf += len; |
| 312 | for (i = 0; i < num_cnxn_props; i++) { |
| 313 | char value[PROPERTY_VALUE_MAX]; |
| 314 | property_get(cnxn_props[i], value, ""); |
| 315 | len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i], value); |
| 316 | remaining -= len; |
| 317 | buf += len; |
| 318 | } |
| 319 | |
| 320 | return bufsize - remaining + 1; |
| 321 | #endif |
| 322 | } |
| 323 | |
Dan Albert | ba3a251 | 2015-02-18 17:47:33 -0800 | [diff] [blame] | 324 | void send_connect(atransport *t) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 325 | { |
| 326 | D("Calling send_connect \n"); |
| 327 | apacket *cp = get_apacket(); |
| 328 | cp->msg.command = A_CNXN; |
| 329 | cp->msg.arg0 = A_VERSION; |
| 330 | cp->msg.arg1 = MAX_PAYLOAD; |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 331 | cp->msg.data_length = fill_connect_data((char *)cp->data, |
| 332 | sizeof(cp->data)); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 333 | send_packet(cp, t); |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 334 | } |
| 335 | |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 336 | // qual_overwrite is used to overwrite a qualifier string. dst is a |
| 337 | // pointer to a char pointer. It is assumed that if *dst is non-NULL, it |
| 338 | // was malloc'ed and needs to freed. *dst will be set to a dup of src. |
| 339 | // TODO: switch to std::string for these atransport fields instead. |
| 340 | static void qual_overwrite(char** dst, const std::string& src) { |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 341 | free(*dst); |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 342 | *dst = strdup(src.c_str()); |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 343 | } |
| 344 | |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 345 | void parse_banner(const char* banner, atransport* t) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 346 | D("parse_banner: %s\n", banner); |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 347 | |
| 348 | // The format is something like: |
| 349 | // "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;". |
| 350 | std::vector<std::string> pieces = android::base::Split(banner, ":"); |
| 351 | |
| 352 | if (pieces.size() > 2) { |
| 353 | const std::string& props = pieces[2]; |
| 354 | for (auto& prop : android::base::Split(props, ";")) { |
| 355 | // The list of properties was traditionally ;-terminated rather than ;-separated. |
| 356 | if (prop.empty()) continue; |
| 357 | |
| 358 | std::vector<std::string> key_value = android::base::Split(prop, "="); |
| 359 | if (key_value.size() != 2) continue; |
| 360 | |
| 361 | const std::string& key = key_value[0]; |
| 362 | const std::string& value = key_value[1]; |
| 363 | if (key == "ro.product.name") { |
| 364 | qual_overwrite(&t->product, value); |
| 365 | } else if (key == "ro.product.model") { |
| 366 | qual_overwrite(&t->model, value); |
| 367 | } else if (key == "ro.product.device") { |
| 368 | qual_overwrite(&t->device, value); |
Scott Anderson | e82c2db | 2012-05-25 14:10:02 -0700 | [diff] [blame] | 369 | } |
| 370 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 371 | } |
| 372 | |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 373 | const std::string& type = pieces[0]; |
| 374 | if (type == "bootloader") { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 375 | D("setting connection_state to kCsBootloader\n"); |
| 376 | t->connection_state = kCsBootloader; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 377 | update_transports(); |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 378 | } else if (type == "device") { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 379 | D("setting connection_state to kCsDevice\n"); |
| 380 | t->connection_state = kCsDevice; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 381 | update_transports(); |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 382 | } else if (type == "recovery") { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 383 | D("setting connection_state to kCsRecovery\n"); |
| 384 | t->connection_state = kCsRecovery; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 385 | update_transports(); |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 386 | } else if (type == "sideload") { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 387 | D("setting connection_state to kCsSideload\n"); |
| 388 | t->connection_state = kCsSideload; |
Doug Zongker | 447f061 | 2012-01-09 14:54:53 -0800 | [diff] [blame] | 389 | update_transports(); |
Elliott Hughes | 3ce9575 | 2015-04-29 22:37:25 -0700 | [diff] [blame] | 390 | } else { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 391 | D("setting connection_state to kCsHost\n"); |
| 392 | t->connection_state = kCsHost; |
Doug Zongker | 447f061 | 2012-01-09 14:54:53 -0800 | [diff] [blame] | 393 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 394 | } |
| 395 | |
| 396 | void handle_packet(apacket *p, atransport *t) |
| 397 | { |
| 398 | asocket *s; |
| 399 | |
Viral Mehta | 899913f | 2010-06-16 18:41:28 +0530 | [diff] [blame] | 400 | D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0], |
| 401 | ((char*) (&(p->msg.command)))[1], |
| 402 | ((char*) (&(p->msg.command)))[2], |
| 403 | ((char*) (&(p->msg.command)))[3]); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 404 | print_packet("recv", p); |
| 405 | |
| 406 | switch(p->msg.command){ |
| 407 | case A_SYNC: |
| 408 | if(p->msg.arg0){ |
| 409 | send_packet(p, t); |
| 410 | if(HOST) send_connect(t); |
| 411 | } else { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 412 | t->connection_state = kCsOffline; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 413 | handle_offline(t); |
| 414 | send_packet(p, t); |
| 415 | } |
| 416 | return; |
| 417 | |
| 418 | case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */ |
| 419 | /* XXX verify version, etc */ |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 420 | if(t->connection_state != kCsOffline) { |
| 421 | t->connection_state = kCsOffline; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 422 | handle_offline(t); |
| 423 | } |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 424 | |
Elliott Hughes | 8d5fa6d | 2015-04-24 23:02:00 -0700 | [diff] [blame] | 425 | parse_banner(reinterpret_cast<const char*>(p->data), t); |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 426 | |
| 427 | if (HOST || !auth_enabled) { |
| 428 | handle_online(t); |
| 429 | if(!HOST) send_connect(t); |
| 430 | } else { |
| 431 | send_auth_request(t); |
| 432 | } |
| 433 | break; |
| 434 | |
| 435 | case A_AUTH: |
| 436 | if (p->msg.arg0 == ADB_AUTH_TOKEN) { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 437 | t->connection_state = kCsUnauthorized; |
Benoit Goby | d5fcafa | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 438 | t->key = adb_auth_nextkey(t->key); |
| 439 | if (t->key) { |
| 440 | send_auth_response(p->data, p->msg.data_length, t); |
| 441 | } else { |
| 442 | /* No more private keys to try, send the public key */ |
| 443 | send_auth_publickey(t); |
| 444 | } |
| 445 | } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) { |
| 446 | if (adb_auth_verify(t->token, p->data, p->msg.data_length)) { |
| 447 | adb_auth_verified(t); |
| 448 | t->failed_auth_attempts = 0; |
| 449 | } else { |
| 450 | if (t->failed_auth_attempts++ > 10) |
| 451 | adb_sleep_ms(1000); |
| 452 | send_auth_request(t); |
| 453 | } |
| 454 | } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) { |
| 455 | adb_auth_confirm_key(p->data, p->msg.data_length, t); |
| 456 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 457 | break; |
| 458 | |
| 459 | case A_OPEN: /* OPEN(local-id, 0, "destination") */ |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 460 | if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 461 | char *name = (char*) p->data; |
| 462 | name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0; |
| 463 | s = create_local_service_socket(name); |
| 464 | if(s == 0) { |
| 465 | send_close(0, p->msg.arg0, t); |
| 466 | } else { |
| 467 | s->peer = create_remote_socket(p->msg.arg0, t); |
| 468 | s->peer->peer = s; |
| 469 | send_ready(s->id, s->peer->id, t); |
| 470 | s->ready(s); |
| 471 | } |
| 472 | } |
| 473 | break; |
| 474 | |
| 475 | case A_OKAY: /* READY(local-id, remote-id, "") */ |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 476 | if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { |
| 477 | if((s = find_local_socket(p->msg.arg1, 0))) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 478 | if(s->peer == 0) { |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 479 | /* On first READY message, create the connection. */ |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 480 | s->peer = create_remote_socket(p->msg.arg0, t); |
| 481 | s->peer->peer = s; |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 482 | s->ready(s); |
| 483 | } else if (s->peer->id == p->msg.arg0) { |
| 484 | /* Other READY messages must use the same local-id */ |
| 485 | s->ready(s); |
| 486 | } else { |
| 487 | D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s\n", |
| 488 | p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 489 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 490 | } |
| 491 | } |
| 492 | break; |
| 493 | |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 494 | case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */ |
| 495 | if (t->online && p->msg.arg1 != 0) { |
| 496 | if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { |
| 497 | /* According to protocol.txt, p->msg.arg0 might be 0 to indicate |
| 498 | * a failed OPEN only. However, due to a bug in previous ADB |
| 499 | * versions, CLOSE(0, remote-id, "") was also used for normal |
| 500 | * CLOSE() operations. |
| 501 | * |
| 502 | * This is bad because it means a compromised adbd could |
| 503 | * send packets to close connections between the host and |
| 504 | * other devices. To avoid this, only allow this if the local |
| 505 | * socket has a peer on the same transport. |
| 506 | */ |
| 507 | if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) { |
| 508 | D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s\n", |
| 509 | p->msg.arg1, t->serial, s->peer->transport->serial); |
| 510 | } else { |
| 511 | s->close(s); |
| 512 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 513 | } |
| 514 | } |
| 515 | break; |
| 516 | |
David 'Digit' Turner | 818d641 | 2013-12-13 14:09:44 +0100 | [diff] [blame] | 517 | case A_WRTE: /* WRITE(local-id, remote-id, <data>) */ |
| 518 | if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { |
| 519 | if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 520 | unsigned rid = p->msg.arg0; |
| 521 | p->len = p->msg.data_length; |
| 522 | |
| 523 | if(s->enqueue(s, p) == 0) { |
| 524 | D("Enqueue the socket\n"); |
| 525 | send_ready(s->id, rid, t); |
| 526 | } |
| 527 | return; |
| 528 | } |
| 529 | } |
| 530 | break; |
| 531 | |
| 532 | default: |
| 533 | printf("handle_packet: what is %08x?!\n", p->msg.command); |
| 534 | } |
| 535 | |
| 536 | put_apacket(p); |
| 537 | } |
| 538 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 539 | #if ADB_HOST |
JP Abgrall | 571c136 | 2012-12-06 18:18:12 -0800 | [diff] [blame] | 540 | |
Stefan Hilzinger | a84a42e | 2010-04-19 12:21:12 +0100 | [diff] [blame] | 541 | int launch_server(int server_port) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 542 | { |
Yabin Cui | e77b6a0 | 2014-11-11 09:24:11 -0800 | [diff] [blame] | 543 | #if defined(_WIN32) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 544 | /* we need to start the server in the background */ |
| 545 | /* we create a PIPE that will be used to wait for the server's "OK" */ |
| 546 | /* message since the pipe handles must be inheritable, we use a */ |
| 547 | /* security attribute */ |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 548 | HANDLE nul_read, nul_write; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 549 | HANDLE pipe_read, pipe_write; |
Ray Donnelly | 267aa8b | 2012-11-29 01:18:50 +0000 | [diff] [blame] | 550 | HANDLE stdout_handle, stderr_handle; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 551 | SECURITY_ATTRIBUTES sa; |
| 552 | STARTUPINFO startup; |
| 553 | PROCESS_INFORMATION pinfo; |
| 554 | char program_path[ MAX_PATH ]; |
| 555 | int ret; |
| 556 | |
| 557 | sa.nLength = sizeof(sa); |
| 558 | sa.lpSecurityDescriptor = NULL; |
| 559 | sa.bInheritHandle = TRUE; |
| 560 | |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 561 | /* Redirect stdin and stderr to Windows /dev/null. If we instead pass our |
| 562 | * stdin/stderr handles and they are console handles, when the adb server |
| 563 | * starts up, the C Runtime will see console handles for a process that |
| 564 | * isn't connected to a console and it will configure stderr to be closed. |
| 565 | * At that point, freopen() could be used to reopen stderr, but it would |
| 566 | * take more massaging to fixup the file descriptor number that freopen() |
| 567 | * uses. It's simplest to avoid all of this complexity by just redirecting |
| 568 | * stdin/stderr to `nul' and then the C Runtime acts as expected. |
| 569 | */ |
| 570 | nul_read = CreateFileW(L"nul", GENERIC_READ, |
| 571 | FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, |
| 572 | OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); |
| 573 | if (nul_read == INVALID_HANDLE_VALUE) { |
| 574 | fprintf(stderr, "CreateFileW(nul, GENERIC_READ) failure, error %ld\n", |
| 575 | GetLastError()); |
| 576 | return -1; |
| 577 | } |
| 578 | |
| 579 | nul_write = CreateFileW(L"nul", GENERIC_WRITE, |
| 580 | FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, |
| 581 | OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); |
| 582 | if (nul_write == INVALID_HANDLE_VALUE) { |
| 583 | fprintf(stderr, "CreateFileW(nul, GENERIC_WRITE) failure, error %ld\n", |
| 584 | GetLastError()); |
| 585 | CloseHandle(nul_read); |
| 586 | return -1; |
| 587 | } |
| 588 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 589 | /* create pipe, and ensure its read handle isn't inheritable */ |
| 590 | ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 ); |
| 591 | if (!ret) { |
| 592 | fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() ); |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 593 | CloseHandle(nul_read); |
| 594 | CloseHandle(nul_write); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 595 | return -1; |
| 596 | } |
| 597 | |
| 598 | SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 ); |
| 599 | |
Ray Donnelly | 267aa8b | 2012-11-29 01:18:50 +0000 | [diff] [blame] | 600 | /* Some programs want to launch an adb command and collect its output by |
| 601 | * calling CreateProcess with inheritable stdout/stderr handles, then |
| 602 | * using read() to get its output. When this happens, the stdout/stderr |
| 603 | * handles passed to the adb client process will also be inheritable. |
| 604 | * When starting the adb server here, care must be taken to reset them |
| 605 | * to non-inheritable. |
| 606 | * Otherwise, something bad happens: even if the adb command completes, |
| 607 | * the calling process is stuck while read()-ing from the stdout/stderr |
| 608 | * descriptors, because they're connected to corresponding handles in the |
| 609 | * adb server process (even if the latter never uses/writes to them). |
| 610 | */ |
| 611 | stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE ); |
| 612 | stderr_handle = GetStdHandle( STD_ERROR_HANDLE ); |
| 613 | if (stdout_handle != INVALID_HANDLE_VALUE) { |
| 614 | SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 ); |
| 615 | } |
| 616 | if (stderr_handle != INVALID_HANDLE_VALUE) { |
| 617 | SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 ); |
| 618 | } |
| 619 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 620 | ZeroMemory( &startup, sizeof(startup) ); |
| 621 | startup.cb = sizeof(startup); |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 622 | startup.hStdInput = nul_read; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 623 | startup.hStdOutput = pipe_write; |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 624 | startup.hStdError = nul_write; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 625 | startup.dwFlags = STARTF_USESTDHANDLES; |
| 626 | |
| 627 | ZeroMemory( &pinfo, sizeof(pinfo) ); |
| 628 | |
| 629 | /* get path of current program */ |
| 630 | GetModuleFileName( NULL, program_path, sizeof(program_path) ); |
Wenhao Li | a09558c | 2013-11-13 16:23:37 +0800 | [diff] [blame] | 631 | char args[64]; |
| 632 | snprintf(args, sizeof(args), "adb -P %d fork-server server", server_port); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 633 | ret = CreateProcess( |
| 634 | program_path, /* program path */ |
Wenhao Li | a09558c | 2013-11-13 16:23:37 +0800 | [diff] [blame] | 635 | args, |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 636 | /* the fork-server argument will set the |
| 637 | debug = 2 in the child */ |
| 638 | NULL, /* process handle is not inheritable */ |
| 639 | NULL, /* thread handle is not inheritable */ |
| 640 | TRUE, /* yes, inherit some handles */ |
| 641 | DETACHED_PROCESS, /* the new process doesn't have a console */ |
| 642 | NULL, /* use parent's environment block */ |
| 643 | NULL, /* use parent's starting directory */ |
| 644 | &startup, /* startup info, i.e. std handles */ |
| 645 | &pinfo ); |
| 646 | |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame^] | 647 | CloseHandle( nul_read ); |
| 648 | CloseHandle( nul_write ); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 649 | CloseHandle( pipe_write ); |
| 650 | |
| 651 | if (!ret) { |
| 652 | fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() ); |
| 653 | CloseHandle( pipe_read ); |
| 654 | return -1; |
| 655 | } |
| 656 | |
| 657 | CloseHandle( pinfo.hProcess ); |
| 658 | CloseHandle( pinfo.hThread ); |
| 659 | |
| 660 | /* wait for the "OK\n" message */ |
| 661 | { |
| 662 | char temp[3]; |
| 663 | DWORD count; |
| 664 | |
| 665 | ret = ReadFile( pipe_read, temp, 3, &count, NULL ); |
| 666 | CloseHandle( pipe_read ); |
| 667 | if ( !ret ) { |
| 668 | fprintf(stderr, "could not read ok from ADB Server, error = %ld\n", GetLastError() ); |
| 669 | return -1; |
| 670 | } |
| 671 | if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { |
| 672 | fprintf(stderr, "ADB server didn't ACK\n" ); |
| 673 | return -1; |
| 674 | } |
| 675 | } |
Yabin Cui | e77b6a0 | 2014-11-11 09:24:11 -0800 | [diff] [blame] | 676 | #else /* !defined(_WIN32) */ |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 677 | char path[PATH_MAX]; |
| 678 | int fd[2]; |
| 679 | |
| 680 | // set up a pipe so the child can tell us when it is ready. |
| 681 | // fd[0] will be parent's end, and fd[1] will get mapped to stderr in the child. |
| 682 | if (pipe(fd)) { |
| 683 | fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno); |
| 684 | return -1; |
| 685 | } |
Alexey Tarasov | 3166410 | 2009-10-22 02:55:00 +1100 | [diff] [blame] | 686 | get_my_path(path, PATH_MAX); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 687 | pid_t pid = fork(); |
| 688 | if(pid < 0) return -1; |
| 689 | |
| 690 | if (pid == 0) { |
| 691 | // child side of the fork |
| 692 | |
| 693 | // redirect stderr to the pipe |
| 694 | // we use stderr instead of stdout due to stdout's buffering behavior. |
| 695 | adb_close(fd[0]); |
| 696 | dup2(fd[1], STDERR_FILENO); |
| 697 | adb_close(fd[1]); |
| 698 | |
Matt Gumbel | d7b3308 | 2012-11-14 10:16:17 -0800 | [diff] [blame] | 699 | char str_port[30]; |
| 700 | snprintf(str_port, sizeof(str_port), "%d", server_port); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 701 | // child process |
Matt Gumbel | d7b3308 | 2012-11-14 10:16:17 -0800 | [diff] [blame] | 702 | int result = execl(path, "adb", "-P", str_port, "fork-server", "server", NULL); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 703 | // this should not return |
| 704 | fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno); |
| 705 | } else { |
| 706 | // parent side of the fork |
| 707 | |
| 708 | char temp[3]; |
| 709 | |
| 710 | temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C'; |
| 711 | // wait for the "OK\n" message |
| 712 | adb_close(fd[1]); |
| 713 | int ret = adb_read(fd[0], temp, 3); |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 714 | int saved_errno = errno; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 715 | adb_close(fd[0]); |
| 716 | if (ret < 0) { |
JP Abgrall | 408fa57 | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 717 | fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 718 | return -1; |
| 719 | } |
| 720 | if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { |
| 721 | fprintf(stderr, "ADB server didn't ACK\n" ); |
| 722 | return -1; |
| 723 | } |
| 724 | |
| 725 | setsid(); |
| 726 | } |
Yabin Cui | e77b6a0 | 2014-11-11 09:24:11 -0800 | [diff] [blame] | 727 | #endif /* !defined(_WIN32) */ |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 728 | return 0; |
| 729 | } |
Yabin Cui | e77b6a0 | 2014-11-11 09:24:11 -0800 | [diff] [blame] | 730 | #endif /* ADB_HOST */ |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 731 | |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 732 | // Try to handle a network forwarding request. |
| 733 | // This returns 1 on success, 0 on failure, and -1 to indicate this is not |
| 734 | // a forwarding-related request. |
Elliott Hughes | aee80fb | 2015-05-07 21:38:41 -0700 | [diff] [blame] | 735 | int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd) |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 736 | { |
| 737 | if (!strcmp(service, "list-forward")) { |
| 738 | // Create the list of forward redirections. |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 739 | std::string listeners = format_listeners(); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 740 | #if ADB_HOST |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 741 | SendOkay(reply_fd); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 742 | #endif |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 743 | SendProtocolString(reply_fd, listeners); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 744 | return 1; |
| 745 | } |
| 746 | |
| 747 | if (!strcmp(service, "killforward-all")) { |
| 748 | remove_all_listeners(); |
| 749 | #if ADB_HOST |
| 750 | /* On the host: 1st OKAY is connect, 2nd OKAY is status */ |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 751 | SendOkay(reply_fd); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 752 | #endif |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 753 | SendOkay(reply_fd); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 754 | return 1; |
| 755 | } |
| 756 | |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 757 | if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) { |
| 758 | // killforward:local |
| 759 | // forward:(norebind:)?local;remote |
| 760 | bool kill_forward = false; |
| 761 | bool no_rebind = false; |
| 762 | if (android::base::StartsWith(service, "killforward:")) { |
| 763 | kill_forward = true; |
| 764 | service += 12; |
| 765 | if (android::base::StartsWith(service, "norebind:")) { |
| 766 | no_rebind = true; |
| 767 | service += 9; |
| 768 | } |
| 769 | } else { |
| 770 | service += 8; |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 771 | } |
| 772 | |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 773 | std::vector<std::string> pieces = android::base::Split(service, ";"); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 774 | |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 775 | if (kill_forward) { |
| 776 | // Check killforward: parameter format: '<local>' |
| 777 | if (pieces.size() != 1 || pieces[0].empty()) { |
| 778 | SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service)); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 779 | return 1; |
| 780 | } |
| 781 | } else { |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 782 | // Check forward: parameter format: '<local>;<remote>' |
| 783 | if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') { |
| 784 | SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service)); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 785 | return 1; |
| 786 | } |
| 787 | } |
| 788 | |
Elliott Hughes | 7be29c8 | 2015-04-16 22:54:44 -0700 | [diff] [blame] | 789 | std::string error_msg; |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 790 | atransport* transport = acquire_one_transport(kCsAny, type, serial, &error_msg); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 791 | if (!transport) { |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 792 | SendFail(reply_fd, error_msg); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 793 | return 1; |
| 794 | } |
| 795 | |
Elliott Hughes | 3bd73c1 | 2015-05-05 13:10:43 -0700 | [diff] [blame] | 796 | InstallStatus r; |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 797 | if (kill_forward) { |
| 798 | r = remove_listener(pieces[0].c_str(), transport); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 799 | } else { |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 800 | r = install_listener(pieces[0], pieces[1].c_str(), transport, no_rebind); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 801 | } |
Elliott Hughes | 7b50609 | 2015-04-20 08:09:20 -0700 | [diff] [blame] | 802 | if (r == INSTALL_STATUS_OK) { |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 803 | #if ADB_HOST |
| 804 | /* On the host: 1st OKAY is connect, 2nd OKAY is status */ |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 805 | SendOkay(reply_fd); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 806 | #endif |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 807 | SendOkay(reply_fd); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 808 | return 1; |
| 809 | } |
| 810 | |
Elliott Hughes | 7b50609 | 2015-04-20 08:09:20 -0700 | [diff] [blame] | 811 | std::string message; |
| 812 | switch (r) { |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 813 | case INSTALL_STATUS_OK: message = "success (!)"; break; |
Elliott Hughes | 7b50609 | 2015-04-20 08:09:20 -0700 | [diff] [blame] | 814 | case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break; |
| 815 | case INSTALL_STATUS_CANNOT_BIND: |
| 816 | message = android::base::StringPrintf("cannot bind to socket: %s", strerror(errno)); |
| 817 | break; |
| 818 | case INSTALL_STATUS_CANNOT_REBIND: |
| 819 | message = android::base::StringPrintf("cannot rebind existing socket: %s", strerror(errno)); |
| 820 | break; |
Elliott Hughes | 424af02 | 2015-05-29 17:55:19 -0700 | [diff] [blame] | 821 | case INSTALL_STATUS_LISTENER_NOT_FOUND: |
| 822 | message = android::base::StringPrintf("listener '%s' not found", service); |
| 823 | break; |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 824 | } |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 825 | SendFail(reply_fd, message); |
David 'Digit' Turner | 2525869 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 826 | return 1; |
| 827 | } |
| 828 | return 0; |
| 829 | } |
| 830 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 831 | int handle_host_request(const char* service, TransportType type, |
| 832 | const char* serial, int reply_fd, asocket* s) { |
| 833 | if (strcmp(service, "kill") == 0) { |
| 834 | fprintf(stderr, "adb server killed by remote request\n"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 835 | fflush(stdout); |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 836 | SendOkay(reply_fd); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 837 | exit(0); |
| 838 | } |
| 839 | |
| 840 | #if ADB_HOST |
Chih-Hung Hsieh | f787b38 | 2014-09-05 15:38:15 -0700 | [diff] [blame] | 841 | atransport *transport = NULL; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 842 | // "transport:" is used for switching transport with a specified serial number |
| 843 | // "transport-usb:" is used for switching transport to the only USB transport |
| 844 | // "transport-local:" is used for switching transport to the only local transport |
| 845 | // "transport-any:" is used for switching transport to the only transport |
| 846 | if (!strncmp(service, "transport", strlen("transport"))) { |
Elliott Hughes | 3bd73c1 | 2015-05-05 13:10:43 -0700 | [diff] [blame] | 847 | TransportType type = kTransportAny; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 848 | |
| 849 | if (!strncmp(service, "transport-usb", strlen("transport-usb"))) { |
| 850 | type = kTransportUsb; |
| 851 | } else if (!strncmp(service, "transport-local", strlen("transport-local"))) { |
| 852 | type = kTransportLocal; |
| 853 | } else if (!strncmp(service, "transport-any", strlen("transport-any"))) { |
| 854 | type = kTransportAny; |
| 855 | } else if (!strncmp(service, "transport:", strlen("transport:"))) { |
| 856 | service += strlen("transport:"); |
Tom Marlin | 3175c8e | 2011-07-27 12:56:14 -0500 | [diff] [blame] | 857 | serial = service; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 858 | } |
| 859 | |
Elliott Hughes | 7be29c8 | 2015-04-16 22:54:44 -0700 | [diff] [blame] | 860 | std::string error_msg = "unknown failure"; |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 861 | transport = acquire_one_transport(kCsAny, type, serial, &error_msg); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 862 | |
| 863 | if (transport) { |
| 864 | s->transport = transport; |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 865 | SendOkay(reply_fd); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 866 | } else { |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 867 | SendFail(reply_fd, error_msg); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 868 | } |
| 869 | return 1; |
| 870 | } |
| 871 | |
| 872 | // return a list of all connected devices |
Scott Anderson | e109d26 | 2012-04-20 11:21:14 -0700 | [diff] [blame] | 873 | if (!strncmp(service, "devices", 7)) { |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 874 | bool long_listing = (strcmp(service+7, "-l") == 0); |
| 875 | if (long_listing || service[7] == 0) { |
| 876 | D("Getting device list...\n"); |
| 877 | std::string device_list = list_transports(long_listing); |
| 878 | D("Sending device list...\n"); |
| 879 | SendOkay(reply_fd); |
| 880 | SendProtocolString(reply_fd, device_list); |
Scott Anderson | e109d26 | 2012-04-20 11:21:14 -0700 | [diff] [blame] | 881 | return 0; |
| 882 | } |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 883 | return 1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 884 | } |
| 885 | |
Mike Lockwood | 74d7ff8 | 2009-10-11 23:04:18 -0400 | [diff] [blame] | 886 | // remove TCP transport |
| 887 | if (!strncmp(service, "disconnect:", 11)) { |
| 888 | char buffer[4096]; |
| 889 | memset(buffer, 0, sizeof(buffer)); |
Elliott Hughes | aee80fb | 2015-05-07 21:38:41 -0700 | [diff] [blame] | 890 | const char* serial = service + 11; |
Mike Lockwood | cbbe79a | 2010-05-24 10:44:35 -0400 | [diff] [blame] | 891 | if (serial[0] == 0) { |
| 892 | // disconnect from all TCP devices |
| 893 | unregister_all_tcp_transports(); |
Mike Lockwood | 74d7ff8 | 2009-10-11 23:04:18 -0400 | [diff] [blame] | 894 | } else { |
Mike Lockwood | cbbe79a | 2010-05-24 10:44:35 -0400 | [diff] [blame] | 895 | char hostbuf[100]; |
| 896 | // assume port 5555 if no port is specified |
| 897 | if (!strchr(serial, ':')) { |
| 898 | snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555", serial); |
| 899 | serial = hostbuf; |
| 900 | } |
| 901 | atransport *t = find_transport(serial); |
| 902 | |
| 903 | if (t) { |
| 904 | unregister_transport(t); |
| 905 | } else { |
| 906 | snprintf(buffer, sizeof(buffer), "No such device %s", serial); |
| 907 | } |
Mike Lockwood | 74d7ff8 | 2009-10-11 23:04:18 -0400 | [diff] [blame] | 908 | } |
| 909 | |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 910 | SendOkay(reply_fd); |
| 911 | SendProtocolString(reply_fd, buffer); |
Mike Lockwood | 2f38b69 | 2009-08-24 15:58:40 -0700 | [diff] [blame] | 912 | return 0; |
| 913 | } |
| 914 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 915 | // returns our value for ADB_SERVER_VERSION |
| 916 | if (!strcmp(service, "version")) { |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 917 | SendOkay(reply_fd); |
| 918 | SendProtocolString(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION)); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 919 | return 0; |
| 920 | } |
| 921 | |
| 922 | if(!strncmp(service,"get-serialno",strlen("get-serialno"))) { |
Dan Albert | bac3474 | 2015-02-25 17:51:28 -0800 | [diff] [blame] | 923 | const char *out = "unknown"; |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 924 | transport = acquire_one_transport(kCsAny, type, serial, NULL); |
Elliott Hughes | 7be29c8 | 2015-04-16 22:54:44 -0700 | [diff] [blame] | 925 | if (transport && transport->serial) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 926 | out = transport->serial; |
| 927 | } |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 928 | SendOkay(reply_fd); |
| 929 | SendProtocolString(reply_fd, out); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 930 | return 0; |
| 931 | } |
Scott Anderson | e109d26 | 2012-04-20 11:21:14 -0700 | [diff] [blame] | 932 | if(!strncmp(service,"get-devpath",strlen("get-devpath"))) { |
Dan Albert | bac3474 | 2015-02-25 17:51:28 -0800 | [diff] [blame] | 933 | const char *out = "unknown"; |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 934 | transport = acquire_one_transport(kCsAny, type, serial, NULL); |
Elliott Hughes | 7be29c8 | 2015-04-16 22:54:44 -0700 | [diff] [blame] | 935 | if (transport && transport->devpath) { |
Scott Anderson | e109d26 | 2012-04-20 11:21:14 -0700 | [diff] [blame] | 936 | out = transport->devpath; |
| 937 | } |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 938 | SendOkay(reply_fd); |
| 939 | SendProtocolString(reply_fd, out); |
Scott Anderson | e109d26 | 2012-04-20 11:21:14 -0700 | [diff] [blame] | 940 | return 0; |
| 941 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 942 | // indicates a new emulator instance has started |
| 943 | if (!strncmp(service,"emulator:",9)) { |
| 944 | int port = atoi(service+9); |
| 945 | local_connect(port); |
| 946 | /* we don't even need to send a reply */ |
| 947 | return 0; |
| 948 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 949 | |
| 950 | if(!strncmp(service,"get-state",strlen("get-state"))) { |
Dan Albert | dcd78a1 | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 951 | transport = acquire_one_transport(kCsAny, type, serial, NULL); |
Elliott Hughes | e67f1f8 | 2015-04-30 17:32:03 -0700 | [diff] [blame] | 952 | SendOkay(reply_fd); |
| 953 | SendProtocolString(reply_fd, transport->connection_state_name()); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 954 | return 0; |
| 955 | } |
Simon Ye | dc22c3c | 2014-07-14 17:23:06 -0700 | [diff] [blame] | 956 | #endif // ADB_HOST |
| 957 | |
Elliott Hughes | 3bd73c1 | 2015-05-05 13:10:43 -0700 | [diff] [blame] | 958 | int ret = handle_forward_request(service, type, serial, reply_fd); |
Simon Ye | dc22c3c | 2014-07-14 17:23:06 -0700 | [diff] [blame] | 959 | if (ret >= 0) |
| 960 | return ret - 1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 961 | return -1; |
| 962 | } |