services.cpp revision 1fbc9dbd0f78d755e42a7100a8a24d2ff31c7f6a
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 <android-base/file.h> 35#include <android-base/stringprintf.h> 36#include <android-base/strings.h> 37#include <cutils/sockets.h> 38 39#if !ADB_HOST 40#include "cutils/android_reboot.h" 41#include "cutils/properties.h" 42#endif 43 44#include "adb.h" 45#include "adb_io.h" 46#include "adb_utils.h" 47#include "file_sync_service.h" 48#include "remount_service.h" 49#include "services.h" 50#include "shell_service.h" 51#include "transport.h" 52 53struct stinfo { 54 void (*func)(int fd, void *cookie); 55 int fd; 56 void *cookie; 57}; 58 59void *service_bootstrap_func(void *x) 60{ 61 stinfo* sti = reinterpret_cast<stinfo*>(x); 62 adb_thread_setname(android::base::StringPrintf("service %d", sti->fd)); 63 sti->func(sti->fd, sti->cookie); 64 free(sti); 65 return 0; 66} 67 68#if !ADB_HOST 69 70void restart_root_service(int fd, void *cookie) { 71 if (getuid() == 0) { 72 WriteFdExactly(fd, "adbd is already running as root\n"); 73 adb_close(fd); 74 } else { 75 char value[PROPERTY_VALUE_MAX]; 76 property_get("ro.debuggable", value, ""); 77 if (strcmp(value, "1") != 0) { 78 WriteFdExactly(fd, "adbd cannot run as root in production builds\n"); 79 adb_close(fd); 80 return; 81 } 82 83 property_set("service.adb.root", "1"); 84 WriteFdExactly(fd, "restarting adbd as root\n"); 85 adb_close(fd); 86 } 87} 88 89void restart_unroot_service(int fd, void *cookie) { 90 if (getuid() != 0) { 91 WriteFdExactly(fd, "adbd not running as root\n"); 92 adb_close(fd); 93 } else { 94 property_set("service.adb.root", "0"); 95 WriteFdExactly(fd, "restarting adbd as non root\n"); 96 adb_close(fd); 97 } 98} 99 100void restart_tcp_service(int fd, void *cookie) { 101 int port = (int) (uintptr_t) cookie; 102 if (port <= 0) { 103 WriteFdFmt(fd, "invalid port %d\n", port); 104 adb_close(fd); 105 return; 106 } 107 108 char value[PROPERTY_VALUE_MAX]; 109 snprintf(value, sizeof(value), "%d", port); 110 property_set("service.adb.tcp.port", value); 111 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port); 112 adb_close(fd); 113} 114 115void restart_usb_service(int fd, void *cookie) { 116 property_set("service.adb.tcp.port", "0"); 117 WriteFdExactly(fd, "restarting in USB mode\n"); 118 adb_close(fd); 119} 120 121static bool reboot_service_impl(int fd, const char* arg) { 122 const char* reboot_arg = arg; 123 bool auto_reboot = false; 124 125 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) { 126 auto_reboot = true; 127 reboot_arg = "sideload"; 128 } 129 130 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot" 131 // in the command file. 132 if (strcmp(reboot_arg, "sideload") == 0) { 133 if (getuid() != 0) { 134 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n"); 135 return false; 136 } 137 138 const char* const recovery_dir = "/cache/recovery"; 139 const char* const command_file = "/cache/recovery/command"; 140 // Ensure /cache/recovery exists. 141 if (adb_mkdir(recovery_dir, 0770) == -1 && errno != EEXIST) { 142 D("Failed to create directory '%s': %s", recovery_dir, strerror(errno)); 143 return false; 144 } 145 146 bool write_status = android::base::WriteStringToFile( 147 auto_reboot ? "--sideload_auto_reboot" : "--sideload", command_file); 148 if (!write_status) { 149 return false; 150 } 151 152 reboot_arg = "recovery"; 153 } 154 155 sync(); 156 157 char property_val[PROPERTY_VALUE_MAX]; 158 int ret = snprintf(property_val, sizeof(property_val), "reboot,%s", reboot_arg); 159 if (ret >= static_cast<int>(sizeof(property_val))) { 160 WriteFdFmt(fd, "reboot string too long: %d\n", ret); 161 return false; 162 } 163 164 ret = property_set(ANDROID_RB_PROPERTY, property_val); 165 if (ret < 0) { 166 WriteFdFmt(fd, "reboot failed: %d\n", ret); 167 return false; 168 } 169 170 return true; 171} 172 173void reboot_service(int fd, void* arg) 174{ 175 if (reboot_service_impl(fd, static_cast<const char*>(arg))) { 176 // Don't return early. Give the reboot command time to take effect 177 // to avoid messing up scripts which do "adb reboot && adb wait-for-device" 178 while (true) { 179 pause(); 180 } 181 } 182 183 free(arg); 184 adb_close(fd); 185} 186 187int reverse_service(const char* command) { 188 int s[2]; 189 if (adb_socketpair(s)) { 190 PLOG(ERROR) << "cannot create service socket pair."; 191 return -1; 192 } 193 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1]; 194 if (handle_forward_request(command, kTransportAny, nullptr, s[1]) < 0) { 195 SendFail(s[1], "not a reverse forwarding command"); 196 } 197 adb_close(s[1]); 198 return s[0]; 199} 200 201// Shell service string can look like: 202// shell[,arg1,arg2,...]:[command] 203static int ShellService(const std::string& args, const atransport* transport) { 204 size_t delimiter_index = args.find(':'); 205 if (delimiter_index == std::string::npos) { 206 LOG(ERROR) << "No ':' found in shell service arguments: " << args; 207 return -1; 208 } 209 210 const std::string service_args = args.substr(0, delimiter_index); 211 const std::string command = args.substr(delimiter_index + 1); 212 213 // Defaults: 214 // PTY for interactive, raw for non-interactive. 215 // No protocol. 216 // $TERM set to "dumb". 217 SubprocessType type(command.empty() ? SubprocessType::kPty 218 : SubprocessType::kRaw); 219 SubprocessProtocol protocol = SubprocessProtocol::kNone; 220 std::string terminal_type = "dumb"; 221 222 for (const std::string& arg : android::base::Split(service_args, ",")) { 223 if (arg == kShellServiceArgRaw) { 224 type = SubprocessType::kRaw; 225 } else if (arg == kShellServiceArgPty) { 226 type = SubprocessType::kPty; 227 } else if (arg == kShellServiceArgShellProtocol) { 228 protocol = SubprocessProtocol::kShell; 229 } else if (android::base::StartsWith(arg, "TERM=")) { 230 terminal_type = arg.substr(5); 231 } else if (!arg.empty()) { 232 // This is not an error to allow for future expansion. 233 LOG(WARNING) << "Ignoring unknown shell service argument: " << arg; 234 } 235 } 236 237 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol); 238} 239 240#endif // !ADB_HOST 241 242static int create_service_thread(void (*func)(int, void *), void *cookie) 243{ 244 int s[2]; 245 if (adb_socketpair(s)) { 246 printf("cannot create service socket pair\n"); 247 return -1; 248 } 249 D("socketpair: (%d,%d)", s[0], s[1]); 250 251 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo))); 252 if (sti == nullptr) { 253 fatal("cannot allocate stinfo"); 254 } 255 sti->func = func; 256 sti->cookie = cookie; 257 sti->fd = s[1]; 258 259 if (!adb_thread_create(service_bootstrap_func, sti)) { 260 free(sti); 261 adb_close(s[0]); 262 adb_close(s[1]); 263 printf("cannot create service thread\n"); 264 return -1; 265 } 266 267 D("service thread started, %d:%d",s[0], s[1]); 268 return s[0]; 269} 270 271int service_to_fd(const char* name, const atransport* transport) { 272 int ret = -1; 273 274 if(!strncmp(name, "tcp:", 4)) { 275 int port = atoi(name + 4); 276 name = strchr(name + 4, ':'); 277 if(name == 0) { 278 std::string error; 279 ret = network_loopback_client(port, SOCK_STREAM, &error); 280 if (ret >= 0) 281 disable_tcp_nagle(ret); 282 } else { 283#if ADB_HOST 284 std::string error; 285 ret = network_connect(name + 1, port, SOCK_STREAM, 0, &error); 286#else 287 return -1; 288#endif 289 } 290#if !defined(_WIN32) /* winsock doesn't implement unix domain sockets */ 291 } else if(!strncmp(name, "local:", 6)) { 292 ret = socket_local_client(name + 6, 293 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM); 294 } else if(!strncmp(name, "localreserved:", 14)) { 295 ret = socket_local_client(name + 14, 296 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM); 297 } else if(!strncmp(name, "localabstract:", 14)) { 298 ret = socket_local_client(name + 14, 299 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); 300 } else if(!strncmp(name, "localfilesystem:", 16)) { 301 ret = socket_local_client(name + 16, 302 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM); 303#endif 304#if !ADB_HOST 305 } else if(!strncmp("dev:", name, 4)) { 306 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC); 307 } else if(!strncmp(name, "framebuffer:", 12)) { 308 ret = create_service_thread(framebuffer_service, 0); 309 } else if (!strncmp(name, "jdwp:", 5)) { 310 ret = create_jdwp_connection_fd(atoi(name+5)); 311 } else if(!strncmp(name, "shell", 5)) { 312 ret = ShellService(name + 5, transport); 313 } else if(!strncmp(name, "exec:", 5)) { 314 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); 315 } else if(!strncmp(name, "sync:", 5)) { 316 ret = create_service_thread(file_sync_service, NULL); 317 } else if(!strncmp(name, "remount:", 8)) { 318 ret = create_service_thread(remount_service, NULL); 319 } else if(!strncmp(name, "reboot:", 7)) { 320 void* arg = strdup(name + 7); 321 if (arg == NULL) return -1; 322 ret = create_service_thread(reboot_service, arg); 323 } else if(!strncmp(name, "root:", 5)) { 324 ret = create_service_thread(restart_root_service, NULL); 325 } else if(!strncmp(name, "unroot:", 7)) { 326 ret = create_service_thread(restart_unroot_service, NULL); 327 } else if(!strncmp(name, "backup:", 7)) { 328 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s", 329 (name + 7)).c_str(), 330 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); 331 } else if(!strncmp(name, "restore:", 8)) { 332 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw, 333 SubprocessProtocol::kNone); 334 } else if(!strncmp(name, "tcpip:", 6)) { 335 int port; 336 if (sscanf(name + 6, "%d", &port) != 1) { 337 return -1; 338 } 339 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port); 340 } else if(!strncmp(name, "usb:", 4)) { 341 ret = create_service_thread(restart_usb_service, NULL); 342 } else if (!strncmp(name, "reverse:", 8)) { 343 ret = reverse_service(name + 8); 344 } else if(!strncmp(name, "disable-verity:", 15)) { 345 ret = create_service_thread(set_verity_enabled_state_service, (void*)0); 346 } else if(!strncmp(name, "enable-verity:", 15)) { 347 ret = create_service_thread(set_verity_enabled_state_service, (void*)1); 348#endif 349 } 350 if (ret >= 0) { 351 close_on_exec(ret); 352 } 353 return ret; 354} 355 356#if ADB_HOST 357struct state_info { 358 TransportType transport_type; 359 std::string serial; 360 ConnectionState state; 361}; 362 363static void wait_for_state(int fd, void* data) { 364 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data)); 365 366 D("wait_for_state %d", sinfo->state); 367 368 while (true) { 369 bool is_ambiguous = false; 370 std::string error = "unknown error"; 371 atransport* t = acquire_one_transport(sinfo->transport_type, sinfo->serial.c_str(), 372 &is_ambiguous, &error); 373 if (t != nullptr && t->connection_state == sinfo->state) { 374 SendOkay(fd); 375 break; 376 } else if (!is_ambiguous) { 377 adb_sleep_ms(1000); 378 // Try again... 379 } else { 380 SendFail(fd, error); 381 break; 382 } 383 } 384 385 adb_close(fd); 386 D("wait_for_state is done"); 387} 388 389static void connect_device(const std::string& address, std::string* response) { 390 if (address.empty()) { 391 *response = "empty address"; 392 return; 393 } 394 395 std::string serial; 396 std::string host; 397 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT; 398 if (!parse_host_and_port(address, &serial, &host, &port, response)) { 399 return; 400 } 401 402 std::string error; 403 int fd = network_connect(host.c_str(), port, SOCK_STREAM, 10, &error); 404 if (fd == -1) { 405 *response = android::base::StringPrintf("unable to connect to %s: %s", 406 serial.c_str(), error.c_str()); 407 return; 408 } 409 410 D("client: connected %s remote on fd %d", serial.c_str(), fd); 411 close_on_exec(fd); 412 disable_tcp_nagle(fd); 413 414 int ret = register_socket_transport(fd, serial.c_str(), port, 0); 415 if (ret < 0) { 416 adb_close(fd); 417 *response = android::base::StringPrintf("already connected to %s", serial.c_str()); 418 } else { 419 *response = android::base::StringPrintf("connected to %s", serial.c_str()); 420 } 421} 422 423void connect_emulator(const std::string& port_spec, std::string* response) { 424 std::vector<std::string> pieces = android::base::Split(port_spec, ","); 425 if (pieces.size() != 2) { 426 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>", 427 port_spec.c_str()); 428 return; 429 } 430 431 int console_port = strtol(pieces[0].c_str(), NULL, 0); 432 int adb_port = strtol(pieces[1].c_str(), NULL, 0); 433 if (console_port <= 0 || adb_port <= 0) { 434 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str()); 435 return; 436 } 437 438 // Check if the emulator is already known. 439 // Note: There's a small but harmless race condition here: An emulator not 440 // present just yet could be registered by another invocation right 441 // after doing this check here. However, local_connect protects 442 // against double-registration too. From here, a better error message 443 // can be produced. In the case of the race condition, the very specific 444 // error message won't be shown, but the data doesn't get corrupted. 445 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port); 446 if (known_emulator != nullptr) { 447 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port); 448 return; 449 } 450 451 // Check if more emulators can be registered. Similar unproblematic 452 // race condition as above. 453 int candidate_slot = get_available_local_transport_index(); 454 if (candidate_slot < 0) { 455 *response = "Cannot accept more emulators"; 456 return; 457 } 458 459 // Preconditions met, try to connect to the emulator. 460 std::string error; 461 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) { 462 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d", 463 console_port, adb_port); 464 } else { 465 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s", 466 console_port, adb_port, error.c_str()); 467 } 468} 469 470static void connect_service(int fd, void* data) { 471 char* host = reinterpret_cast<char*>(data); 472 std::string response; 473 if (!strncmp(host, "emu:", 4)) { 474 connect_emulator(host + 4, &response); 475 } else { 476 connect_device(host, &response); 477 } 478 free(host); 479 480 // Send response for emulator and device 481 SendProtocolString(fd, response); 482 adb_close(fd); 483} 484#endif 485 486#if ADB_HOST 487asocket* host_service_to_socket(const char* name, const char* serial) { 488 if (!strcmp(name,"track-devices")) { 489 return create_device_tracker(); 490 } else if (android::base::StartsWith(name, "wait-for-")) { 491 name += strlen("wait-for-"); 492 493 std::unique_ptr<state_info> sinfo(new state_info); 494 if (sinfo == nullptr) { 495 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno)); 496 return nullptr; 497 } 498 499 if (serial) sinfo->serial = serial; 500 501 if (android::base::StartsWith(name, "local")) { 502 name += strlen("local"); 503 sinfo->transport_type = kTransportLocal; 504 } else if (android::base::StartsWith(name, "usb")) { 505 name += strlen("usb"); 506 sinfo->transport_type = kTransportUsb; 507 } else if (android::base::StartsWith(name, "any")) { 508 name += strlen("any"); 509 sinfo->transport_type = kTransportAny; 510 } else { 511 return nullptr; 512 } 513 514 if (!strcmp(name, "-device")) { 515 sinfo->state = kCsDevice; 516 } else if (!strcmp(name, "-recovery")) { 517 sinfo->state = kCsRecovery; 518 } else if (!strcmp(name, "-sideload")) { 519 sinfo->state = kCsSideload; 520 } else if (!strcmp(name, "-bootloader")) { 521 sinfo->state = kCsBootloader; 522 } else { 523 return nullptr; 524 } 525 526 int fd = create_service_thread(wait_for_state, sinfo.release()); 527 return create_local_socket(fd); 528 } else if (!strncmp(name, "connect:", 8)) { 529 char* host = strdup(name + 8); 530 int fd = create_service_thread(connect_service, host); 531 return create_local_socket(fd); 532 } 533 return NULL; 534} 535#endif /* ADB_HOST */ 536