blob: 9605e6ec07b9d0ecd61f44f8e8da1e416f1a1594 [file] [log] [blame]
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Yabin Cui19bec5b2015-09-22 15:52:57 -070017#define TRACE_TAG SERVICES
Dan Albertdb6fe642015-03-19 15:21:08 -070018
19#include "sysdeps.h"
20
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080021#include <errno.h>
Dan Albertb302d122015-02-24 15:51:19 -080022#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
Josh Gao0f3312a2017-04-12 17:00:49 -070034#include <thread>
35
Elliott Hughesf55ead92015-12-04 22:00:26 -080036#include <android-base/file.h>
David Pursella17d2722016-01-21 08:40:59 -080037#include <android-base/parsenetaddress.h>
Elliott Hughesf55ead92015-12-04 22:00:26 -080038#include <android-base/stringprintf.h>
39#include <android-base/strings.h>
Elliott Hughes43df1092015-07-23 17:12:58 -070040#include <cutils/sockets.h>
Elliott Hughese4b64792015-04-17 20:11:08 -070041
Dan Albertb302d122015-02-24 15:51:19 -080042#if !ADB_HOST
Elliott Hughes8b249d22016-09-23 15:40:03 -070043#include <android-base/properties.h>
Tao Baoa8c21dc2017-01-05 18:01:01 -080044#include <bootloader_message/bootloader_message.h>
Mark Salyzync75f65f2016-03-28 15:52:13 -070045#include <cutils/android_reboot.h>
Steven Morelandb087d302017-04-13 23:48:57 -070046#include <log/log_properties.h>
Dan Albertb302d122015-02-24 15:51:19 -080047#endif
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080048
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080049#include "adb.h"
Dan Albert66a91b02015-02-24 21:26:58 -080050#include "adb_io.h"
Elliott Hughes09ccf1f2015-07-18 12:21:30 -070051#include "adb_utils.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080052#include "file_sync_service.h"
Elliott Hughesdedf7672015-03-16 21:58:32 +000053#include "remount_service.h"
David Pursell22fc5e92015-09-30 13:35:42 -070054#include "services.h"
David Pursell4f344bb2015-08-28 15:08:49 -070055#include "shell_service.h"
Josh Gao4a5a95d2016-08-24 18:38:44 -070056#include "socket_spec.h"
Josh Gaoc1fab362016-02-19 10:42:40 -080057#include "sysdeps.h"
Dan Albertb302d122015-02-24 15:51:19 -080058#include "transport.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080059
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080060struct stinfo {
61 void (*func)(int fd, void *cookie);
62 int fd;
63 void *cookie;
64};
65
Josh Gao7d405252016-02-12 14:31:15 -080066static void service_bootstrap_func(void* x) {
Dan Albertf30d73c2015-02-25 17:51:28 -080067 stinfo* sti = reinterpret_cast<stinfo*>(x);
Siva Velusamy2669cf92015-08-28 16:37:29 -070068 adb_thread_setname(android::base::StringPrintf("service %d", sti->fd));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080069 sti->func(sti->fd, sti->cookie);
70 free(sti);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080071}
72
Benoit Goby12dc3692013-02-20 15:04:53 -080073#if !ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080074
Elliott Hughesfb596842015-05-01 17:04:38 -070075void restart_root_service(int fd, void *cookie) {
The Android Open Source Project9c753402009-03-13 13:04:37 -070076 if (getuid() == 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -070077 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Project9c753402009-03-13 13:04:37 -070078 adb_close(fd);
79 } else {
Mark Salyzync75f65f2016-03-28 15:52:13 -070080 if (!__android_log_is_debuggable()) {
Elliott Hughesfb596842015-05-01 17:04:38 -070081 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwood26b88e32009-08-24 15:58:40 -070082 adb_close(fd);
The Android Open Source Project9c753402009-03-13 13:04:37 -070083 return;
84 }
85
Elliott Hughes8b249d22016-09-23 15:40:03 -070086 android::base::SetProperty("service.adb.root", "1");
Elliott Hughesfb596842015-05-01 17:04:38 -070087 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Project9c753402009-03-13 13:04:37 -070088 adb_close(fd);
The Android Open Source Project9c753402009-03-13 13:04:37 -070089 }
90}
91
Elliott Hughesfb596842015-05-01 17:04:38 -070092void restart_unroot_service(int fd, void *cookie) {
Dan Pasanenfb787d92014-10-06 12:57:20 -050093 if (getuid() != 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -070094 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanenfb787d92014-10-06 12:57:20 -050095 adb_close(fd);
96 } else {
Elliott Hughes8b249d22016-09-23 15:40:03 -070097 android::base::SetProperty("service.adb.root", "0");
Elliott Hughesfb596842015-05-01 17:04:38 -070098 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanenfb787d92014-10-06 12:57:20 -050099 adb_close(fd);
100 }
101}
102
Elliott Hughesfb596842015-05-01 17:04:38 -0700103void restart_tcp_service(int fd, void *cookie) {
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800104 int port = (int) (uintptr_t) cookie;
Mike Lockwood26b88e32009-08-24 15:58:40 -0700105 if (port <= 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -0700106 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700107 adb_close(fd);
108 return;
109 }
110
Elliott Hughes8b249d22016-09-23 15:40:03 -0700111 android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port));
Elliott Hughesfb596842015-05-01 17:04:38 -0700112 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700113 adb_close(fd);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700114}
115
Elliott Hughesfb596842015-05-01 17:04:38 -0700116void restart_usb_service(int fd, void *cookie) {
Elliott Hughes8b249d22016-09-23 15:40:03 -0700117 android::base::SetProperty("service.adb.tcp.port", "0");
Elliott Hughesfb596842015-05-01 17:04:38 -0700118 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwood26b88e32009-08-24 15:58:40 -0700119 adb_close(fd);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700120}
121
Tao Bao0db67642015-03-29 11:22:34 -0700122static bool reboot_service_impl(int fd, const char* arg) {
123 const char* reboot_arg = arg;
124 bool auto_reboot = false;
125
126 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) {
127 auto_reboot = true;
128 reboot_arg = "sideload";
129 }
130
Tao Bao0db67642015-03-29 11:22:34 -0700131 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot"
132 // in the command file.
133 if (strcmp(reboot_arg, "sideload") == 0) {
134 if (getuid() != 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700135 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao0db67642015-03-29 11:22:34 -0700136 return false;
137 }
138
Tao Baoa8c21dc2017-01-05 18:01:01 -0800139 const std::vector<std::string> options = {
140 auto_reboot ? "--sideload_auto_reboot" : "--sideload"
141 };
142 std::string err;
143 if (!write_bootloader_message(options, &err)) {
144 D("Failed to set bootloader message: %s", err.c_str());
Tao Bao0db67642015-03-29 11:22:34 -0700145 return false;
146 }
147
148 reboot_arg = "recovery";
149 }
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400150
151 sync();
Mike Lockwoodd49e9eb2010-02-24 16:07:23 -0500152
Elliott Hughes8b249d22016-09-23 15:40:03 -0700153 std::string reboot_string = android::base::StringPrintf("reboot,%s", reboot_arg);
154 if (!android::base::SetProperty(ANDROID_RB_PROPERTY, reboot_string)) {
155 WriteFdFmt(fd, "reboot (%s) failed\n", reboot_string.c_str());
Tao Bao0db67642015-03-29 11:22:34 -0700156 return false;
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400157 }
Tao Bao0db67642015-03-29 11:22:34 -0700158
159 return true;
160}
161
162void reboot_service(int fd, void* arg)
163{
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"
Elliott Hughes7cf35752015-04-17 17:03:59 -0700167 while (true) {
Tao Bao0db67642015-03-29 11:22:34 -0700168 pause();
169 }
170 }
171
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400172 free(arg);
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400173 adb_close(fd);
174}
175
Yabin Cuid78ed222016-04-05 13:50:44 -0700176static 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
Yabin Cuidf852632015-10-30 18:37:26 -0700183int 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;
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100188 }
Yabin Cuidf852632015-10-30 18:37:26 -0700189 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1];
190 if (handle_forward_request(command, kTransportAny, nullptr, s[1]) < 0) {
191 SendFail(s[1], "not a reverse forwarding command");
192 }
193 adb_close(s[1]);
194 return s[0];
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100195}
196
David Pursella07dbad2015-09-22 10:43:08 -0700197// Shell service string can look like:
David Pursell22fc5e92015-09-30 13:35:42 -0700198// shell[,arg1,arg2,...]:[command]
David Pursella07dbad2015-09-22 10:43:08 -0700199static 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 }
David Pursell22fc5e92015-09-30 13:35:42 -0700205
David Pursella07dbad2015-09-22 10:43:08 -0700206 const std::string service_args = args.substr(0, delimiter_index);
207 const std::string command = args.substr(delimiter_index + 1);
208
David Pursell22fc5e92015-09-30 13:35:42 -0700209 // Defaults:
210 // PTY for interactive, raw for non-interactive.
211 // No protocol.
Elliott Hughesff444562015-11-16 10:55:34 -0800212 // $TERM set to "dumb".
David Pursell22fc5e92015-09-30 13:35:42 -0700213 SubprocessType type(command.empty() ? SubprocessType::kPty
214 : SubprocessType::kRaw);
215 SubprocessProtocol protocol = SubprocessProtocol::kNone;
Elliott Hughesff444562015-11-16 10:55:34 -0800216 std::string terminal_type = "dumb";
David Pursella07dbad2015-09-22 10:43:08 -0700217
David Pursell22fc5e92015-09-30 13:35:42 -0700218 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;
Elliott Hughesff444562015-11-16 10:55:34 -0800225 } 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;
David Pursell22fc5e92015-09-30 13:35:42 -0700230 }
231 }
David Pursella07dbad2015-09-22 10:43:08 -0700232
Elliott Hughesff444562015-11-16 10:55:34 -0800233 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol);
David Pursella07dbad2015-09-22 10:43:08 -0700234}
235
236#endif // !ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800237
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800238static int create_service_thread(void (*func)(int, void *), void *cookie)
239{
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800240 int s[2];
Dan Albertf30d73c2015-02-25 17:51:28 -0800241 if (adb_socketpair(s)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800242 printf("cannot create service socket pair\n");
243 return -1;
244 }
Yabin Cui815ad882015-09-02 17:44:28 -0700245 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800246
Jerry Zhangf0e239c2017-02-10 17:45:27 -0800247#if !ADB_HOST
248 if (func == &file_sync_service) {
249 // Set file sync service socket to maximum size
250 int max_buf = LINUX_MAX_SOCKET_SIZE;
251 adb_setsockopt(s[0], SOL_SOCKET, SO_SNDBUF, &max_buf, sizeof(max_buf));
252 adb_setsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &max_buf, sizeof(max_buf));
253 }
254#endif // !ADB_HOST
255
Dan Albertf30d73c2015-02-25 17:51:28 -0800256 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
257 if (sti == nullptr) {
258 fatal("cannot allocate stinfo");
259 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800260 sti->func = func;
261 sti->cookie = cookie;
262 sti->fd = s[1];
263
Josh Gao0f3312a2017-04-12 17:00:49 -0700264 std::thread(service_bootstrap_func, sti).detach();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800265
Yabin Cui815ad882015-09-02 17:44:28 -0700266 D("service thread started, %d:%d",s[0], s[1]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800267 return s[0];
268}
269
David Pursell8da19a42015-08-31 10:42:13 -0700270int service_to_fd(const char* name, const atransport* transport) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800271 int ret = -1;
272
Josh Gao4a5a95d2016-08-24 18:38:44 -0700273 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;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800278 }
Benoit Goby12dc3692013-02-20 15:04:53 -0800279#if !ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800280 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevich777523e2014-07-18 20:57:35 -0700281 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800282 } else if(!strncmp(name, "framebuffer:", 12)) {
283 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800284 } else if (!strncmp(name, "jdwp:", 5)) {
285 ret = create_jdwp_connection_fd(atoi(name+5));
David Pursella07dbad2015-09-22 10:43:08 -0700286 } else if(!strncmp(name, "shell", 5)) {
287 ret = ShellService(name + 5, transport);
Yabin Cui5fe6d0d2015-08-11 13:40:42 -0700288 } else if(!strncmp(name, "exec:", 5)) {
Elliott Hughesff444562015-11-16 10:55:34 -0800289 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800290 } else if(!strncmp(name, "sync:", 5)) {
291 ret = create_service_thread(file_sync_service, NULL);
292 } else if(!strncmp(name, "remount:", 8)) {
293 ret = create_service_thread(remount_service, NULL);
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400294 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400295 void* arg = strdup(name + 7);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700296 if (arg == NULL) return -1;
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400297 ret = create_service_thread(reboot_service, arg);
The Android Open Source Project9c753402009-03-13 13:04:37 -0700298 } else if(!strncmp(name, "root:", 5)) {
299 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanenfb787d92014-10-06 12:57:20 -0500300 } else if(!strncmp(name, "unroot:", 7)) {
301 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tate73779122011-04-21 12:53:28 -0700302 } else if(!strncmp(name, "backup:", 7)) {
David Pursell4f344bb2015-08-28 15:08:49 -0700303 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
304 (name + 7)).c_str(),
Elliott Hughesff444562015-11-16 10:55:34 -0800305 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
Elliott Hughesb628cb12015-08-03 10:38:08 -0700306 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughesff444562015-11-16 10:55:34 -0800307 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
David Pursell8da19a42015-08-31 10:42:13 -0700308 SubprocessProtocol::kNone);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700309 } else if(!strncmp(name, "tcpip:", 6)) {
310 int port;
Spencer Low29a029c2015-01-25 17:38:36 -0800311 if (sscanf(name + 6, "%d", &port) != 1) {
Elliott Hughesd94e8ba2015-07-21 16:13:40 -0700312 return -1;
Mike Lockwood26b88e32009-08-24 15:58:40 -0700313 }
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800314 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700315 } else if(!strncmp(name, "usb:", 4)) {
316 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100317 } else if (!strncmp(name, "reverse:", 8)) {
Yabin Cuidf852632015-10-30 18:37:26 -0700318 ret = reverse_service(name + 8);
Paul Lawrence5f356482014-10-09 14:22:49 +0000319 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence8ba2b022014-12-03 15:31:57 -0800320 ret = create_service_thread(set_verity_enabled_state_service, (void*)0);
321 } else if(!strncmp(name, "enable-verity:", 15)) {
322 ret = create_service_thread(set_verity_enabled_state_service, (void*)1);
Yabin Cuid78ed222016-04-05 13:50:44 -0700323 } else if (!strcmp(name, "reconnect")) {
324 ret = create_service_thread(reconnect_service, const_cast<atransport*>(transport));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800325#endif
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800326 }
327 if (ret >= 0) {
328 close_on_exec(ret);
329 }
330 return ret;
331}
332
333#if ADB_HOST
334struct state_info {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700335 TransportType transport_type;
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100336 std::string serial;
Dan Albert9a50f4c2015-05-18 16:43:57 -0700337 ConnectionState state;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800338};
339
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100340static void wait_for_state(int fd, void* data) {
341 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800342
Yabin Cui815ad882015-09-02 17:44:28 -0700343 D("wait_for_state %d", sinfo->state);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800344
Elliott Hughes67943d12015-10-07 14:55:10 -0700345 while (true) {
346 bool is_ambiguous = false;
347 std::string error = "unknown error";
Leo Sartre66831322016-01-05 12:06:05 +0100348 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL;
349 atransport* t = acquire_one_transport(sinfo->transport_type, serial, &is_ambiguous, &error);
Yabin Cui3cf1b362017-03-10 16:01:01 -0800350 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->GetConnectionState())) {
Elliott Hughes67943d12015-10-07 14:55:10 -0700351 SendOkay(fd);
352 break;
353 } else if (!is_ambiguous) {
Josh Gaoc1fab362016-02-19 10:42:40 -0800354 adb_pollfd pfd = {.fd = fd, .events = POLLIN };
355 int rc = adb_poll(&pfd, 1, 1000);
356 if (rc < 0) {
357 SendFail(fd, error);
358 break;
359 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) {
360 // The other end of the socket is closed, probably because the other side was
361 // terminated, bail out.
362 break;
363 }
364
Elliott Hughes67943d12015-10-07 14:55:10 -0700365 // Try again...
366 } else {
367 SendFail(fd, error);
368 break;
369 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800370 }
371
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800372 adb_close(fd);
Yabin Cui815ad882015-09-02 17:44:28 -0700373 D("wait_for_state is done");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800374}
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700375
Elliott Hughes88b4c852015-04-30 17:32:03 -0700376void connect_emulator(const std::string& port_spec, std::string* response) {
377 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
378 if (pieces.size() != 2) {
379 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
380 port_spec.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700381 return;
382 }
383
Elliott Hughes88b4c852015-04-30 17:32:03 -0700384 int console_port = strtol(pieces[0].c_str(), NULL, 0);
385 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
386 if (console_port <= 0 || adb_port <= 0) {
387 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700388 return;
389 }
390
Elliott Hughes88b4c852015-04-30 17:32:03 -0700391 // Check if the emulator is already known.
392 // Note: There's a small but harmless race condition here: An emulator not
393 // present just yet could be registered by another invocation right
394 // after doing this check here. However, local_connect protects
395 // against double-registration too. From here, a better error message
396 // can be produced. In the case of the race condition, the very specific
397 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700398 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700399 if (known_emulator != nullptr) {
400 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700401 return;
402 }
403
Elliott Hughes88b4c852015-04-30 17:32:03 -0700404 // Check if more emulators can be registered. Similar unproblematic
405 // race condition as above.
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700406 int candidate_slot = get_available_local_transport_index();
407 if (candidate_slot < 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700408 *response = "Cannot accept more emulators";
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700409 return;
410 }
411
Elliott Hughes88b4c852015-04-30 17:32:03 -0700412 // Preconditions met, try to connect to the emulator.
Elliott Hughes43df1092015-07-23 17:12:58 -0700413 std::string error;
414 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700415 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
416 console_port, adb_port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700417 } else {
Elliott Hughes43df1092015-07-23 17:12:58 -0700418 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s",
419 console_port, adb_port, error.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700420 }
421}
422
Alan Jeone6959b72014-10-16 17:05:25 +0900423static void connect_service(int fd, void* data) {
424 char* host = reinterpret_cast<char*>(data);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700425 std::string response;
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700426 if (!strncmp(host, "emu:", 4)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700427 connect_emulator(host + 4, &response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700428 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700429 connect_device(host, &response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700430 }
Alan Jeone6959b72014-10-16 17:05:25 +0900431 free(host);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700432
433 // Send response for emulator and device
Elliott Hughes88b4c852015-04-30 17:32:03 -0700434 SendProtocolString(fd, response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700435 adb_close(fd);
436}
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800437#endif
438
439#if ADB_HOST
Elliott Hughesb628cb12015-08-03 10:38:08 -0700440asocket* host_service_to_socket(const char* name, const char* serial) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800441 if (!strcmp(name,"track-devices")) {
442 return create_device_tracker();
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100443 } else if (android::base::StartsWith(name, "wait-for-")) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800444 name += strlen("wait-for-");
445
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100446 std::unique_ptr<state_info> sinfo(new state_info);
447 if (sinfo == nullptr) {
448 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
449 return nullptr;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800450 }
451
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100452 if (serial) sinfo->serial = serial;
453
454 if (android::base::StartsWith(name, "local")) {
455 name += strlen("local");
456 sinfo->transport_type = kTransportLocal;
457 } else if (android::base::StartsWith(name, "usb")) {
458 name += strlen("usb");
459 sinfo->transport_type = kTransportUsb;
460 } else if (android::base::StartsWith(name, "any")) {
461 name += strlen("any");
462 sinfo->transport_type = kTransportAny;
463 } else {
464 return nullptr;
465 }
466
467 if (!strcmp(name, "-device")) {
468 sinfo->state = kCsDevice;
469 } else if (!strcmp(name, "-recovery")) {
470 sinfo->state = kCsRecovery;
471 } else if (!strcmp(name, "-sideload")) {
472 sinfo->state = kCsSideload;
473 } else if (!strcmp(name, "-bootloader")) {
474 sinfo->state = kCsBootloader;
Josh Gao071328d2016-04-13 12:18:58 -0700475 } else if (!strcmp(name, "-any")) {
476 sinfo->state = kCsAny;
Leo Sartre6cd9bc32015-11-27 18:56:48 +0100477 } else {
478 return nullptr;
479 }
480
481 int fd = create_service_thread(wait_for_state, sinfo.release());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800482 return create_local_socket(fd);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700483 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeone6959b72014-10-16 17:05:25 +0900484 char* host = strdup(name + 8);
485 int fd = create_service_thread(connect_service, host);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700486 return create_local_socket(fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800487 }
488 return NULL;
489}
490#endif /* ADB_HOST */