blob: aff7012ee125b0a4286ad9f10792227544bc09e1 [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 {
Josh Gaobcadc772017-09-28 16:29:53 -070061 const char* service_name;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080062 void (*func)(int fd, void *cookie);
63 int fd;
64 void *cookie;
65};
66
Josh Gaob5fea142016-02-12 14:31:15 -080067static void service_bootstrap_func(void* x) {
Dan Albertbac34742015-02-25 17:51:28 -080068 stinfo* sti = reinterpret_cast<stinfo*>(x);
Josh Gaobcadc772017-09-28 16:29:53 -070069 adb_thread_setname(android::base::StringPrintf("%s svc %d", sti->service_name, sti->fd));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080070 sti->func(sti->fd, sti->cookie);
71 free(sti);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080072}
73
Benoit Goby9470c2f2013-02-20 15:04:53 -080074#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080075
Elliott Hughesab52c182015-05-01 17:04:38 -070076void restart_root_service(int fd, void *cookie) {
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070077 if (getuid() == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070078 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070079 adb_close(fd);
80 } else {
Mark Salyzyn97787a02016-03-28 15:52:13 -070081 if (!__android_log_is_debuggable()) {
Elliott Hughesab52c182015-05-01 17:04:38 -070082 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwoodff196702009-08-24 15:58:40 -070083 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070084 return;
85 }
86
Elliott Hughesffdec182016-09-23 15:40:03 -070087 android::base::SetProperty("service.adb.root", "1");
Elliott Hughesab52c182015-05-01 17:04:38 -070088 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070089 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070090 }
91}
92
Elliott Hughesab52c182015-05-01 17:04:38 -070093void restart_unroot_service(int fd, void *cookie) {
Dan Pasanen98858812014-10-06 12:57:20 -050094 if (getuid() != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070095 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050096 adb_close(fd);
97 } else {
Elliott Hughesffdec182016-09-23 15:40:03 -070098 android::base::SetProperty("service.adb.root", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -070099 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanen98858812014-10-06 12:57:20 -0500100 adb_close(fd);
101 }
102}
103
Elliott Hughesab52c182015-05-01 17:04:38 -0700104void restart_tcp_service(int fd, void *cookie) {
Elliott Hughesccecf142014-01-16 10:53:11 -0800105 int port = (int) (uintptr_t) cookie;
Mike Lockwoodff196702009-08-24 15:58:40 -0700106 if (port <= 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700107 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700108 adb_close(fd);
109 return;
110 }
111
Elliott Hughesffdec182016-09-23 15:40:03 -0700112 android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port));
Elliott Hughesab52c182015-05-01 17:04:38 -0700113 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700114 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700115}
116
Elliott Hughesab52c182015-05-01 17:04:38 -0700117void restart_usb_service(int fd, void *cookie) {
Elliott Hughesffdec182016-09-23 15:40:03 -0700118 android::base::SetProperty("service.adb.tcp.port", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -0700119 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwoodff196702009-08-24 15:58:40 -0700120 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700121}
122
Tao Bao175b7bb2015-03-29 11:22:34 -0700123static 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
Tao Bao175b7bb2015-03-29 11:22:34 -0700132 // 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) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700136 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao175b7bb2015-03-29 11:22:34 -0700137 return false;
138 }
139
Tao Bao40e0ec92017-01-05 18:01:01 -0800140 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());
Tao Bao175b7bb2015-03-29 11:22:34 -0700146 return false;
147 }
148
149 reboot_arg = "recovery";
150 }
Mike Lockwoodee156622009-08-04 20:37:51 -0400151
152 sync();
Mike Lockwoodd969faa2010-02-24 16:07:23 -0500153
Mark Salyzyn277eca12017-09-11 15:22:57 -0700154 if (!reboot_arg || !reboot_arg[0]) reboot_arg = "adb";
Elliott Hughesffdec182016-09-23 15:40:03 -0700155 std::string reboot_string = android::base::StringPrintf("reboot,%s", reboot_arg);
156 if (!android::base::SetProperty(ANDROID_RB_PROPERTY, reboot_string)) {
157 WriteFdFmt(fd, "reboot (%s) failed\n", reboot_string.c_str());
Tao Bao175b7bb2015-03-29 11:22:34 -0700158 return false;
Mike Lockwoodee156622009-08-04 20:37:51 -0400159 }
Tao Bao175b7bb2015-03-29 11:22:34 -0700160
161 return true;
162}
163
Josh Gaobcadc772017-09-28 16:29:53 -0700164void reboot_service(int fd, void* arg) {
Tao Bao175b7bb2015-03-29 11:22:34 -0700165 if (reboot_service_impl(fd, static_cast<const char*>(arg))) {
166 // Don't return early. Give the reboot command time to take effect
167 // to avoid messing up scripts which do "adb reboot && adb wait-for-device"
Elliott Hughesa7090b92015-04-17 17:03:59 -0700168 while (true) {
Tao Bao175b7bb2015-03-29 11:22:34 -0700169 pause();
170 }
171 }
172
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400173 free(arg);
Mike Lockwoodee156622009-08-04 20:37:51 -0400174 adb_close(fd);
175}
176
Yabin Cui1f4ec192016-04-05 13:50:44 -0700177static void reconnect_service(int fd, void* arg) {
178 WriteFdExactly(fd, "done");
179 adb_close(fd);
180 atransport* t = static_cast<atransport*>(arg);
181 kick_transport(t);
182}
183
Yabin Cuifbfa8402015-10-30 18:37:26 -0700184int reverse_service(const char* command) {
185 int s[2];
186 if (adb_socketpair(s)) {
187 PLOG(ERROR) << "cannot create service socket pair.";
188 return -1;
David 'Digit' Turner25258692013-03-21 21:07:42 +0100189 }
Yabin Cuifbfa8402015-10-30 18:37:26 -0700190 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1];
Josh Gaob122b172017-08-16 16:57:01 -0700191 if (handle_forward_request(command, kTransportAny, nullptr, 0, s[1]) < 0) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700192 SendFail(s[1], "not a reverse forwarding command");
193 }
194 adb_close(s[1]);
195 return s[0];
David 'Digit' Turner25258692013-03-21 21:07:42 +0100196}
197
David Pursell4e2fd362015-09-22 10:43:08 -0700198// Shell service string can look like:
David Pursell70ef7b42015-09-30 13:35:42 -0700199// shell[,arg1,arg2,...]:[command]
David Pursell4e2fd362015-09-22 10:43:08 -0700200static int ShellService(const std::string& args, const atransport* transport) {
201 size_t delimiter_index = args.find(':');
202 if (delimiter_index == std::string::npos) {
203 LOG(ERROR) << "No ':' found in shell service arguments: " << args;
204 return -1;
205 }
David Pursell70ef7b42015-09-30 13:35:42 -0700206
David Pursell4e2fd362015-09-22 10:43:08 -0700207 const std::string service_args = args.substr(0, delimiter_index);
208 const std::string command = args.substr(delimiter_index + 1);
209
David Pursell70ef7b42015-09-30 13:35:42 -0700210 // Defaults:
211 // PTY for interactive, raw for non-interactive.
212 // No protocol.
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800213 // $TERM set to "dumb".
David Pursell70ef7b42015-09-30 13:35:42 -0700214 SubprocessType type(command.empty() ? SubprocessType::kPty
215 : SubprocessType::kRaw);
216 SubprocessProtocol protocol = SubprocessProtocol::kNone;
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800217 std::string terminal_type = "dumb";
David Pursell4e2fd362015-09-22 10:43:08 -0700218
David Pursell70ef7b42015-09-30 13:35:42 -0700219 for (const std::string& arg : android::base::Split(service_args, ",")) {
220 if (arg == kShellServiceArgRaw) {
221 type = SubprocessType::kRaw;
222 } else if (arg == kShellServiceArgPty) {
223 type = SubprocessType::kPty;
224 } else if (arg == kShellServiceArgShellProtocol) {
225 protocol = SubprocessProtocol::kShell;
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800226 } else if (android::base::StartsWith(arg, "TERM=")) {
227 terminal_type = arg.substr(5);
228 } else if (!arg.empty()) {
229 // This is not an error to allow for future expansion.
230 LOG(WARNING) << "Ignoring unknown shell service argument: " << arg;
David Pursell70ef7b42015-09-30 13:35:42 -0700231 }
232 }
David Pursell4e2fd362015-09-22 10:43:08 -0700233
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800234 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol);
David Pursell4e2fd362015-09-22 10:43:08 -0700235}
236
237#endif // !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800238
Josh Gaobcadc772017-09-28 16:29:53 -0700239static int create_service_thread(const char* service_name, void (*func)(int, void*), void* cookie) {
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 }
Josh Gaobcadc772017-09-28 16:29:53 -0700260 sti->service_name = service_name;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800261 sti->func = func;
262 sti->cookie = cookie;
263 sti->fd = s[1];
264
Josh Gaoe1dacfc2017-04-12 17:00:49 -0700265 std::thread(service_bootstrap_func, sti).detach();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800266
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700267 D("service thread started, %d:%d",s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800268 return s[0];
269}
270
David Pursell0955c662015-08-31 10:42:13 -0700271int service_to_fd(const char* name, const atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800272 int ret = -1;
273
Josh Gaocfb21412016-08-24 18:38:44 -0700274 if (is_socket_spec(name)) {
275 std::string error;
276 ret = socket_spec_connect(name, &error);
277 if (ret < 0) {
278 LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800279 }
Benoit Goby9470c2f2013-02-20 15:04:53 -0800280#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800281 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700282 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800283 } else if(!strncmp(name, "framebuffer:", 12)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700284 ret = create_service_thread("fb", framebuffer_service, nullptr);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800285 } else if (!strncmp(name, "jdwp:", 5)) {
286 ret = create_jdwp_connection_fd(atoi(name+5));
David Pursell4e2fd362015-09-22 10:43:08 -0700287 } else if(!strncmp(name, "shell", 5)) {
288 ret = ShellService(name + 5, transport);
Yabin Cui661327e2015-08-11 13:40:42 -0700289 } else if(!strncmp(name, "exec:", 5)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800290 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800291 } else if(!strncmp(name, "sync:", 5)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700292 ret = create_service_thread("sync", file_sync_service, nullptr);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800293 } else if(!strncmp(name, "remount:", 8)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700294 ret = create_service_thread("remount", remount_service, nullptr);
Mike Lockwoodee156622009-08-04 20:37:51 -0400295 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400296 void* arg = strdup(name + 7);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700297 if (arg == NULL) return -1;
Josh Gaobcadc772017-09-28 16:29:53 -0700298 ret = create_service_thread("reboot", reboot_service, arg);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700299 } else if(!strncmp(name, "root:", 5)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700300 ret = create_service_thread("root", restart_root_service, nullptr);
Dan Pasanen98858812014-10-06 12:57:20 -0500301 } else if(!strncmp(name, "unroot:", 7)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700302 ret = create_service_thread("unroot", restart_unroot_service, nullptr);
Christopher Tated2f54152011-04-21 12:53:28 -0700303 } else if(!strncmp(name, "backup:", 7)) {
David Pursell80f67022015-08-28 15:08:49 -0700304 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
305 (name + 7)).c_str(),
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800306 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
Elliott Hughesaa245492015-08-03 10:38:08 -0700307 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800308 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
David Pursell0955c662015-08-31 10:42:13 -0700309 SubprocessProtocol::kNone);
Mike Lockwoodff196702009-08-24 15:58:40 -0700310 } else if(!strncmp(name, "tcpip:", 6)) {
311 int port;
Spencer Low943ef232015-01-25 17:38:36 -0800312 if (sscanf(name + 6, "%d", &port) != 1) {
Elliott Hughes19d80b82015-07-21 16:13:40 -0700313 return -1;
Mike Lockwoodff196702009-08-24 15:58:40 -0700314 }
Josh Gaobcadc772017-09-28 16:29:53 -0700315 ret = create_service_thread("tcp", restart_tcp_service, reinterpret_cast<void*>(port));
Mike Lockwoodff196702009-08-24 15:58:40 -0700316 } else if(!strncmp(name, "usb:", 4)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700317 ret = create_service_thread("usb", restart_usb_service, nullptr);
David 'Digit' Turner25258692013-03-21 21:07:42 +0100318 } else if (!strncmp(name, "reverse:", 8)) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700319 ret = reverse_service(name + 8);
Paul Lawrenceec900bb2014-10-09 14:22:49 +0000320 } else if(!strncmp(name, "disable-verity:", 15)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700321 ret = create_service_thread("verity-on", set_verity_enabled_state_service,
322 reinterpret_cast<void*>(0));
Paul Lawrence982089d2014-12-03 15:31:57 -0800323 } else if(!strncmp(name, "enable-verity:", 15)) {
Josh Gaobcadc772017-09-28 16:29:53 -0700324 ret = create_service_thread("verity-off", set_verity_enabled_state_service,
325 reinterpret_cast<void*>(1));
Yabin Cui1f4ec192016-04-05 13:50:44 -0700326 } else if (!strcmp(name, "reconnect")) {
Josh Gaobcadc772017-09-28 16:29:53 -0700327 ret = create_service_thread("reconnect", reconnect_service,
328 const_cast<atransport*>(transport));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800329#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800330 }
331 if (ret >= 0) {
332 close_on_exec(ret);
333 }
334 return ret;
335}
336
337#if ADB_HOST
338struct state_info {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700339 TransportType transport_type;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100340 std::string serial;
Josh Gaob122b172017-08-16 16:57:01 -0700341 TransportId transport_id;
Dan Albertdcd78a12015-05-18 16:43:57 -0700342 ConnectionState state;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800343};
344
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100345static void wait_for_state(int fd, void* data) {
346 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800347
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700348 D("wait_for_state %d", sinfo->state);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800349
Elliott Hughes8d28e192015-10-07 14:55:10 -0700350 while (true) {
351 bool is_ambiguous = false;
352 std::string error = "unknown error";
Leo Sartre94e07762016-01-05 12:06:05 +0100353 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL;
Josh Gaob122b172017-08-16 16:57:01 -0700354 atransport* t = acquire_one_transport(sinfo->transport_type, serial, sinfo->transport_id,
355 &is_ambiguous, &error);
Yabin Cuib5e11412017-03-10 16:01:01 -0800356 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->GetConnectionState())) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700357 SendOkay(fd);
358 break;
359 } else if (!is_ambiguous) {
Josh Gao09855472016-02-19 10:42:40 -0800360 adb_pollfd pfd = {.fd = fd, .events = POLLIN };
361 int rc = adb_poll(&pfd, 1, 1000);
362 if (rc < 0) {
363 SendFail(fd, error);
364 break;
365 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) {
366 // The other end of the socket is closed, probably because the other side was
367 // terminated, bail out.
368 break;
369 }
370
Elliott Hughes8d28e192015-10-07 14:55:10 -0700371 // Try again...
372 } else {
373 SendFail(fd, error);
374 break;
375 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800376 }
377
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800378 adb_close(fd);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700379 D("wait_for_state is done");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800380}
Benoit Goby1c45ee92013-03-29 18:22:36 -0700381
Elliott Hughese67f1f82015-04-30 17:32:03 -0700382void connect_emulator(const std::string& port_spec, std::string* response) {
383 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
384 if (pieces.size() != 2) {
385 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
386 port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700387 return;
388 }
389
Elliott Hughese67f1f82015-04-30 17:32:03 -0700390 int console_port = strtol(pieces[0].c_str(), NULL, 0);
391 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
392 if (console_port <= 0 || adb_port <= 0) {
393 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700394 return;
395 }
396
Elliott Hughese67f1f82015-04-30 17:32:03 -0700397 // Check if the emulator is already known.
398 // Note: There's a small but harmless race condition here: An emulator not
399 // present just yet could be registered by another invocation right
400 // after doing this check here. However, local_connect protects
401 // against double-registration too. From here, a better error message
402 // can be produced. In the case of the race condition, the very specific
403 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700404 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700405 if (known_emulator != nullptr) {
406 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700407 return;
408 }
409
Elliott Hughese67f1f82015-04-30 17:32:03 -0700410 // Check if more emulators can be registered. Similar unproblematic
411 // race condition as above.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700412 int candidate_slot = get_available_local_transport_index();
413 if (candidate_slot < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700414 *response = "Cannot accept more emulators";
Benoit Goby1c45ee92013-03-29 18:22:36 -0700415 return;
416 }
417
Elliott Hughese67f1f82015-04-30 17:32:03 -0700418 // Preconditions met, try to connect to the emulator.
Elliott Hughes381cfa92015-07-23 17:12:58 -0700419 std::string error;
420 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700421 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
422 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700423 } else {
Elliott Hughes381cfa92015-07-23 17:12:58 -0700424 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s",
425 console_port, adb_port, error.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700426 }
427}
428
Alan Jeon4af3c402014-10-16 17:05:25 +0900429static void connect_service(int fd, void* data) {
430 char* host = reinterpret_cast<char*>(data);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700431 std::string response;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700432 if (!strncmp(host, "emu:", 4)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700433 connect_emulator(host + 4, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700434 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700435 connect_device(host, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700436 }
Alan Jeon4af3c402014-10-16 17:05:25 +0900437 free(host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700438
439 // Send response for emulator and device
Elliott Hughese67f1f82015-04-30 17:32:03 -0700440 SendProtocolString(fd, response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700441 adb_close(fd);
442}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800443#endif
444
445#if ADB_HOST
Josh Gaob122b172017-08-16 16:57:01 -0700446asocket* host_service_to_socket(const char* name, const char* serial, TransportId transport_id) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800447 if (!strcmp(name,"track-devices")) {
Josh Gaob0c18022017-08-14 18:57:54 -0700448 return create_device_tracker(false);
449 } else if (!strcmp(name, "track-devices-l")) {
450 return create_device_tracker(true);
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100451 } else if (android::base::StartsWith(name, "wait-for-")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800452 name += strlen("wait-for-");
453
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100454 std::unique_ptr<state_info> sinfo(new state_info);
455 if (sinfo == nullptr) {
456 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
457 return nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800458 }
459
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100460 if (serial) sinfo->serial = serial;
Josh Gaob122b172017-08-16 16:57:01 -0700461 sinfo->transport_id = transport_id;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100462
463 if (android::base::StartsWith(name, "local")) {
464 name += strlen("local");
465 sinfo->transport_type = kTransportLocal;
466 } else if (android::base::StartsWith(name, "usb")) {
467 name += strlen("usb");
468 sinfo->transport_type = kTransportUsb;
469 } else if (android::base::StartsWith(name, "any")) {
470 name += strlen("any");
471 sinfo->transport_type = kTransportAny;
472 } else {
473 return nullptr;
474 }
475
476 if (!strcmp(name, "-device")) {
477 sinfo->state = kCsDevice;
478 } else if (!strcmp(name, "-recovery")) {
479 sinfo->state = kCsRecovery;
480 } else if (!strcmp(name, "-sideload")) {
481 sinfo->state = kCsSideload;
482 } else if (!strcmp(name, "-bootloader")) {
483 sinfo->state = kCsBootloader;
Josh Gao86441c32016-04-13 12:18:58 -0700484 } else if (!strcmp(name, "-any")) {
485 sinfo->state = kCsAny;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100486 } else {
487 return nullptr;
488 }
489
Josh Gaobcadc772017-09-28 16:29:53 -0700490 int fd = create_service_thread("wait", wait_for_state, sinfo.get());
Ting-Yuan Huangf26cf6d2017-08-15 15:07:21 -0700491 if (fd != -1) {
492 sinfo.release();
493 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800494 return create_local_socket(fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700495 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeon4af3c402014-10-16 17:05:25 +0900496 char* host = strdup(name + 8);
Josh Gaobcadc772017-09-28 16:29:53 -0700497 int fd = create_service_thread("connect", connect_service, host);
Ting-Yuan Huangf26cf6d2017-08-15 15:07:21 -0700498 if (fd == -1) {
499 free(host);
500 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700501 return create_local_socket(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800502 }
503 return NULL;
504}
505#endif /* ADB_HOST */