blob: 0c3dd00f9660439659dc4e8d4489dff26a4b3fab [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"
Elliott Hughesffdec182016-09-23 15:40:03 -070042#include <android-base/properties.h>
Dan Albert76649012015-02-24 15:51:19 -080043#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 Gaocfb21412016-08-24 18:38:44 -070052#include "socket_spec.h"
Josh Gao09855472016-02-19 10:42:40 -080053#include "sysdeps.h"
Dan Albert76649012015-02-24 15:51:19 -080054#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080055
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080056struct stinfo {
57 void (*func)(int fd, void *cookie);
58 int fd;
59 void *cookie;
60};
61
Josh Gaob5fea142016-02-12 14:31:15 -080062static void service_bootstrap_func(void* x) {
Dan Albertbac34742015-02-25 17:51:28 -080063 stinfo* sti = reinterpret_cast<stinfo*>(x);
Siva Velusamy49ee7cf2015-08-28 16:37:29 -070064 adb_thread_setname(android::base::StringPrintf("service %d", sti->fd));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080065 sti->func(sti->fd, sti->cookie);
66 free(sti);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080067}
68
Benoit Goby9470c2f2013-02-20 15:04:53 -080069#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080070
Elliott Hughesab52c182015-05-01 17:04:38 -070071void restart_root_service(int fd, void *cookie) {
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070072 if (getuid() == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070073 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070074 adb_close(fd);
75 } else {
Elliott Hughesffdec182016-09-23 15:40:03 -070076 if (!android::base::GetBoolProperty("ro.debuggable", false)) {
Elliott Hughesab52c182015-05-01 17:04:38 -070077 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwoodff196702009-08-24 15:58:40 -070078 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070079 return;
80 }
81
Elliott Hughesffdec182016-09-23 15:40:03 -070082 android::base::SetProperty("service.adb.root", "1");
Elliott Hughesab52c182015-05-01 17:04:38 -070083 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070084 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070085 }
86}
87
Elliott Hughesab52c182015-05-01 17:04:38 -070088void restart_unroot_service(int fd, void *cookie) {
Dan Pasanen98858812014-10-06 12:57:20 -050089 if (getuid() != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070090 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050091 adb_close(fd);
92 } else {
Elliott Hughesffdec182016-09-23 15:40:03 -070093 android::base::SetProperty("service.adb.root", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -070094 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050095 adb_close(fd);
96 }
97}
98
Elliott Hughesab52c182015-05-01 17:04:38 -070099void restart_tcp_service(int fd, void *cookie) {
Elliott Hughesccecf142014-01-16 10:53:11 -0800100 int port = (int) (uintptr_t) cookie;
Mike Lockwoodff196702009-08-24 15:58:40 -0700101 if (port <= 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700102 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700103 adb_close(fd);
104 return;
105 }
106
Elliott Hughesffdec182016-09-23 15:40:03 -0700107 android::base::SetProperty("service.adb.tcp.port", android::base::StringPrintf("%d", port));
Elliott Hughesab52c182015-05-01 17:04:38 -0700108 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700109 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700110}
111
Elliott Hughesab52c182015-05-01 17:04:38 -0700112void restart_usb_service(int fd, void *cookie) {
Elliott Hughesffdec182016-09-23 15:40:03 -0700113 android::base::SetProperty("service.adb.tcp.port", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -0700114 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwoodff196702009-08-24 15:58:40 -0700115 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700116}
117
Tao Bao175b7bb2015-03-29 11:22:34 -0700118static bool reboot_service_impl(int fd, const char* arg) {
119 const char* reboot_arg = arg;
120 bool auto_reboot = false;
121
122 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) {
123 auto_reboot = true;
124 reboot_arg = "sideload";
125 }
126
Tao Bao175b7bb2015-03-29 11:22:34 -0700127 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot"
128 // in the command file.
129 if (strcmp(reboot_arg, "sideload") == 0) {
130 if (getuid() != 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700131 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao175b7bb2015-03-29 11:22:34 -0700132 return false;
133 }
134
135 const char* const recovery_dir = "/cache/recovery";
136 const char* const command_file = "/cache/recovery/command";
137 // Ensure /cache/recovery exists.
138 if (adb_mkdir(recovery_dir, 0770) == -1 && errno != EEXIST) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700139 D("Failed to create directory '%s': %s", recovery_dir, strerror(errno));
Tao Bao175b7bb2015-03-29 11:22:34 -0700140 return false;
141 }
142
143 bool write_status = android::base::WriteStringToFile(
144 auto_reboot ? "--sideload_auto_reboot" : "--sideload", command_file);
145 if (!write_status) {
146 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
Elliott Hughesffdec182016-09-23 15:40:03 -0700154 std::string reboot_string = android::base::StringPrintf("reboot,%s", reboot_arg);
155 if (!android::base::SetProperty(ANDROID_RB_PROPERTY, reboot_string)) {
156 WriteFdFmt(fd, "reboot (%s) failed\n", reboot_string.c_str());
Tao Bao175b7bb2015-03-29 11:22:34 -0700157 return false;
Mike Lockwoodee156622009-08-04 20:37:51 -0400158 }
Tao Bao175b7bb2015-03-29 11:22:34 -0700159
160 return true;
161}
162
163void reboot_service(int fd, void* arg)
164{
165 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];
191 if (handle_forward_request(command, kTransportAny, nullptr, s[1]) < 0) {
192 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
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800239static int create_service_thread(void (*func)(int, void *), void *cookie)
240{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800241 int s[2];
Dan Albertbac34742015-02-25 17:51:28 -0800242 if (adb_socketpair(s)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800243 printf("cannot create service socket pair\n");
244 return -1;
245 }
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700246 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800247
Dan Albertbac34742015-02-25 17:51:28 -0800248 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
249 if (sti == nullptr) {
250 fatal("cannot allocate stinfo");
251 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800252 sti->func = func;
253 sti->cookie = cookie;
254 sti->fd = s[1];
255
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700256 if (!adb_thread_create(service_bootstrap_func, sti)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800257 free(sti);
258 adb_close(s[0]);
259 adb_close(s[1]);
260 printf("cannot create service thread\n");
261 return -1;
262 }
263
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700264 D("service thread started, %d:%d",s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800265 return s[0];
266}
267
David Pursell0955c662015-08-31 10:42:13 -0700268int service_to_fd(const char* name, const atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800269 int ret = -1;
270
Josh Gaocfb21412016-08-24 18:38:44 -0700271 if (is_socket_spec(name)) {
272 std::string error;
273 ret = socket_spec_connect(name, &error);
274 if (ret < 0) {
275 LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800276 }
Benoit Goby9470c2f2013-02-20 15:04:53 -0800277#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800278 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700279 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800280 } else if(!strncmp(name, "framebuffer:", 12)) {
281 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800282 } else if (!strncmp(name, "jdwp:", 5)) {
283 ret = create_jdwp_connection_fd(atoi(name+5));
David Pursell4e2fd362015-09-22 10:43:08 -0700284 } else if(!strncmp(name, "shell", 5)) {
285 ret = ShellService(name + 5, transport);
Yabin Cui661327e2015-08-11 13:40:42 -0700286 } else if(!strncmp(name, "exec:", 5)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800287 ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800288 } else if(!strncmp(name, "sync:", 5)) {
289 ret = create_service_thread(file_sync_service, NULL);
290 } else if(!strncmp(name, "remount:", 8)) {
291 ret = create_service_thread(remount_service, NULL);
Mike Lockwoodee156622009-08-04 20:37:51 -0400292 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400293 void* arg = strdup(name + 7);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700294 if (arg == NULL) return -1;
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400295 ret = create_service_thread(reboot_service, arg);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700296 } else if(!strncmp(name, "root:", 5)) {
297 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanen98858812014-10-06 12:57:20 -0500298 } else if(!strncmp(name, "unroot:", 7)) {
299 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tated2f54152011-04-21 12:53:28 -0700300 } else if(!strncmp(name, "backup:", 7)) {
David Pursell80f67022015-08-28 15:08:49 -0700301 ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
302 (name + 7)).c_str(),
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800303 nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
Elliott Hughesaa245492015-08-03 10:38:08 -0700304 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughes18ddf5c2015-11-16 10:55:34 -0800305 ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
David Pursell0955c662015-08-31 10:42:13 -0700306 SubprocessProtocol::kNone);
Mike Lockwoodff196702009-08-24 15:58:40 -0700307 } else if(!strncmp(name, "tcpip:", 6)) {
308 int port;
Spencer Low943ef232015-01-25 17:38:36 -0800309 if (sscanf(name + 6, "%d", &port) != 1) {
Elliott Hughes19d80b82015-07-21 16:13:40 -0700310 return -1;
Mike Lockwoodff196702009-08-24 15:58:40 -0700311 }
Elliott Hughesccecf142014-01-16 10:53:11 -0800312 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700313 } else if(!strncmp(name, "usb:", 4)) {
314 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner25258692013-03-21 21:07:42 +0100315 } else if (!strncmp(name, "reverse:", 8)) {
Yabin Cuifbfa8402015-10-30 18:37:26 -0700316 ret = reverse_service(name + 8);
Paul Lawrenceec900bb2014-10-09 14:22:49 +0000317 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence982089d2014-12-03 15:31:57 -0800318 ret = create_service_thread(set_verity_enabled_state_service, (void*)0);
319 } else if(!strncmp(name, "enable-verity:", 15)) {
320 ret = create_service_thread(set_verity_enabled_state_service, (void*)1);
Yabin Cui1f4ec192016-04-05 13:50:44 -0700321 } else if (!strcmp(name, "reconnect")) {
322 ret = create_service_thread(reconnect_service, const_cast<atransport*>(transport));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800323#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800324 }
325 if (ret >= 0) {
326 close_on_exec(ret);
327 }
328 return ret;
329}
330
331#if ADB_HOST
332struct state_info {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700333 TransportType transport_type;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100334 std::string serial;
Dan Albertdcd78a12015-05-18 16:43:57 -0700335 ConnectionState state;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800336};
337
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100338static void wait_for_state(int fd, void* data) {
339 std::unique_ptr<state_info> sinfo(reinterpret_cast<state_info*>(data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800340
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700341 D("wait_for_state %d", sinfo->state);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800342
Elliott Hughes8d28e192015-10-07 14:55:10 -0700343 while (true) {
344 bool is_ambiguous = false;
345 std::string error = "unknown error";
Leo Sartre94e07762016-01-05 12:06:05 +0100346 const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL;
347 atransport* t = acquire_one_transport(sinfo->transport_type, serial, &is_ambiguous, &error);
Josh Gao86441c32016-04-13 12:18:58 -0700348 if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->connection_state)) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700349 SendOkay(fd);
350 break;
351 } else if (!is_ambiguous) {
Josh Gao09855472016-02-19 10:42:40 -0800352 adb_pollfd pfd = {.fd = fd, .events = POLLIN };
353 int rc = adb_poll(&pfd, 1, 1000);
354 if (rc < 0) {
355 SendFail(fd, error);
356 break;
357 } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) {
358 // The other end of the socket is closed, probably because the other side was
359 // terminated, bail out.
360 break;
361 }
362
Elliott Hughes8d28e192015-10-07 14:55:10 -0700363 // Try again...
364 } else {
365 SendFail(fd, error);
366 break;
367 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800368 }
369
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800370 adb_close(fd);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700371 D("wait_for_state is done");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800372}
Benoit Goby1c45ee92013-03-29 18:22:36 -0700373
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700374static void connect_device(const std::string& address, std::string* response) {
375 if (address.empty()) {
376 *response = "empty address";
Elliott Hughese67f1f82015-04-30 17:32:03 -0700377 return;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700378 }
379
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700380 std::string serial;
381 std::string host;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700382 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
David Pursell706955f2016-01-21 08:40:59 -0800383 if (!android::base::ParseNetAddress(address, &host, &port, &serial, response)) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700384 return;
385 }
386
Elliott Hughes381cfa92015-07-23 17:12:58 -0700387 std::string error;
388 int fd = network_connect(host.c_str(), port, SOCK_STREAM, 10, &error);
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700389 if (fd == -1) {
390 *response = android::base::StringPrintf("unable to connect to %s: %s",
Elliott Hughes381cfa92015-07-23 17:12:58 -0700391 serial.c_str(), error.c_str());
Elliott Hughes3d5f60d2015-07-18 12:21:30 -0700392 return;
393 }
394
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700395 D("client: connected %s remote on fd %d", serial.c_str(), fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700396 close_on_exec(fd);
397 disable_tcp_nagle(fd);
398
David Pursellbfd95032016-02-22 14:27:23 -0800399 // Send a TCP keepalive ping to the device every second so we can detect disconnects.
400 if (!set_tcp_keepalive(fd, 1)) {
401 D("warning: failed to configure TCP keepalives (%s)", strerror(errno));
402 }
403
Elliott Hughese67f1f82015-04-30 17:32:03 -0700404 int ret = register_socket_transport(fd, serial.c_str(), port, 0);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700405 if (ret < 0) {
406 adb_close(fd);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700407 *response = android::base::StringPrintf("already connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700408 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700409 *response = android::base::StringPrintf("connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700410 }
411}
412
Elliott Hughese67f1f82015-04-30 17:32:03 -0700413void connect_emulator(const std::string& port_spec, std::string* response) {
414 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
415 if (pieces.size() != 2) {
416 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
417 port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700418 return;
419 }
420
Elliott Hughese67f1f82015-04-30 17:32:03 -0700421 int console_port = strtol(pieces[0].c_str(), NULL, 0);
422 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
423 if (console_port <= 0 || adb_port <= 0) {
424 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700425 return;
426 }
427
Elliott Hughese67f1f82015-04-30 17:32:03 -0700428 // Check if the emulator is already known.
429 // Note: There's a small but harmless race condition here: An emulator not
430 // present just yet could be registered by another invocation right
431 // after doing this check here. However, local_connect protects
432 // against double-registration too. From here, a better error message
433 // can be produced. In the case of the race condition, the very specific
434 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700435 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700436 if (known_emulator != nullptr) {
437 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700438 return;
439 }
440
Elliott Hughese67f1f82015-04-30 17:32:03 -0700441 // Check if more emulators can be registered. Similar unproblematic
442 // race condition as above.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700443 int candidate_slot = get_available_local_transport_index();
444 if (candidate_slot < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700445 *response = "Cannot accept more emulators";
Benoit Goby1c45ee92013-03-29 18:22:36 -0700446 return;
447 }
448
Elliott Hughese67f1f82015-04-30 17:32:03 -0700449 // Preconditions met, try to connect to the emulator.
Elliott Hughes381cfa92015-07-23 17:12:58 -0700450 std::string error;
451 if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700452 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
453 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700454 } else {
Elliott Hughes381cfa92015-07-23 17:12:58 -0700455 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s",
456 console_port, adb_port, error.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700457 }
458}
459
Alan Jeon4af3c402014-10-16 17:05:25 +0900460static void connect_service(int fd, void* data) {
461 char* host = reinterpret_cast<char*>(data);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700462 std::string response;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700463 if (!strncmp(host, "emu:", 4)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700464 connect_emulator(host + 4, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700465 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700466 connect_device(host, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700467 }
Alan Jeon4af3c402014-10-16 17:05:25 +0900468 free(host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700469
470 // Send response for emulator and device
Elliott Hughese67f1f82015-04-30 17:32:03 -0700471 SendProtocolString(fd, response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700472 adb_close(fd);
473}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800474#endif
475
476#if ADB_HOST
Elliott Hughesaa245492015-08-03 10:38:08 -0700477asocket* host_service_to_socket(const char* name, const char* serial) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800478 if (!strcmp(name,"track-devices")) {
479 return create_device_tracker();
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100480 } else if (android::base::StartsWith(name, "wait-for-")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800481 name += strlen("wait-for-");
482
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100483 std::unique_ptr<state_info> sinfo(new state_info);
484 if (sinfo == nullptr) {
485 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
486 return nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800487 }
488
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100489 if (serial) sinfo->serial = serial;
490
491 if (android::base::StartsWith(name, "local")) {
492 name += strlen("local");
493 sinfo->transport_type = kTransportLocal;
494 } else if (android::base::StartsWith(name, "usb")) {
495 name += strlen("usb");
496 sinfo->transport_type = kTransportUsb;
497 } else if (android::base::StartsWith(name, "any")) {
498 name += strlen("any");
499 sinfo->transport_type = kTransportAny;
500 } else {
501 return nullptr;
502 }
503
504 if (!strcmp(name, "-device")) {
505 sinfo->state = kCsDevice;
506 } else if (!strcmp(name, "-recovery")) {
507 sinfo->state = kCsRecovery;
508 } else if (!strcmp(name, "-sideload")) {
509 sinfo->state = kCsSideload;
510 } else if (!strcmp(name, "-bootloader")) {
511 sinfo->state = kCsBootloader;
Josh Gao86441c32016-04-13 12:18:58 -0700512 } else if (!strcmp(name, "-any")) {
513 sinfo->state = kCsAny;
Leo Sartre1fbc9db2015-11-27 18:56:48 +0100514 } else {
515 return nullptr;
516 }
517
518 int fd = create_service_thread(wait_for_state, sinfo.release());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800519 return create_local_socket(fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700520 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeon4af3c402014-10-16 17:05:25 +0900521 char* host = strdup(name + 8);
522 int fd = create_service_thread(connect_service, host);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700523 return create_local_socket(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800524 }
525 return NULL;
526}
527#endif /* ADB_HOST */