blob: 3b212e9c854e21a57d29a2132f14018a91301cc1 [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
Elliott Hughes4f713192015-12-04 22:00:26 -080034#include <android-base/file.h>
David Pursell706955f2016-01-21 08:40:59 -080035#include <android-base/parsenetaddress.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080036#include <android-base/stringprintf.h>
37#include <android-base/strings.h>
Elliott Hughes381cfa92015-07-23 17:12:58 -070038#include <cutils/sockets.h>
Elliott Hughes6c34bba2015-04-17 20:11:08 -070039
Dan Albert76649012015-02-24 15:51:19 -080040#if !ADB_HOST
41#include "cutils/android_reboot.h"
42#include "cutils/properties.h"
43#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080044
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080045#include "adb.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080046#include "adb_io.h"
Elliott Hughes3d5f60d2015-07-18 12:21:30 -070047#include "adb_utils.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080048#include "file_sync_service.h"
Elliott Hughesec7a6672015-03-16 21:58:32 +000049#include "remount_service.h"
David Pursell70ef7b42015-09-30 13:35:42 -070050#include "services.h"
David Pursell80f67022015-08-28 15:08:49 -070051#include "shell_service.h"
Josh Gao09855472016-02-19 10:42:40 -080052#include "sysdeps.h"
Dan Albert76649012015-02-24 15:51:19 -080053#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080054
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080055struct stinfo {
56 void (*func)(int fd, void *cookie);
57 int fd;
58 void *cookie;
59};
60
Josh Gaob5fea142016-02-12 14:31:15 -080061static void service_bootstrap_func(void* x) {
Dan Albertbac34742015-02-25 17:51:28 -080062 stinfo* sti = reinterpret_cast<stinfo*>(x);
Siva Velusamy49ee7cf2015-08-28 16:37:29 -070063 adb_thread_setname(android::base::StringPrintf("service %d", sti->fd));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080064 sti->func(sti->fd, sti->cookie);
65 free(sti);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080066}
67
Benoit Goby9470c2f2013-02-20 15:04:53 -080068#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080069
Elliott Hughesab52c182015-05-01 17:04:38 -070070void restart_root_service(int fd, void *cookie) {
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070071 if (getuid() == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070072 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070073 adb_close(fd);
74 } else {
Elliott Hughesab52c182015-05-01 17:04:38 -070075 char value[PROPERTY_VALUE_MAX];
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070076 property_get("ro.debuggable", value, "");
77 if (strcmp(value, "1") != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070078 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwoodff196702009-08-24 15:58:40 -070079 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070080 return;
81 }
82
Benoit Goby7941cf82012-03-16 14:44:17 -070083 property_set("service.adb.root", "1");
Elliott Hughesab52c182015-05-01 17:04:38 -070084 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070085 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070086 }
87}
88
Elliott Hughesab52c182015-05-01 17:04:38 -070089void restart_unroot_service(int fd, void *cookie) {
Dan Pasanen98858812014-10-06 12:57:20 -050090 if (getuid() != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070091 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050092 adb_close(fd);
93 } else {
94 property_set("service.adb.root", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -070095 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050096 adb_close(fd);
97 }
98}
99
Elliott Hughesab52c182015-05-01 17:04:38 -0700100void restart_tcp_service(int fd, void *cookie) {
Elliott Hughesccecf142014-01-16 10:53:11 -0800101 int port = (int) (uintptr_t) cookie;
Mike Lockwoodff196702009-08-24 15:58:40 -0700102 if (port <= 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700103 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700104 adb_close(fd);
105 return;
106 }
107
Elliott Hughesab52c182015-05-01 17:04:38 -0700108 char value[PROPERTY_VALUE_MAX];
Mike Lockwoodff196702009-08-24 15:58:40 -0700109 snprintf(value, sizeof(value), "%d", port);
110 property_set("service.adb.tcp.port", value);
Elliott Hughesab52c182015-05-01 17:04:38 -0700111 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700112 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700113}
114
Elliott Hughesab52c182015-05-01 17:04:38 -0700115void restart_usb_service(int fd, void *cookie) {
Mike Lockwoodff196702009-08-24 15:58:40 -0700116 property_set("service.adb.tcp.port", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -0700117 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwoodff196702009-08-24 15:58:40 -0700118 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700119}
120
Tao Bao175b7bb2015-03-29 11:22:34 -0700121static 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
Tao Bao175b7bb2015-03-29 11:22:34 -0700130 // 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) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700134 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao175b7bb2015-03-29 11:22:34 -0700135 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) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700142 D("Failed to create directory '%s': %s", recovery_dir, strerror(errno));
Tao Bao175b7bb2015-03-29 11:22:34 -0700143 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 }
Mike Lockwoodee156622009-08-04 20:37:51 -0400154
155 sync();
Mike Lockwoodd969faa2010-02-24 16:07:23 -0500156
Tao Bao175b7bb2015-03-29 11:22:34 -0700157 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))) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700160 WriteFdFmt(fd, "reboot string too long: %d\n", ret);
Tao Bao175b7bb2015-03-29 11:22:34 -0700161 return false;
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700162 }
163
164 ret = property_set(ANDROID_RB_PROPERTY, property_val);
Mike Lockwoodee156622009-08-04 20:37:51 -0400165 if (ret < 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700166 WriteFdFmt(fd, "reboot failed: %d\n", ret);
Tao Bao175b7bb2015-03-29 11:22:34 -0700167 return false;
Mike Lockwoodee156622009-08-04 20:37:51 -0400168 }
Tao Bao175b7bb2015-03-29 11:22:34 -0700169
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"
Elliott Hughesa7090b92015-04-17 17:03:59 -0700178 while (true) {
Tao Bao175b7bb2015-03-29 11:22:34 -0700179 pause();
180 }
181 }
182
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400183 free(arg);
Mike Lockwoodee156622009-08-04 20:37:51 -0400184 adb_close(fd);
185}
186
Yabin Cui1f4ec192016-04-05 13:50:44 -0700187static void reconnect_service(int fd, void* arg) {
188 WriteFdExactly(fd, "done");
189 adb_close(fd);
190 atransport* t = static_cast<atransport*>(arg);
191 kick_transport(t);
192}
193
Yabin Cuifbfa8402015-10-30 18:37:26 -0700194int reverse_service(const char* command) {
195 int s[2];
196 if (adb_socketpair(s)) {
197 PLOG(ERROR) << "cannot create service socket pair.";
198 return -1;
David 'Digit' Turner25258692013-03-21 21:07:42 +0100199 }
Yabin Cuifbfa8402015-10-30 18:37:26 -0700200 VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1];
201 if (handle_forward_request(command, kTransportAny, nullptr, s[1]) < 0) {
202 SendFail(s[1], "not a reverse forwarding command");
203 }
204 adb_close(s[1]);
205 return s[0];
David 'Digit' Turner25258692013-03-21 21:07:42 +0100206}
207
David Pursell4e2fd362015-09-22 10:43:08 -0700208// Shell service string can look like:
David Pursell70ef7b42015-09-30 13:35:42 -0700209// shell[,arg1,arg2,...]:[command]
David Pursell4e2fd362015-09-22 10:43:08 -0700210static int ShellService(const std::string& args, const atransport* transport) {
211 size_t delimiter_index = args.find(':');
212 if (delimiter_index == std::string::npos) {
213 LOG(ERROR) << "No ':' found in shell service arguments: " << args;
214 return -1;
215 }
David Pursell70ef7b42015-09-30 13:35:42 -0700216
David Pursell4e2fd362015-09-22 10:43:08 -0700217 const std::string service_args = args.substr(0, delimiter_index);
218 const std::string command = args.substr(delimiter_index + 1);
219
David Pursell70ef7b42015-09-30 13:35:42 -0700220 // Defaults:
221 // PTY for interactive, raw for non-interactive.
222 // No protocol.
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800223 // $TERM set to "dumb".
David Pursell70ef7b42015-09-30 13:35:42 -0700224 SubprocessType type(command.empty() ? SubprocessType::kPty
225 : SubprocessType::kRaw);
226 SubprocessProtocol protocol = SubprocessProtocol::kNone;
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800227 std::string terminal_type = "dumb";
David Pursell4e2fd362015-09-22 10:43:08 -0700228
David Pursell70ef7b42015-09-30 13:35:42 -0700229 for (const std::string& arg : android::base::Split(service_args, ",")) {
230 if (arg == kShellServiceArgRaw) {
231 type = SubprocessType::kRaw;
232 } else if (arg == kShellServiceArgPty) {
233 type = SubprocessType::kPty;
234 } else if (arg == kShellServiceArgShellProtocol) {
235 protocol = SubprocessProtocol::kShell;
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800236 } else if (android::base::StartsWith(arg, "TERM=")) {
237 terminal_type = arg.substr(5);
238 } else if (!arg.empty()) {
239 // This is not an error to allow for future expansion.
240 LOG(WARNING) << "Ignoring unknown shell service argument: " << arg;
David Pursell70ef7b42015-09-30 13:35:42 -0700241 }
242 }
David Pursell4e2fd362015-09-22 10:43:08 -0700243
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800244 return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol);
David Pursell4e2fd362015-09-22 10:43:08 -0700245}
246
247#endif // !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800248
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800249static int create_service_thread(void (*func)(int, void *), void *cookie)
250{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800251 int s[2];
Dan Albertbac34742015-02-25 17:51:28 -0800252 if (adb_socketpair(s)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800253 printf("cannot create service socket pair\n");
254 return -1;
255 }
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700256 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800257
Dan Albertbac34742015-02-25 17:51:28 -0800258 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
259 if (sti == nullptr) {
260 fatal("cannot allocate stinfo");
261 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800262 sti->func = func;
263 sti->cookie = cookie;
264 sti->fd = s[1];
265
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700266 if (!adb_thread_create(service_bootstrap_func, sti)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800267 free(sti);
268 adb_close(s[0]);
269 adb_close(s[1]);
270 printf("cannot create service thread\n");
271 return -1;
272 }
273
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700274 D("service thread started, %d:%d",s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275 return s[0];
276}
277
David Pursell0955c662015-08-31 10:42:13 -0700278int service_to_fd(const char* name, const atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800279 int ret = -1;
280
281 if(!strncmp(name, "tcp:", 4)) {
282 int port = atoi(name + 4);
283 name = strchr(name + 4, ':');
284 if(name == 0) {
Spencer Low5200c662015-07-30 23:07:55 -0700285 std::string error;
286 ret = network_loopback_client(port, SOCK_STREAM, &error);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800287 if (ret >= 0)
288 disable_tcp_nagle(ret);
289 } else {
290#if ADB_HOST
Elliott Hughes381cfa92015-07-23 17:12:58 -0700291 std::string error;
292 ret = network_connect(name + 1, port, SOCK_STREAM, 0, &error);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800293#else
294 return -1;
295#endif
296 }
Elliott Hughesadbf4422015-07-29 17:45:24 -0700297#if !defined(_WIN32) /* winsock doesn't implement unix domain sockets */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800298 } else if(!strncmp(name, "local:", 6)) {
299 ret = socket_local_client(name + 6,
300 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
301 } else if(!strncmp(name, "localreserved:", 14)) {
302 ret = socket_local_client(name + 14,
303 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
304 } else if(!strncmp(name, "localabstract:", 14)) {
305 ret = socket_local_client(name + 14,
306 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
307 } else if(!strncmp(name, "localfilesystem:", 16)) {
308 ret = socket_local_client(name + 16,
309 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
310#endif
Benoit Goby9470c2f2013-02-20 15:04:53 -0800311#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800312 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700313 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800314 } else if(!strncmp(name, "framebuffer:", 12)) {
315 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800316 } else if (!strncmp(name, "jdwp:", 5)) {
317 ret = create_jdwp_connection_fd(atoi(name+5));
David Pursell4e2fd362015-09-22 10:43:08 -0700318 } else if(!strncmp(name, "shell", 5)) {
319 ret = ShellService(name + 5, transport);
Yabin Cui661327e2015-08-11 13:40:42 -0700320 } else if(!strncmp(name, "exec:", 5)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800321 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800322 } else if(!strncmp(name, "sync:", 5)) {
323 ret = create_service_thread(file_sync_service, NULL);
324 } else if(!strncmp(name, "remount:", 8)) {
325 ret = create_service_thread(remount_service, NULL);
Mike Lockwoodee156622009-08-04 20:37:51 -0400326 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400327 void* arg = strdup(name + 7);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700328 if (arg == NULL) return -1;
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400329 ret = create_service_thread(reboot_service, arg);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700330 } else if(!strncmp(name, "root:", 5)) {
331 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanen98858812014-10-06 12:57:20 -0500332 } else if(!strncmp(name, "unroot:", 7)) {
333 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tated2f54152011-04-21 12:53:28 -0700334 } else if(!strncmp(name, "backup:", 7)) {
David Pursell80f67022015-08-28 15:08:49 -0700335 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
336 (name + 7)).c_str(),
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800337 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
Elliott Hughesaa245492015-08-03 10:38:08 -0700338 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800339 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
David Pursell0955c662015-08-31 10:42:13 -0700340 SubprocessProtocol::kNone);
Mike Lockwoodff196702009-08-24 15:58:40 -0700341 } else if(!strncmp(name, "tcpip:", 6)) {
342 int port;
Spencer Low943ef232015-01-25 17:38:36 -0800343 if (sscanf(name + 6, "%d", &port) != 1) {
Elliott Hughes19d80b82015-07-21 16:13:40 -0700344 return -1;
Mike Lockwoodff196702009-08-24 15:58:40 -0700345 }
Elliott Hughesccecf142014-01-16 10:53:11 -0800346 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700347 } else if(!strncmp(name, "usb:", 4)) {
348 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner25258692013-03-21 21:07:42 +0100349 } else if (!strncmp(name, "reverse:", 8)) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700350 ret = reverse_service(name + 8);
Paul Lawrenceec900bb2014-10-09 14:22:49 +0000351 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence982089d2014-12-03 15:31:57 -0800352 ret = create_service_thread(set_verity_enabled_state_service, (void*)0);
353 } else if(!strncmp(name, "enable-verity:", 15)) {
354 ret = create_service_thread(set_verity_enabled_state_service, (void*)1);
Yabin Cui1f4ec192016-04-05 13:50:44 -0700355 } else if (!strcmp(name, "reconnect")) {
356 ret = create_service_thread(reconnect_service, const_cast<atransport*>(transport));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800357#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800358 }
359 if (ret >= 0) {
360 close_on_exec(ret);
361 }
362 return ret;
363}
364
365#if ADB_HOST
366struct state_info {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700367 TransportType transport_type;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100368 std::string serial;
Dan Albertdcd78a12015-05-18 16:43:57 -0700369 ConnectionState state;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800370};
371
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100372static void wait_for_state(int fd, void* data) {
373 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800374
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700375 D("wait_for_state %d", sinfo->state);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800376
Elliott Hughes8d28e192015-10-07 14:55:10 -0700377 while (true) {
378 bool is_ambiguous = false;
379 std::string error = "unknown error";
Leo Sartre94e07762016-01-05 12:06:05 +0100380 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL;
381 atransport* t = acquire_one_transport(sinfo->transport_type, serial, &is_ambiguous, &error);
Josh Gao86441c32016-04-13 12:18:58 -0700382 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->connection_state)) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700383 SendOkay(fd);
384 break;
385 } else if (!is_ambiguous) {
Josh Gao09855472016-02-19 10:42:40 -0800386 adb_pollfd pfd = {.fd = fd, .events = POLLIN };
387 int rc = adb_poll(&pfd, 1, 1000);
388 if (rc < 0) {
389 SendFail(fd, error);
390 break;
391 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) {
392 // The other end of the socket is closed, probably because the other side was
393 // terminated, bail out.
394 break;
395 }
396
Elliott Hughes8d28e192015-10-07 14:55:10 -0700397 // Try again...
398 } else {
399 SendFail(fd, error);
400 break;
401 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800402 }
403
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800404 adb_close(fd);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700405 D("wait_for_state is done");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800406}
Benoit Goby1c45ee92013-03-29 18:22:36 -0700407
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700408static void connect_device(const std::string& address, std::string* response) {
409 if (address.empty()) {
410 *response = "empty address";
Elliott Hughese67f1f82015-04-30 17:32:03 -0700411 return;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700412 }
413
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700414 std::string serial;
415 std::string host;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700416 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
David Pursell706955f2016-01-21 08:40:59 -0800417 if (!android::base::ParseNetAddress(address, &host, &port, &serial, response)) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700418 return;
419 }
420
Elliott Hughes381cfa92015-07-23 17:12:58 -0700421 std::string error;
422 int fd = network_connect(host.c_str(), port, SOCK_STREAM, 10, &error);
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700423 if (fd == -1) {
424 *response = android::base::StringPrintf("unable to connect to %s: %s",
Elliott Hughes381cfa92015-07-23 17:12:58 -0700425 serial.c_str(), error.c_str());
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700426 return;
427 }
428
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700429 D("client: connected %s remote on fd %d", serial.c_str(), fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700430 close_on_exec(fd);
431 disable_tcp_nagle(fd);
432
David Pursellbfd95032016-02-22 14:27:23 -0800433 // Send a TCP keepalive ping to the device every second so we can detect disconnects.
434 if (!set_tcp_keepalive(fd, 1)) {
435 D("warning: failed to configure TCP keepalives (%s)", strerror(errno));
436 }
437
Elliott Hughese67f1f82015-04-30 17:32:03 -0700438 int ret = register_socket_transport(fd, serial.c_str(), port, 0);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700439 if (ret < 0) {
440 adb_close(fd);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700441 *response = android::base::StringPrintf("already connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700442 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700443 *response = android::base::StringPrintf("connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700444 }
445}
446
Elliott Hughese67f1f82015-04-30 17:32:03 -0700447void connect_emulator(const std::string& port_spec, std::string* response) {
448 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
449 if (pieces.size() != 2) {
450 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
451 port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700452 return;
453 }
454
Elliott Hughese67f1f82015-04-30 17:32:03 -0700455 int console_port = strtol(pieces[0].c_str(), NULL, 0);
456 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
457 if (console_port <= 0 || adb_port <= 0) {
458 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700459 return;
460 }
461
Elliott Hughese67f1f82015-04-30 17:32:03 -0700462 // Check if the emulator is already known.
463 // Note: There's a small but harmless race condition here: An emulator not
464 // present just yet could be registered by another invocation right
465 // after doing this check here. However, local_connect protects
466 // against double-registration too. From here, a better error message
467 // can be produced. In the case of the race condition, the very specific
468 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700469 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700470 if (known_emulator != nullptr) {
471 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700472 return;
473 }
474
Elliott Hughese67f1f82015-04-30 17:32:03 -0700475 // Check if more emulators can be registered. Similar unproblematic
476 // race condition as above.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700477 int candidate_slot = get_available_local_transport_index();
478 if (candidate_slot < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700479 *response = "Cannot accept more emulators";
Benoit Goby1c45ee92013-03-29 18:22:36 -0700480 return;
481 }
482
Elliott Hughese67f1f82015-04-30 17:32:03 -0700483 // Preconditions met, try to connect to the emulator.
Elliott Hughes381cfa92015-07-23 17:12:58 -0700484 std::string error;
485 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700486 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
487 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700488 } else {
Elliott Hughes381cfa92015-07-23 17:12:58 -0700489 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s",
490 console_port, adb_port, error.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700491 }
492}
493
Alan Jeon4af3c402014-10-16 17:05:25 +0900494static void connect_service(int fd, void* data) {
495 char* host = reinterpret_cast<char*>(data);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700496 std::string response;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700497 if (!strncmp(host, "emu:", 4)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700498 connect_emulator(host + 4, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700499 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700500 connect_device(host, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700501 }
Alan Jeon4af3c402014-10-16 17:05:25 +0900502 free(host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700503
504 // Send response for emulator and device
Elliott Hughese67f1f82015-04-30 17:32:03 -0700505 SendProtocolString(fd, response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700506 adb_close(fd);
507}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800508#endif
509
510#if ADB_HOST
Elliott Hughesaa245492015-08-03 10:38:08 -0700511asocket* host_service_to_socket(const char* name, const char* serial) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800512 if (!strcmp(name,"track-devices")) {
513 return create_device_tracker();
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100514 } else if (android::base::StartsWith(name, "wait-for-")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800515 name += strlen("wait-for-");
516
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100517 std::unique_ptr<state_info> sinfo(new state_info);
518 if (sinfo == nullptr) {
519 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
520 return nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800521 }
522
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100523 if (serial) sinfo->serial = serial;
524
525 if (android::base::StartsWith(name, "local")) {
526 name += strlen("local");
527 sinfo->transport_type = kTransportLocal;
528 } else if (android::base::StartsWith(name, "usb")) {
529 name += strlen("usb");
530 sinfo->transport_type = kTransportUsb;
531 } else if (android::base::StartsWith(name, "any")) {
532 name += strlen("any");
533 sinfo->transport_type = kTransportAny;
534 } else {
535 return nullptr;
536 }
537
538 if (!strcmp(name, "-device")) {
539 sinfo->state = kCsDevice;
540 } else if (!strcmp(name, "-recovery")) {
541 sinfo->state = kCsRecovery;
542 } else if (!strcmp(name, "-sideload")) {
543 sinfo->state = kCsSideload;
544 } else if (!strcmp(name, "-bootloader")) {
545 sinfo->state = kCsBootloader;
Josh Gao86441c32016-04-13 12:18:58 -0700546 } else if (!strcmp(name, "-any")) {
547 sinfo->state = kCsAny;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100548 } else {
549 return nullptr;
550 }
551
552 int fd = create_service_thread(wait_for_state, sinfo.release());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800553 return create_local_socket(fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700554 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeon4af3c402014-10-16 17:05:25 +0900555 char* host = strdup(name + 8);
556 int fd = create_service_thread(connect_service, host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700557 return create_local_socket(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800558 }
559 return NULL;
560}
561#endif /* ADB_HOST */