blob: dbf71d36db601ec3c790b7bdc381bc0c117728ad [file] [log] [blame]
The Android Open Source Projectdd7bc332009-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 Cuiaed3c612015-09-22 15:52:57 -070017#define TRACE_TAG SERVICES
Dan Albert33134262015-03-19 15:21:08 -070018
19#include "sysdeps.h"
20
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080021#include <errno.h>
Dan Albert76649012015-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 Gaoe1dacfc2017-04-12 17:00:49 -070034#include <thread>
35
Elliott Hughes4f713192015-12-04 22:00:26 -080036#include <android-base/file.h>
David Pursell706955f2016-01-21 08:40:59 -080037#include <android-base/parsenetaddress.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080038#include <android-base/stringprintf.h>
39#include <android-base/strings.h>
Elliott Hughes381cfa92015-07-23 17:12:58 -070040#include <cutils/sockets.h>
Elliott Hughes6c34bba2015-04-17 20:11:08 -070041
Dan Albert76649012015-02-24 15:51:19 -080042#if !ADB_HOST
Elliott Hughesffdec182016-09-23 15:40:03 -070043#include <android-base/properties.h>
Tao Bao40e0ec92017-01-05 18:01:01 -080044#include <bootloader_message/bootloader_message.h>
Mark Salyzyn97787a02016-03-28 15:52:13 -070045#include <cutils/android_reboot.h>
Steven Morelandd73be1b2017-04-13 23:48:57 -070046#include <log/log_properties.h>
Dan Albert76649012015-02-24 15:51:19 -080047#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080048
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080049#include "adb.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080050#include "adb_io.h"
Elliott Hughes3d5f60d2015-07-18 12:21:30 -070051#include "adb_utils.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080052#include "file_sync_service.h"
Elliott Hughesec7a6672015-03-16 21:58:32 +000053#include "remount_service.h"
David Pursell70ef7b42015-09-30 13:35:42 -070054#include "services.h"
David Pursell80f67022015-08-28 15:08:49 -070055#include "shell_service.h"
Josh Gaocfb21412016-08-24 18:38:44 -070056#include "socket_spec.h"
Josh Gao09855472016-02-19 10:42:40 -080057#include "sysdeps.h"
Dan Albert76649012015-02-24 15:51:19 -080058#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080059
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080060struct stinfo {
61 void (*func)(int fd, void *cookie);
62 int fd;
63 void *cookie;
64};
65
Josh Gaob5fea142016-02-12 14:31:15 -080066static void service_bootstrap_func(void* x) {
Dan Albertbac34742015-02-25 17:51:28 -080067 stinfo* sti = reinterpret_cast<stinfo*>(x);
Siva Velusamy49ee7cf2015-08-28 16:37:29 -070068 adb_thread_setname(android::base::StringPrintf("service %d", sti->fd));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080069 sti->func(sti->fd, sti->cookie);
70 free(sti);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080071}
72
Benoit Goby9470c2f2013-02-20 15:04:53 -080073#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080074
Elliott Hughesab52c182015-05-01 17:04:38 -070075void restart_root_service(int fd, void *cookie) {
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070076 if (getuid() == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070077 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070078 adb_close(fd);
79 } else {
Mark Salyzyn97787a02016-03-28 15:52:13 -070080 if (!__android_log_is_debuggable()) {
Elliott Hughesab52c182015-05-01 17:04:38 -070081 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwoodff196702009-08-24 15:58:40 -070082 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070083 return;
84 }
85
Elliott Hughesffdec182016-09-23 15:40:03 -070086 android::base::SetProperty("service.adb.root", "1");
Elliott Hughesab52c182015-05-01 17:04:38 -070087 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070088 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070089 }
90}
91
Elliott Hughesab52c182015-05-01 17:04:38 -070092void restart_unroot_service(int fd, void *cookie) {
Dan Pasanen98858812014-10-06 12:57:20 -050093 if (getuid() != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070094 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050095 adb_close(fd);
96 } else {
Elliott Hughesffdec182016-09-23 15:40:03 -070097 android::base::SetProperty("service.adb.root", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -070098 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050099 adb_close(fd);
100 }
101}
102
Elliott Hughesab52c182015-05-01 17:04:38 -0700103void restart_tcp_service(int fd, void *cookie) {
Elliott Hughesccecf142014-01-16 10:53:11 -0800104 int port = (int) (uintptr_t) cookie;
Mike Lockwoodff196702009-08-24 15:58:40 -0700105 if (port <= 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700106 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700107 adb_close(fd);
108 return;
109 }
110
Elliott Hughesffdec182016-09-23 15:40:03 -0700111 android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port));
Elliott Hughesab52c182015-05-01 17:04:38 -0700112 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700113 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700114}
115
Elliott Hughesab52c182015-05-01 17:04:38 -0700116void restart_usb_service(int fd, void *cookie) {
Elliott Hughesffdec182016-09-23 15:40:03 -0700117 android::base::SetProperty("service.adb.tcp.port", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -0700118 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwoodff196702009-08-24 15:58:40 -0700119 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700120}
121
Tao Bao175b7bb2015-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 Bao175b7bb2015-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 Hughese67f1f82015-04-30 17:32:03 -0700135 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao175b7bb2015-03-29 11:22:34 -0700136 return false;
137 }
138
Tao Bao40e0ec92017-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 Bao175b7bb2015-03-29 11:22:34 -0700145 return false;
146 }
147
148 reboot_arg = "recovery";
149 }
Mike Lockwoodee156622009-08-04 20:37:51 -0400150
151 sync();
Mike Lockwoodd969faa2010-02-24 16:07:23 -0500152
Elliott Hughesffdec182016-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 Bao175b7bb2015-03-29 11:22:34 -0700156 return false;
Mike Lockwoodee156622009-08-04 20:37:51 -0400157 }
Tao Bao175b7bb2015-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 Hughesa7090b92015-04-17 17:03:59 -0700167 while (true) {
Tao Bao175b7bb2015-03-29 11:22:34 -0700168 pause();
169 }
170 }
171
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400172 free(arg);
Mike Lockwoodee156622009-08-04 20:37:51 -0400173 adb_close(fd);
174}
175
Yabin Cui1f4ec192016-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 Cuifbfa8402015-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' Turner25258692013-03-21 21:07:42 +0100188 }
Yabin Cuifbfa8402015-10-30 18:37:26 -0700189 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1];
Josh Gaob122b172017-08-16 16:57:01 -0700190 if (handle_forward_request(command, kTransportAny, nullptr, 0, s[1]) < 0) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700191 SendFail(s[1], "not a reverse forwarding command");
192 }
193 adb_close(s[1]);
194 return s[0];
David 'Digit' Turner25258692013-03-21 21:07:42 +0100195}
196
David Pursell4e2fd362015-09-22 10:43:08 -0700197// Shell service string can look like:
David Pursell70ef7b42015-09-30 13:35:42 -0700198// shell[,arg1,arg2,...]:[command]
David Pursell4e2fd362015-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 Pursell70ef7b42015-09-30 13:35:42 -0700205
David Pursell4e2fd362015-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 Pursell70ef7b42015-09-30 13:35:42 -0700209 // Defaults:
210 // PTY for interactive, raw for non-interactive.
211 // No protocol.
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800212 // $TERM set to "dumb".
David Pursell70ef7b42015-09-30 13:35:42 -0700213 SubprocessType type(command.empty() ? SubprocessType::kPty
214 : SubprocessType::kRaw);
215 SubprocessProtocol protocol = SubprocessProtocol::kNone;
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800216 std::string terminal_type = "dumb";
David Pursell4e2fd362015-09-22 10:43:08 -0700217
David Pursell70ef7b42015-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 Hughes18ddf5c2015-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 Pursell70ef7b42015-09-30 13:35:42 -0700230 }
231 }
David Pursell4e2fd362015-09-22 10:43:08 -0700232
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800233 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol);
David Pursell4e2fd362015-09-22 10:43:08 -0700234}
235
236#endif // !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800237
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800238static int create_service_thread(void (*func)(int, void *), void *cookie)
239{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800240 int s[2];
Dan Albertbac34742015-02-25 17:51:28 -0800241 if (adb_socketpair(s)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800242 printf("cannot create service socket pair\n");
243 return -1;
244 }
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700245 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800246
Jerry Zhang2f8c60b2017-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 Albertbac34742015-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 Projectdd7bc332009-03-03 19:32:55 -0800260 sti->func = func;
261 sti->cookie = cookie;
262 sti->fd = s[1];
263
Josh Gaoe1dacfc2017-04-12 17:00:49 -0700264 std::thread(service_bootstrap_func, sti).detach();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800265
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700266 D("service thread started, %d:%d",s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800267 return s[0];
268}
269
David Pursell0955c662015-08-31 10:42:13 -0700270int service_to_fd(const char* name, const atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800271 int ret = -1;
272
Josh Gaocfb21412016-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 Projectdd7bc332009-03-03 19:32:55 -0800278 }
Benoit Goby9470c2f2013-02-20 15:04:53 -0800279#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800280 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700281 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800282 } else if(!strncmp(name, "framebuffer:", 12)) {
283 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800284 } else if (!strncmp(name, "jdwp:", 5)) {
285 ret = create_jdwp_connection_fd(atoi(name+5));
David Pursell4e2fd362015-09-22 10:43:08 -0700286 } else if(!strncmp(name, "shell", 5)) {
287 ret = ShellService(name + 5, transport);
Yabin Cui661327e2015-08-11 13:40:42 -0700288 } else if(!strncmp(name, "exec:", 5)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800289 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
The Android Open Source Projectdd7bc332009-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 Lockwoodee156622009-08-04 20:37:51 -0400294 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400295 void* arg = strdup(name + 7);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700296 if (arg == NULL) return -1;
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400297 ret = create_service_thread(reboot_service, arg);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700298 } else if(!strncmp(name, "root:", 5)) {
299 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanen98858812014-10-06 12:57:20 -0500300 } else if(!strncmp(name, "unroot:", 7)) {
301 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tated2f54152011-04-21 12:53:28 -0700302 } else if(!strncmp(name, "backup:", 7)) {
David Pursell80f67022015-08-28 15:08:49 -0700303 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
304 (name + 7)).c_str(),
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800305 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
Elliott Hughesaa245492015-08-03 10:38:08 -0700306 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800307 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
David Pursell0955c662015-08-31 10:42:13 -0700308 SubprocessProtocol::kNone);
Mike Lockwoodff196702009-08-24 15:58:40 -0700309 } else if(!strncmp(name, "tcpip:", 6)) {
310 int port;
Spencer Low943ef232015-01-25 17:38:36 -0800311 if (sscanf(name + 6, "%d", &port) != 1) {
Elliott Hughes19d80b82015-07-21 16:13:40 -0700312 return -1;
Mike Lockwoodff196702009-08-24 15:58:40 -0700313 }
Elliott Hughesccecf142014-01-16 10:53:11 -0800314 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700315 } else if(!strncmp(name, "usb:", 4)) {
316 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner25258692013-03-21 21:07:42 +0100317 } else if (!strncmp(name, "reverse:", 8)) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700318 ret = reverse_service(name + 8);
Paul Lawrenceec900bb2014-10-09 14:22:49 +0000319 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence982089d2014-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 Cui1f4ec192016-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 Projectdd7bc332009-03-03 19:32:55 -0800325#endif
The Android Open Source Projectdd7bc332009-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 Hughes3bd73c12015-05-05 13:10:43 -0700335 TransportType transport_type;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100336 std::string serial;
Josh Gaob122b172017-08-16 16:57:01 -0700337 TransportId transport_id;
Dan Albertdcd78a12015-05-18 16:43:57 -0700338 ConnectionState state;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800339};
340
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100341static void wait_for_state(int fd, void* data) {
342 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800343
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700344 D("wait_for_state %d", sinfo->state);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800345
Elliott Hughes8d28e192015-10-07 14:55:10 -0700346 while (true) {
347 bool is_ambiguous = false;
348 std::string error = "unknown error";
Leo Sartre94e07762016-01-05 12:06:05 +0100349 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL;
Josh Gaob122b172017-08-16 16:57:01 -0700350 atransport* t = acquire_one_transport(sinfo->transport_type, serial, sinfo->transport_id,
351 &is_ambiguous, &error);
Yabin Cuib5e11412017-03-10 16:01:01 -0800352 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->GetConnectionState())) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700353 SendOkay(fd);
354 break;
355 } else if (!is_ambiguous) {
Josh Gao09855472016-02-19 10:42:40 -0800356 adb_pollfd pfd = {.fd = fd, .events = POLLIN };
357 int rc = adb_poll(&pfd, 1, 1000);
358 if (rc < 0) {
359 SendFail(fd, error);
360 break;
361 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) {
362 // The other end of the socket is closed, probably because the other side was
363 // terminated, bail out.
364 break;
365 }
366
Elliott Hughes8d28e192015-10-07 14:55:10 -0700367 // Try again...
368 } else {
369 SendFail(fd, error);
370 break;
371 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800372 }
373
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800374 adb_close(fd);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700375 D("wait_for_state is done");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800376}
Benoit Goby1c45ee92013-03-29 18:22:36 -0700377
Elliott Hughese67f1f82015-04-30 17:32:03 -0700378void connect_emulator(const std::string& port_spec, std::string* response) {
379 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
380 if (pieces.size() != 2) {
381 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
382 port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700383 return;
384 }
385
Elliott Hughese67f1f82015-04-30 17:32:03 -0700386 int console_port = strtol(pieces[0].c_str(), NULL, 0);
387 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
388 if (console_port <= 0 || adb_port <= 0) {
389 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700390 return;
391 }
392
Elliott Hughese67f1f82015-04-30 17:32:03 -0700393 // Check if the emulator is already known.
394 // Note: There's a small but harmless race condition here: An emulator not
395 // present just yet could be registered by another invocation right
396 // after doing this check here. However, local_connect protects
397 // against double-registration too. From here, a better error message
398 // can be produced. In the case of the race condition, the very specific
399 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700400 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700401 if (known_emulator != nullptr) {
402 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700403 return;
404 }
405
Elliott Hughese67f1f82015-04-30 17:32:03 -0700406 // Check if more emulators can be registered. Similar unproblematic
407 // race condition as above.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700408 int candidate_slot = get_available_local_transport_index();
409 if (candidate_slot < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700410 *response = "Cannot accept more emulators";
Benoit Goby1c45ee92013-03-29 18:22:36 -0700411 return;
412 }
413
Elliott Hughese67f1f82015-04-30 17:32:03 -0700414 // Preconditions met, try to connect to the emulator.
Elliott Hughes381cfa92015-07-23 17:12:58 -0700415 std::string error;
416 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700417 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
418 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700419 } else {
Elliott Hughes381cfa92015-07-23 17:12:58 -0700420 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s",
421 console_port, adb_port, error.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700422 }
423}
424
Alan Jeon4af3c402014-10-16 17:05:25 +0900425static void connect_service(int fd, void* data) {
426 char* host = reinterpret_cast<char*>(data);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700427 std::string response;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700428 if (!strncmp(host, "emu:", 4)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700429 connect_emulator(host + 4, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700430 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700431 connect_device(host, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700432 }
Alan Jeon4af3c402014-10-16 17:05:25 +0900433 free(host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700434
435 // Send response for emulator and device
Elliott Hughese67f1f82015-04-30 17:32:03 -0700436 SendProtocolString(fd, response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700437 adb_close(fd);
438}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800439#endif
440
441#if ADB_HOST
Josh Gaob122b172017-08-16 16:57:01 -0700442asocket* host_service_to_socket(const char* name, const char* serial, TransportId transport_id) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800443 if (!strcmp(name,"track-devices")) {
Josh Gaob0c18022017-08-14 18:57:54 -0700444 return create_device_tracker(false);
445 } else if (!strcmp(name, "track-devices-l")) {
446 return create_device_tracker(true);
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100447 } else if (android::base::StartsWith(name, "wait-for-")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800448 name += strlen("wait-for-");
449
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100450 std::unique_ptr<state_info> sinfo(new state_info);
451 if (sinfo == nullptr) {
452 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
453 return nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800454 }
455
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100456 if (serial) sinfo->serial = serial;
Josh Gaob122b172017-08-16 16:57:01 -0700457 sinfo->transport_id = transport_id;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100458
459 if (android::base::StartsWith(name, "local")) {
460 name += strlen("local");
461 sinfo->transport_type = kTransportLocal;
462 } else if (android::base::StartsWith(name, "usb")) {
463 name += strlen("usb");
464 sinfo->transport_type = kTransportUsb;
465 } else if (android::base::StartsWith(name, "any")) {
466 name += strlen("any");
467 sinfo->transport_type = kTransportAny;
468 } else {
469 return nullptr;
470 }
471
472 if (!strcmp(name, "-device")) {
473 sinfo->state = kCsDevice;
474 } else if (!strcmp(name, "-recovery")) {
475 sinfo->state = kCsRecovery;
476 } else if (!strcmp(name, "-sideload")) {
477 sinfo->state = kCsSideload;
478 } else if (!strcmp(name, "-bootloader")) {
479 sinfo->state = kCsBootloader;
Josh Gao86441c32016-04-13 12:18:58 -0700480 } else if (!strcmp(name, "-any")) {
481 sinfo->state = kCsAny;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100482 } else {
483 return nullptr;
484 }
485
Ting-Yuan Huangf26cf6d2017-08-15 15:07:21 -0700486 int fd = create_service_thread(wait_for_state, sinfo.get());
487 if (fd != -1) {
488 sinfo.release();
489 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800490 return create_local_socket(fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700491 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeon4af3c402014-10-16 17:05:25 +0900492 char* host = strdup(name + 8);
493 int fd = create_service_thread(connect_service, host);
Ting-Yuan Huangf26cf6d2017-08-15 15:07:21 -0700494 if (fd == -1) {
495 free(host);
496 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700497 return create_local_socket(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800498 }
499 return NULL;
500}
501#endif /* ADB_HOST */