1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define TRACE_TAG SERVICES 18 19 #include "sysdeps.h" 20 21 #include <errno.h> 22 #include <stddef.h> 23 #include <stdio.h> 24 #include <stdlib.h> 25 #include <string.h> 26 27 #ifndef _WIN32 28 #include <netdb.h> 29 #include <netinet/in.h> 30 #include <sys/ioctl.h> 31 #include <unistd.h> 32 #endif 33 34 #include <thread> 35 36 #include <android-base/file.h> 37 #include <android-base/parsenetaddress.h> 38 #include <android-base/stringprintf.h> 39 #include <android-base/strings.h> 40 #include <cutils/sockets.h> 41 42 #if !ADB_HOST 43 #include <android-base/properties.h> 44 #include <bootloader_message/bootloader_message.h> 45 #include <cutils/android_reboot.h> 46 #include <log/log_properties.h> 47 #endif 48 49 #include "adb.h" 50 #include "adb_io.h" 51 #include "adb_utils.h" 52 #include "file_sync_service.h" 53 #include "remount_service.h" 54 #include "services.h" 55 #include "shell_service.h" 56 #include "socket_spec.h" 57 #include "sysdeps.h" 58 #include "transport.h" 59 60 struct stinfo { 61 const char* service_name; 62 void (*func)(int fd, void *cookie); 63 int fd; 64 void *cookie; 65 }; 66 67 static void service_bootstrap_func(void* x) { 68 stinfo* sti = reinterpret_cast<stinfo*>(x); 69 adb_thread_setname(android::base::StringPrintf("%s svc %d", sti->service_name, sti->fd)); 70 sti->func(sti->fd, sti->cookie); 71 free(sti); 72 } 73 74 #if !ADB_HOST 75 76 void restart_root_service(int fd, void *cookie) { 77 if (getuid() == 0) { 78 WriteFdExactly(fd, "adbd is already running as root\n"); 79 adb_close(fd); 80 } else { 81 if (!__android_log_is_debuggable()) { 82 WriteFdExactly(fd, "adbd cannot run as root in production builds\n"); 83 adb_close(fd); 84 return; 85 } 86 87 android::base::SetProperty("service.adb.root", "1"); 88 WriteFdExactly(fd, "restarting adbd as root\n"); 89 adb_close(fd); 90 } 91 } 92 93 void restart_unroot_service(int fd, void *cookie) { 94 if (getuid() != 0) { 95 WriteFdExactly(fd, "adbd not running as root\n"); 96 adb_close(fd); 97 } else { 98 android::base::SetProperty("service.adb.root", "0"); 99 WriteFdExactly(fd, "restarting adbd as non root\n"); 100 adb_close(fd); 101 } 102 } 103 104 void restart_tcp_service(int fd, void *cookie) { 105 int port = (int) (uintptr_t) cookie; 106 if (port <= 0) { 107 WriteFdFmt(fd, "invalid port %d\n", port); 108 adb_close(fd); 109 return; 110 } 111 112 android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port)); 113 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port); 114 adb_close(fd); 115 } 116 117 void restart_usb_service(int fd, void *cookie) { 118 android::base::SetProperty("service.adb.tcp.port", "0"); 119 WriteFdExactly(fd, "restarting in USB mode\n"); 120 adb_close(fd); 121 } 122 123 static bool reboot_service_impl(int fd, const char* arg) { 124 const char* reboot_arg = arg; 125 bool auto_reboot = false; 126 127 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) { 128 auto_reboot = true; 129 reboot_arg = "sideload"; 130 } 131 132 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot" 133 // in the command file. 134 if (strcmp(reboot_arg, "sideload") == 0) { 135 if (getuid() != 0) { 136 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n"); 137 return false; 138 } 139 140 const std::vector<std::string> options = { 141 auto_reboot ? "--sideload_auto_reboot" : "--sideload" 142 }; 143 std::string err; 144 if (!write_bootloader_message(options, &err)) { 145 D("Failed to set bootloader message: %s", err.c_str()); 146 return false; 147 } 148 149 reboot_arg = "recovery"; 150 } 151 152 sync(); 153 154 std::string reboot_string = android::base::StringPrintf("reboot,%s", reboot_arg); 155 if (!android::base::SetProperty(ANDROID_RB_PROPERTY, reboot_string)) { 156 WriteFdFmt(fd, "reboot (%s) failed\n", reboot_string.c_str()); 157 return false; 158 } 159 160 return true; 161 } 162 163 void reboot_service(int fd, void* arg) { 164 if (reboot_service_impl(fd, static_cast<const char*>(arg))) { 165 // Don't return early. Give the reboot command time to take effect 166 // to avoid messing up scripts which do "adb reboot && adb wait-for-device" 167 while (true) { 168 pause(); 169 } 170 } 171 172 free(arg); 173 adb_close(fd); 174 } 175 176 static void reconnect_service(int fd, void* arg) { 177 WriteFdExactly(fd, "done"); 178 adb_close(fd); 179 atransport* t = static_cast<atransport*>(arg); 180 kick_transport(t); 181 } 182 183 int reverse_service(const char* command) { 184 int s[2]; 185 if (adb_socketpair(s)) { 186 PLOG(ERROR) << "cannot create service socket pair."; 187 return -1; 188 } 189 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1]; 190 if (handle_forward_request(command, kTransportAny, nullptr, 0, s[1]) < 0) { 191 SendFail(s[1], "not a reverse forwarding command"); 192 } 193 adb_close(s[1]); 194 return s[0]; 195 } 196 197 // Shell service string can look like: 198 // shell[,arg1,arg2,...]:[command] 199 static int ShellService(const std::string& args, const atransport* transport) { 200 size_t delimiter_index = args.find(':'); 201 if (delimiter_index == std::string::npos) { 202 LOG(ERROR) << "No ':' found in shell service arguments: " << args; 203 return -1; 204 } 205 206 const std::string service_args = args.substr(0, delimiter_index); 207 const std::string command = args.substr(delimiter_index + 1); 208 209 // Defaults: 210 // PTY for interactive, raw for non-interactive. 211 // No protocol. 212 // $TERM set to "dumb". 213 SubprocessType type(command.empty() ? SubprocessType::kPty 214 : SubprocessType::kRaw); 215 SubprocessProtocol protocol = SubprocessProtocol::kNone; 216 std::string terminal_type = "dumb"; 217 218 for (const std::string& arg : android::base::Split(service_args, ",")) { 219 if (arg == kShellServiceArgRaw) { 220 type = SubprocessType::kRaw; 221 } else if (arg == kShellServiceArgPty) { 222 type = SubprocessType::kPty; 223 } else if (arg == kShellServiceArgShellProtocol) { 224 protocol = SubprocessProtocol::kShell; 225 } else if (android::base::StartsWith(arg, "TERM=")) { 226 terminal_type = arg.substr(5); 227 } else if (!arg.empty()) { 228 // This is not an error to allow for future expansion. 229 LOG(WARNING) << "Ignoring unknown shell service argument: " << arg; 230 } 231 } 232 233 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol); 234 } 235 236 #endif // !ADB_HOST 237 238 static int create_service_thread(const char* service_name, void (*func)(int, void*), void* cookie) { 239 int s[2]; 240 if (adb_socketpair(s)) { 241 printf("cannot create service socket pair\n"); 242 return -1; 243 } 244 D("socketpair: (%d,%d)", s[0], s[1]); 245 246 #if !ADB_HOST 247 if (func == &file_sync_service) { 248 // Set file sync service socket to maximum size 249 int max_buf = LINUX_MAX_SOCKET_SIZE; 250 adb_setsockopt(s[0], SOL_SOCKET, SO_SNDBUF, &max_buf, sizeof(max_buf)); 251 adb_setsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &max_buf, sizeof(max_buf)); 252 } 253 #endif // !ADB_HOST 254 255 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo))); 256 if (sti == nullptr) { 257 fatal("cannot allocate stinfo"); 258 } 259 sti->service_name = service_name; 260 sti->func = func; 261 sti->cookie = cookie; 262 sti->fd = s[1]; 263 264 std::thread(service_bootstrap_func, sti).detach(); 265 266 D("service thread started, %d:%d",s[0], s[1]); 267 return s[0]; 268 } 269 270 int service_to_fd(const char* name, const atransport* transport) { 271 int ret = -1; 272 273 if (is_socket_spec(name)) { 274 std::string error; 275 ret = socket_spec_connect(name, &error); 276 if (ret < 0) { 277 LOG(ERROR) << "failed to connect to socket '" << name << "': " << error; 278 } 279 #if !ADB_HOST 280 } else if(!strncmp("dev:", name, 4)) { 281 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC); 282 } else if(!strncmp(name, "framebuffer:", 12)) { 283 ret = create_service_thread("fb", framebuffer_service, nullptr); 284 } else if (!strncmp(name, "jdwp:", 5)) { 285 ret = create_jdwp_connection_fd(atoi(name+5)); 286 } else if(!strncmp(name, "shell", 5)) { 287 ret = ShellService(name + 5, transport); 288 } else if(!strncmp(name, "exec:", 5)) { 289 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); 290 } else if(!strncmp(name, "sync:", 5)) { 291 ret = create_service_thread("sync", file_sync_service, nullptr); 292 } else if(!strncmp(name, "remount:", 8)) { 293 ret = create_service_thread("remount", remount_service, nullptr); 294 } else if(!strncmp(name, "reboot:", 7)) { 295 void* arg = strdup(name + 7); 296 if (arg == NULL) return -1; 297 ret = create_service_thread("reboot", reboot_service, arg); 298 } else if(!strncmp(name, "root:", 5)) { 299 ret = create_service_thread("root", restart_root_service, nullptr); 300 } else if(!strncmp(name, "unroot:", 7)) { 301 ret = create_service_thread("unroot", restart_unroot_service, nullptr); 302 } else if(!strncmp(name, "backup:", 7)) { 303 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s", 304 (name + 7)).c_str(), 305 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); 306 } else if(!strncmp(name, "restore:", 8)) { 307 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw, 308 SubprocessProtocol::kNone); 309 } else if(!strncmp(name, "tcpip:", 6)) { 310 int port; 311 if (sscanf(name + 6, "%d", &port) != 1) { 312 return -1; 313 } 314 ret = create_service_thread("tcp", restart_tcp_service, reinterpret_cast<void*>(port)); 315 } else if(!strncmp(name, "usb:", 4)) { 316 ret = create_service_thread("usb", restart_usb_service, nullptr); 317 } else if (!strncmp(name, "reverse:", 8)) { 318 ret = reverse_service(name + 8); 319 } else if(!strncmp(name, "disable-verity:", 15)) { 320 ret = create_service_thread("verity-on", set_verity_enabled_state_service, 321 reinterpret_cast<void*>(0)); 322 } else if(!strncmp(name, "enable-verity:", 15)) { 323 ret = create_service_thread("verity-off", set_verity_enabled_state_service, 324 reinterpret_cast<void*>(1)); 325 } else if (!strcmp(name, "reconnect")) { 326 ret = create_service_thread("reconnect", reconnect_service, 327 const_cast<atransport*>(transport)); 328 #endif 329 } 330 if (ret >= 0) { 331 close_on_exec(ret); 332 } 333 return ret; 334 } 335 336 #if ADB_HOST 337 struct state_info { 338 TransportType transport_type; 339 std::string serial; 340 TransportId transport_id; 341 ConnectionState state; 342 }; 343 344 static void wait_for_state(int fd, void* data) { 345 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data)); 346 347 D("wait_for_state %d", sinfo->state); 348 349 while (true) { 350 bool is_ambiguous = false; 351 std::string error = "unknown error"; 352 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL; 353 atransport* t = acquire_one_transport(sinfo->transport_type, serial, sinfo->transport_id, 354 &is_ambiguous, &error); 355 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->GetConnectionState())) { 356 SendOkay(fd); 357 break; 358 } else if (!is_ambiguous) { 359 adb_pollfd pfd = {.fd = fd, .events = POLLIN }; 360 int rc = adb_poll(&pfd, 1, 1000); 361 if (rc < 0) { 362 SendFail(fd, error); 363 break; 364 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) { 365 // The other end of the socket is closed, probably because the other side was 366 // terminated, bail out. 367 break; 368 } 369 370 // Try again... 371 } else { 372 SendFail(fd, error); 373 break; 374 } 375 } 376 377 adb_close(fd); 378 D("wait_for_state is done"); 379 } 380 381 void connect_emulator(const std::string& port_spec, std::string* response) { 382 std::vector<std::string> pieces = android::base::Split(port_spec, ","); 383 if (pieces.size() != 2) { 384 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>", 385 port_spec.c_str()); 386 return; 387 } 388 389 int console_port = strtol(pieces[0].c_str(), NULL, 0); 390 int adb_port = strtol(pieces[1].c_str(), NULL, 0); 391 if (console_port <= 0 || adb_port <= 0) { 392 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str()); 393 return; 394 } 395 396 // Check if the emulator is already known. 397 // Note: There's a small but harmless race condition here: An emulator not 398 // present just yet could be registered by another invocation right 399 // after doing this check here. However, local_connect protects 400 // against double-registration too. From here, a better error message 401 // can be produced. In the case of the race condition, the very specific 402 // error message won't be shown, but the data doesn't get corrupted. 403 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port); 404 if (known_emulator != nullptr) { 405 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port); 406 return; 407 } 408 409 // Check if more emulators can be registered. Similar unproblematic 410 // race condition as above. 411 int candidate_slot = get_available_local_transport_index(); 412 if (candidate_slot < 0) { 413 *response = "Cannot accept more emulators"; 414 return; 415 } 416 417 // Preconditions met, try to connect to the emulator. 418 std::string error; 419 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) { 420 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d", 421 console_port, adb_port); 422 } else { 423 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s", 424 console_port, adb_port, error.c_str()); 425 } 426 } 427 428 static void connect_service(int fd, void* data) { 429 char* host = reinterpret_cast<char*>(data); 430 std::string response; 431 if (!strncmp(host, "emu:", 4)) { 432 connect_emulator(host + 4, &response); 433 } else { 434 connect_device(host, &response); 435 } 436 free(host); 437 438 // Send response for emulator and device 439 SendProtocolString(fd, response); 440 adb_close(fd); 441 } 442 #endif 443 444 #if ADB_HOST 445 asocket* host_service_to_socket(const char* name, const char* serial, TransportId transport_id) { 446 if (!strcmp(name,"track-devices")) { 447 return create_device_tracker(); 448 } else if (android::base::StartsWith(name, "wait-for-")) { 449 name += strlen("wait-for-"); 450 451 std::unique_ptr<state_info> sinfo(new state_info); 452 if (sinfo == nullptr) { 453 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno)); 454 return nullptr; 455 } 456 457 if (serial) sinfo->serial = serial; 458 sinfo->transport_id = transport_id; 459 460 if (android::base::StartsWith(name, "local")) { 461 name += strlen("local"); 462 sinfo->transport_type = kTransportLocal; 463 } else if (android::base::StartsWith(name, "usb")) { 464 name += strlen("usb"); 465 sinfo->transport_type = kTransportUsb; 466 } else if (android::base::StartsWith(name, "any")) { 467 name += strlen("any"); 468 sinfo->transport_type = kTransportAny; 469 } else { 470 return nullptr; 471 } 472 473 if (!strcmp(name, "-device")) { 474 sinfo->state = kCsDevice; 475 } else if (!strcmp(name, "-recovery")) { 476 sinfo->state = kCsRecovery; 477 } else if (!strcmp(name, "-sideload")) { 478 sinfo->state = kCsSideload; 479 } else if (!strcmp(name, "-bootloader")) { 480 sinfo->state = kCsBootloader; 481 } else if (!strcmp(name, "-any")) { 482 sinfo->state = kCsAny; 483 } else { 484 return nullptr; 485 } 486 487 int fd = create_service_thread("wait", wait_for_state, sinfo.get()); 488 if (fd != -1) { 489 sinfo.release(); 490 } 491 return create_local_socket(fd); 492 } else if (!strncmp(name, "connect:", 8)) { 493 char* host = strdup(name + 8); 494 int fd = create_service_thread("connect", connect_service, host); 495 if (fd == -1) { 496 free(host); 497 } 498 return create_local_socket(fd); 499 } 500 return NULL; 501 } 502 #endif /* ADB_HOST */ 503
