blob: a9edbe59f028d2de757fdf1445d9f01b5e527e3d [file] [log] [blame]
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Dan Albertdb6fe642015-03-19 15:21:08 -070017#define TRACE_TAG TRACE_SERVICES
18
19#include "sysdeps.h"
20
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080021#include <errno.h>
Dan Albertb302d122015-02-24 15:51:19 -080022#include <stddef.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
Dan Albert9c028f92015-05-15 12:56:23 -070027#if !ADB_HOST
28#include <pty.h>
29#include <termios.h>
30#endif
31
Dan Albertb302d122015-02-24 15:51:19 -080032#ifndef _WIN32
33#include <netdb.h>
34#include <netinet/in.h>
35#include <sys/ioctl.h>
36#include <unistd.h>
37#endif
38
Elliott Hughes88b4c852015-04-30 17:32:03 -070039#include <base/file.h>
Elliott Hughese4b64792015-04-17 20:11:08 -070040#include <base/stringprintf.h>
Elliott Hughes88b4c852015-04-30 17:32:03 -070041#include <base/strings.h>
Elliott Hughese4b64792015-04-17 20:11:08 -070042
Dan Albertb302d122015-02-24 15:51:19 -080043#if !ADB_HOST
44#include "cutils/android_reboot.h"
45#include "cutils/properties.h"
46#endif
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080047
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080048#include "adb.h"
Dan Albert66a91b02015-02-24 21:26:58 -080049#include "adb_io.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080050#include "file_sync_service.h"
Elliott Hughesdedf7672015-03-16 21:58:32 +000051#include "remount_service.h"
Dan Albertb302d122015-02-24 15:51:19 -080052#include "transport.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080053
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080054struct stinfo {
55 void (*func)(int fd, void *cookie);
56 int fd;
57 void *cookie;
58};
59
60
61void *service_bootstrap_func(void *x)
62{
Dan Albertf30d73c2015-02-25 17:51:28 -080063 stinfo* sti = reinterpret_cast<stinfo*>(x);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080064 sti->func(sti->fd, sti->cookie);
65 free(sti);
66 return 0;
67}
68
Benoit Goby12dc3692013-02-20 15:04:53 -080069#if !ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080070
Elliott Hughesfb596842015-05-01 17:04:38 -070071void restart_root_service(int fd, void *cookie) {
The Android Open Source Project9c753402009-03-13 13:04:37 -070072 if (getuid() == 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -070073 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Project9c753402009-03-13 13:04:37 -070074 adb_close(fd);
75 } else {
Elliott Hughesfb596842015-05-01 17:04:38 -070076 char value[PROPERTY_VALUE_MAX];
The Android Open Source Project9c753402009-03-13 13:04:37 -070077 property_get("ro.debuggable", value, "");
78 if (strcmp(value, "1") != 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -070079 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwood26b88e32009-08-24 15:58:40 -070080 adb_close(fd);
The Android Open Source Project9c753402009-03-13 13:04:37 -070081 return;
82 }
83
Benoit Gobyad926c12012-03-16 14:44:17 -070084 property_set("service.adb.root", "1");
Elliott Hughesfb596842015-05-01 17:04:38 -070085 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Project9c753402009-03-13 13:04:37 -070086 adb_close(fd);
The Android Open Source Project9c753402009-03-13 13:04:37 -070087 }
88}
89
Elliott Hughesfb596842015-05-01 17:04:38 -070090void restart_unroot_service(int fd, void *cookie) {
Dan Pasanenfb787d92014-10-06 12:57:20 -050091 if (getuid() != 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -070092 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanenfb787d92014-10-06 12:57:20 -050093 adb_close(fd);
94 } else {
95 property_set("service.adb.root", "0");
Elliott Hughesfb596842015-05-01 17:04:38 -070096 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanenfb787d92014-10-06 12:57:20 -050097 adb_close(fd);
98 }
99}
100
Elliott Hughesfb596842015-05-01 17:04:38 -0700101void restart_tcp_service(int fd, void *cookie) {
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800102 int port = (int) (uintptr_t) cookie;
Mike Lockwood26b88e32009-08-24 15:58:40 -0700103 if (port <= 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -0700104 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700105 adb_close(fd);
106 return;
107 }
108
Elliott Hughesfb596842015-05-01 17:04:38 -0700109 char value[PROPERTY_VALUE_MAX];
Mike Lockwood26b88e32009-08-24 15:58:40 -0700110 snprintf(value, sizeof(value), "%d", port);
111 property_set("service.adb.tcp.port", value);
Elliott Hughesfb596842015-05-01 17:04:38 -0700112 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700113 adb_close(fd);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700114}
115
Elliott Hughesfb596842015-05-01 17:04:38 -0700116void restart_usb_service(int fd, void *cookie) {
Mike Lockwood26b88e32009-08-24 15:58:40 -0700117 property_set("service.adb.tcp.port", "0");
Elliott Hughesfb596842015-05-01 17:04:38 -0700118 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwood26b88e32009-08-24 15:58:40 -0700119 adb_close(fd);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700120}
121
Tao Bao0db67642015-03-29 11:22:34 -0700122static bool reboot_service_impl(int fd, const char* arg) {
123 const char* reboot_arg = arg;
124 bool auto_reboot = false;
125
126 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) {
127 auto_reboot = true;
128 reboot_arg = "sideload";
129 }
130
Tao Bao0db67642015-03-29 11:22:34 -0700131 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot"
132 // in the command file.
133 if (strcmp(reboot_arg, "sideload") == 0) {
134 if (getuid() != 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700135 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao0db67642015-03-29 11:22:34 -0700136 return false;
137 }
138
139 const char* const recovery_dir = "/cache/recovery";
140 const char* const command_file = "/cache/recovery/command";
141 // Ensure /cache/recovery exists.
142 if (adb_mkdir(recovery_dir, 0770) == -1 && errno != EEXIST) {
143 D("Failed to create directory '%s': %s\n", recovery_dir, strerror(errno));
144 return false;
145 }
146
147 bool write_status = android::base::WriteStringToFile(
148 auto_reboot ? "--sideload_auto_reboot" : "--sideload", command_file);
149 if (!write_status) {
150 return false;
151 }
152
153 reboot_arg = "recovery";
154 }
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400155
156 sync();
Mike Lockwoodd49e9eb2010-02-24 16:07:23 -0500157
Tao Bao0db67642015-03-29 11:22:34 -0700158 char property_val[PROPERTY_VALUE_MAX];
159 int ret = snprintf(property_val, sizeof(property_val), "reboot,%s", reboot_arg);
160 if (ret >= static_cast<int>(sizeof(property_val))) {
Elliott Hughesfb596842015-05-01 17:04:38 -0700161 WriteFdFmt(fd, "reboot string too long: %d\n", ret);
Tao Bao0db67642015-03-29 11:22:34 -0700162 return false;
Nick Kralevichb7df0172013-04-18 12:20:02 -0700163 }
164
165 ret = property_set(ANDROID_RB_PROPERTY, property_val);
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400166 if (ret < 0) {
Elliott Hughesfb596842015-05-01 17:04:38 -0700167 WriteFdFmt(fd, "reboot failed: %d\n", ret);
Tao Bao0db67642015-03-29 11:22:34 -0700168 return false;
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400169 }
Tao Bao0db67642015-03-29 11:22:34 -0700170
171 return true;
172}
173
174void reboot_service(int fd, void* arg)
175{
176 if (reboot_service_impl(fd, static_cast<const char*>(arg))) {
177 // Don't return early. Give the reboot command time to take effect
178 // to avoid messing up scripts which do "adb reboot && adb wait-for-device"
Elliott Hughes7cf35752015-04-17 17:03:59 -0700179 while (true) {
Tao Bao0db67642015-03-29 11:22:34 -0700180 pause();
181 }
182 }
183
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400184 free(arg);
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400185 adb_close(fd);
186}
187
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100188void reverse_service(int fd, void* arg)
189{
Dan Albertf30d73c2015-02-25 17:51:28 -0800190 const char* command = reinterpret_cast<const char*>(arg);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100191
192 if (handle_forward_request(command, kTransportAny, NULL, fd) < 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700193 SendFail(fd, "not a reverse forwarding command");
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100194 }
195 free(arg);
196 adb_close(fd);
197}
198
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800199#endif
200
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800201static int create_service_thread(void (*func)(int, void *), void *cookie)
202{
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800203 int s[2];
Dan Albertf30d73c2015-02-25 17:51:28 -0800204 if (adb_socketpair(s)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800205 printf("cannot create service socket pair\n");
206 return -1;
207 }
leozwang1be54622014-08-15 09:51:27 -0700208 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800209
Dan Albertf30d73c2015-02-25 17:51:28 -0800210 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
211 if (sti == nullptr) {
212 fatal("cannot allocate stinfo");
213 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800214 sti->func = func;
215 sti->cookie = cookie;
216 sti->fd = s[1];
217
Elliott Hughesf2517142015-05-05 13:41:21 -0700218 if (!adb_thread_create(service_bootstrap_func, sti)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800219 free(sti);
220 adb_close(s[0]);
221 adb_close(s[1]);
222 printf("cannot create service thread\n");
223 return -1;
224 }
225
226 D("service thread started, %d:%d\n",s[0], s[1]);
227 return s[0];
228}
229
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700230#if !ADB_HOST
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700231
232static void init_subproc_child()
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800233{
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700234 setsid();
235
Rom Lemarchand9d837e52014-06-20 16:30:54 -0700236 // Set OOM score adjustment to prevent killing
Nick Kralevich777523e2014-07-18 20:57:35 -0700237 int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700238 if (fd >= 0) {
239 adb_write(fd, "0", 1);
240 adb_close(fd);
241 } else {
Rom Lemarchand9d837e52014-06-20 16:30:54 -0700242 D("adb: unable to update oom_score_adj\n");
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700243 }
244}
245
Dan Albert9c028f92015-05-15 12:56:23 -0700246#if !ADB_HOST
247static int create_subproc_pty(const char* cmd, const char* arg0,
248 const char* arg1, pid_t* pid) {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700249 D("create_subproc_pty(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
Dan Albert9c028f92015-05-15 12:56:23 -0700250 char pts_name[PATH_MAX];
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800251 int ptm;
Dan Albert9c028f92015-05-15 12:56:23 -0700252 *pid = forkpty(&ptm, pts_name, nullptr, nullptr);
253 if (*pid == -1) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800254 printf("- fork failed: %s -\n", strerror(errno));
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700255 adb_close(ptm);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800256 return -1;
257 }
258
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700259 if (*pid == 0) {
260 init_subproc_child();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800261
Dan Albert9c028f92015-05-15 12:56:23 -0700262 int pts = unix_open(pts_name, O_RDWR | O_CLOEXEC);
263 if (pts == -1) {
264 fprintf(stderr, "child failed to open pseudo-term slave %s: %s\n",
265 pts_name, strerror(errno));
266 adb_close(ptm);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700267 exit(-1);
268 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800269
Dan Albert9c028f92015-05-15 12:56:23 -0700270 // arg0 is "-c" in batch mode and "-" in interactive mode.
271 if (strcmp(arg0, "-c") == 0) {
272 termios tattr;
273 if (tcgetattr(pts, &tattr) == -1) {
274 fprintf(stderr, "tcgetattr failed: %s\n", strerror(errno));
275 adb_close(pts);
276 adb_close(ptm);
277 exit(-1);
278 }
279
280 cfmakeraw(&tattr);
281 if (tcsetattr(pts, TCSADRAIN, &tattr) == -1) {
282 fprintf(stderr, "tcsetattr failed: %s\n", strerror(errno));
283 adb_close(pts);
284 adb_close(ptm);
285 exit(-1);
286 }
287 }
288
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700289 dup2(pts, STDIN_FILENO);
290 dup2(pts, STDOUT_FILENO);
291 dup2(pts, STDERR_FILENO);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800292
Benoit Gobyf4ded742011-02-01 18:57:41 -0800293 adb_close(pts);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800294 adb_close(ptm);
295
Dan Albert9c028f92015-05-15 12:56:23 -0700296 execl(cmd, cmd, arg0, arg1, nullptr);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700297 fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
298 cmd, strerror(errno), errno);
299 exit(-1);
300 } else {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800301 return ptm;
302 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800303}
Dan Albert9c028f92015-05-15 12:56:23 -0700304#endif // !ADB_HOST
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700305
306static int create_subproc_raw(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
307{
308 D("create_subproc_raw(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
Yabin Cui2fa43212014-11-11 09:24:11 -0800309#if defined(_WIN32)
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700310 fprintf(stderr, "error: create_subproc_raw not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
311 return -1;
Yabin Cui2fa43212014-11-11 09:24:11 -0800312#else
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700313
314 // 0 is parent socket, 1 is child socket
315 int sv[2];
leozwang1be54622014-08-15 09:51:27 -0700316 if (adb_socketpair(sv) < 0) {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700317 printf("[ cannot create socket pair - %s ]\n", strerror(errno));
318 return -1;
319 }
leozwang1be54622014-08-15 09:51:27 -0700320 D("socketpair: (%d,%d)", sv[0], sv[1]);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700321
322 *pid = fork();
323 if (*pid < 0) {
324 printf("- fork failed: %s -\n", strerror(errno));
325 adb_close(sv[0]);
326 adb_close(sv[1]);
327 return -1;
328 }
329
330 if (*pid == 0) {
331 adb_close(sv[0]);
332 init_subproc_child();
333
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700334 dup2(sv[1], STDIN_FILENO);
335 dup2(sv[1], STDOUT_FILENO);
Jeff Sharkey0e0d2512014-06-09 17:30:57 -0700336 dup2(sv[1], STDERR_FILENO);
337
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700338 adb_close(sv[1]);
339
340 execl(cmd, cmd, arg0, arg1, NULL);
341 fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
342 cmd, strerror(errno), errno);
343 exit(-1);
344 } else {
345 adb_close(sv[1]);
346 return sv[0];
347 }
Yabin Cui2fa43212014-11-11 09:24:11 -0800348#endif /* !defined(_WIN32) */
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700349}
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700350#endif /* !ABD_HOST */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800351
352#if ADB_HOST
353#define SHELL_COMMAND "/bin/sh"
354#else
355#define SHELL_COMMAND "/system/bin/sh"
356#endif
357
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700358#if !ADB_HOST
359static void subproc_waiter_service(int fd, void *cookie)
360{
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800361 pid_t pid = (pid_t) (uintptr_t) cookie;
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700362
363 D("entered. fd=%d of pid=%d\n", fd, pid);
Elliott Hughes7cf35752015-04-17 17:03:59 -0700364 while (true) {
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700365 int status;
366 pid_t p = waitpid(pid, &status, 0);
367 if (p == pid) {
368 D("fd=%d, post waitpid(pid=%d) status=%04x\n", fd, p, status);
369 if (WIFSIGNALED(status)) {
370 D("*** Killed by signal %d\n", WTERMSIG(status));
371 break;
372 } else if (!WIFEXITED(status)) {
373 D("*** Didn't exit!!. status %d\n", status);
374 break;
375 } else if (WEXITSTATUS(status) >= 0) {
376 D("*** Exit code %d\n", WEXITSTATUS(status));
377 break;
378 }
379 }
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700380 }
381 D("shell exited fd=%d of pid=%d err=%d\n", fd, pid, errno);
382 if (SHELL_EXIT_NOTIFY_FD >=0) {
383 int res;
Dan Albert66a91b02015-02-24 21:26:58 -0800384 res = WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd)) ? 0 : -1;
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700385 D("notified shell exit via fd=%d for pid=%d res=%d errno=%d\n",
386 SHELL_EXIT_NOTIFY_FD, pid, res, errno);
387 }
388}
389
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700390static int create_subproc_thread(const char *name, bool pty = false) {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700391 const char *arg0, *arg1;
392 if (name == 0 || *name == 0) {
393 arg0 = "-"; arg1 = 0;
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700394 } else {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700395 arg0 = "-c"; arg1 = name;
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700396 }
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700397
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700398 pid_t pid = -1;
399 int ret_fd;
400 if (pty) {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700401 ret_fd = create_subproc_pty(SHELL_COMMAND, arg0, arg1, &pid);
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700402 } else {
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700403 ret_fd = create_subproc_raw(SHELL_COMMAND, arg0, arg1, &pid);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700404 }
405 D("create_subproc ret_fd=%d pid=%d\n", ret_fd, pid);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700406
Dan Albertf30d73c2015-02-25 17:51:28 -0800407 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700408 if(sti == 0) fatal("cannot allocate stinfo");
409 sti->func = subproc_waiter_service;
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800410 sti->cookie = (void*) (uintptr_t) pid;
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700411 sti->fd = ret_fd;
412
Elliott Hughesf2517142015-05-05 13:41:21 -0700413 if (!adb_thread_create(service_bootstrap_func, sti)) {
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700414 free(sti);
415 adb_close(ret_fd);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700416 fprintf(stderr, "cannot create service thread\n");
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700417 return -1;
418 }
419
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700420 D("service thread started, fd=%d pid=%d\n", ret_fd, pid);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700421 return ret_fd;
422}
423#endif
424
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800425int service_to_fd(const char *name)
426{
427 int ret = -1;
428
429 if(!strncmp(name, "tcp:", 4)) {
430 int port = atoi(name + 4);
431 name = strchr(name + 4, ':');
432 if(name == 0) {
433 ret = socket_loopback_client(port, SOCK_STREAM);
434 if (ret >= 0)
435 disable_tcp_nagle(ret);
436 } else {
437#if ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800438 ret = socket_network_client(name + 1, port, SOCK_STREAM);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800439#else
440 return -1;
441#endif
442 }
443#ifndef HAVE_WINSOCK /* winsock doesn't implement unix domain sockets */
444 } else if(!strncmp(name, "local:", 6)) {
445 ret = socket_local_client(name + 6,
446 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
447 } else if(!strncmp(name, "localreserved:", 14)) {
448 ret = socket_local_client(name + 14,
449 ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
450 } else if(!strncmp(name, "localabstract:", 14)) {
451 ret = socket_local_client(name + 14,
452 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
453 } else if(!strncmp(name, "localfilesystem:", 16)) {
454 ret = socket_local_client(name + 16,
455 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
456#endif
Benoit Goby12dc3692013-02-20 15:04:53 -0800457#if !ADB_HOST
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800458 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevich777523e2014-07-18 20:57:35 -0700459 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800460 } else if(!strncmp(name, "framebuffer:", 12)) {
461 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800462 } else if (!strncmp(name, "jdwp:", 5)) {
463 ret = create_jdwp_connection_fd(atoi(name+5));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800464 } else if(!HOST && !strncmp(name, "shell:", 6)) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700465 ret = create_subproc_thread(name + 6, true);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700466 } else if(!HOST && !strncmp(name, "exec:", 5)) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700467 ret = create_subproc_thread(name + 5);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800468 } else if(!strncmp(name, "sync:", 5)) {
469 ret = create_service_thread(file_sync_service, NULL);
470 } else if(!strncmp(name, "remount:", 8)) {
471 ret = create_service_thread(remount_service, NULL);
Mike Lockwood12a35ea2009-08-04 20:37:51 -0400472 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400473 void* arg = strdup(name + 7);
Jeff Sharkeyc52ec1a2014-05-26 18:30:43 -0700474 if (arg == NULL) return -1;
Mike Lockwood1a855ae2009-09-19 16:52:58 -0400475 ret = create_service_thread(reboot_service, arg);
The Android Open Source Project9c753402009-03-13 13:04:37 -0700476 } else if(!strncmp(name, "root:", 5)) {
477 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanenfb787d92014-10-06 12:57:20 -0500478 } else if(!strncmp(name, "unroot:", 7)) {
479 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tate73779122011-04-21 12:53:28 -0700480 } else if(!strncmp(name, "backup:", 7)) {
Elliott Hughese4b64792015-04-17 20:11:08 -0700481 ret = create_subproc_thread(android::base::StringPrintf("/system/bin/bu backup %s",
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700482 (name + 7)).c_str());
Christopher Tatecf5379b2011-05-17 15:52:54 -0700483 } else if(!strncmp(name, "restore:", 8)) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700484 ret = create_subproc_thread("/system/bin/bu restore");
Mike Lockwood26b88e32009-08-24 15:58:40 -0700485 } else if(!strncmp(name, "tcpip:", 6)) {
486 int port;
Spencer Low29a029c2015-01-25 17:38:36 -0800487 if (sscanf(name + 6, "%d", &port) != 1) {
Mike Lockwood26b88e32009-08-24 15:58:40 -0700488 port = 0;
489 }
Elliott Hughes9c0d9402014-01-16 10:53:11 -0800490 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwood26b88e32009-08-24 15:58:40 -0700491 } else if(!strncmp(name, "usb:", 4)) {
492 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100493 } else if (!strncmp(name, "reverse:", 8)) {
494 char* cookie = strdup(name + 8);
495 if (cookie == NULL) {
496 ret = -1;
497 } else {
498 ret = create_service_thread(reverse_service, cookie);
499 if (ret < 0) {
500 free(cookie);
501 }
502 }
Paul Lawrence5f356482014-10-09 14:22:49 +0000503 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence8ba2b022014-12-03 15:31:57 -0800504 ret = create_service_thread(set_verity_enabled_state_service, (void*)0);
505 } else if(!strncmp(name, "enable-verity:", 15)) {
506 ret = create_service_thread(set_verity_enabled_state_service, (void*)1);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800507#endif
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800508 }
509 if (ret >= 0) {
510 close_on_exec(ret);
511 }
512 return ret;
513}
514
515#if ADB_HOST
516struct state_info {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700517 TransportType transport_type;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800518 char* serial;
Dan Albert9a50f4c2015-05-18 16:43:57 -0700519 ConnectionState state;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800520};
521
522static void wait_for_state(int fd, void* cookie)
523{
Dan Albertf30d73c2015-02-25 17:51:28 -0800524 state_info* sinfo = reinterpret_cast<state_info*>(cookie);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800525
526 D("wait_for_state %d\n", sinfo->state);
527
Elliott Hughesab882422015-04-16 22:54:44 -0700528 std::string error_msg = "unknown error";
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700529 atransport* t = acquire_one_transport(sinfo->state, sinfo->transport_type, sinfo->serial,
530 &error_msg);
Elliott Hughesab882422015-04-16 22:54:44 -0700531 if (t != 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700532 SendOkay(fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800533 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700534 SendFail(fd, error_msg);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800535 }
536
537 if (sinfo->serial)
538 free(sinfo->serial);
539 free(sinfo);
540 adb_close(fd);
541 D("wait_for_state is done\n");
542}
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700543
Elliott Hughes88b4c852015-04-30 17:32:03 -0700544static void connect_device(const std::string& host, std::string* response) {
545 if (host.empty()) {
546 *response = "empty host name";
547 return;
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700548 }
549
Elliott Hughes88b4c852015-04-30 17:32:03 -0700550 std::vector<std::string> pieces = android::base::Split(host, ":");
551 const std::string& hostname = pieces[0];
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700552
Elliott Hughes88b4c852015-04-30 17:32:03 -0700553 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
554 if (pieces.size() > 1) {
555 if (sscanf(pieces[1].c_str(), "%d", &port) != 1) {
556 *response = android::base::StringPrintf("bad port number %s", pieces[1].c_str());
557 return;
558 }
559 }
560
561 // This may look like we're putting 'host' back together,
562 // but we're actually inserting the default port if necessary.
563 std::string serial = android::base::StringPrintf("%s:%d", hostname.c_str(), port);
564
565 int fd = socket_network_client_timeout(hostname.c_str(), port, SOCK_STREAM, 10);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700566 if (fd < 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700567 *response = android::base::StringPrintf("unable to connect to %s:%d",
568 hostname.c_str(), port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700569 return;
570 }
571
572 D("client: connected on remote on fd %d\n", fd);
573 close_on_exec(fd);
574 disable_tcp_nagle(fd);
575
Elliott Hughes88b4c852015-04-30 17:32:03 -0700576 int ret = register_socket_transport(fd, serial.c_str(), port, 0);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700577 if (ret < 0) {
578 adb_close(fd);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700579 *response = android::base::StringPrintf("already connected to %s", serial.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700580 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700581 *response = android::base::StringPrintf("connected to %s", serial.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700582 }
583}
584
Elliott Hughes88b4c852015-04-30 17:32:03 -0700585void connect_emulator(const std::string& port_spec, std::string* response) {
586 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
587 if (pieces.size() != 2) {
588 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
589 port_spec.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700590 return;
591 }
592
Elliott Hughes88b4c852015-04-30 17:32:03 -0700593 int console_port = strtol(pieces[0].c_str(), NULL, 0);
594 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
595 if (console_port <= 0 || adb_port <= 0) {
596 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700597 return;
598 }
599
Elliott Hughes88b4c852015-04-30 17:32:03 -0700600 // Check if the emulator is already known.
601 // Note: There's a small but harmless race condition here: An emulator not
602 // present just yet could be registered by another invocation right
603 // after doing this check here. However, local_connect protects
604 // against double-registration too. From here, a better error message
605 // can be produced. In the case of the race condition, the very specific
606 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700607 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700608 if (known_emulator != nullptr) {
609 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700610 return;
611 }
612
Elliott Hughes88b4c852015-04-30 17:32:03 -0700613 // Check if more emulators can be registered. Similar unproblematic
614 // race condition as above.
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700615 int candidate_slot = get_available_local_transport_index();
616 if (candidate_slot < 0) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700617 *response = "Cannot accept more emulators";
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700618 return;
619 }
620
Elliott Hughes88b4c852015-04-30 17:32:03 -0700621 // Preconditions met, try to connect to the emulator.
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700622 if (!local_connect_arbitrary_ports(console_port, adb_port)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700623 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
624 console_port, adb_port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700625 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700626 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d",
627 console_port, adb_port);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700628 }
629}
630
Alan Jeone6959b72014-10-16 17:05:25 +0900631static void connect_service(int fd, void* data) {
632 char* host = reinterpret_cast<char*>(data);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700633 std::string response;
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700634 if (!strncmp(host, "emu:", 4)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700635 connect_emulator(host + 4, &response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700636 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700637 connect_device(host, &response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700638 }
Alan Jeone6959b72014-10-16 17:05:25 +0900639 free(host);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700640
641 // Send response for emulator and device
Elliott Hughes88b4c852015-04-30 17:32:03 -0700642 SendProtocolString(fd, response);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700643 adb_close(fd);
644}
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800645#endif
646
647#if ADB_HOST
648asocket* host_service_to_socket(const char* name, const char *serial)
649{
650 if (!strcmp(name,"track-devices")) {
651 return create_device_tracker();
652 } else if (!strncmp(name, "wait-for-", strlen("wait-for-"))) {
Dan Albertf30d73c2015-02-25 17:51:28 -0800653 auto sinfo = reinterpret_cast<state_info*>(malloc(sizeof(state_info)));
Elliott Hughesd0269c92015-04-21 19:39:52 -0700654 if (sinfo == nullptr) {
655 fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno));
656 return NULL;
657 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800658
659 if (serial)
660 sinfo->serial = strdup(serial);
661 else
662 sinfo->serial = NULL;
663
664 name += strlen("wait-for-");
665
666 if (!strncmp(name, "local", strlen("local"))) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700667 sinfo->transport_type = kTransportLocal;
Dan Albert9a50f4c2015-05-18 16:43:57 -0700668 sinfo->state = kCsDevice;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800669 } else if (!strncmp(name, "usb", strlen("usb"))) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700670 sinfo->transport_type = kTransportUsb;
Dan Albert9a50f4c2015-05-18 16:43:57 -0700671 sinfo->state = kCsDevice;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800672 } else if (!strncmp(name, "any", strlen("any"))) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700673 sinfo->transport_type = kTransportAny;
Dan Albert9a50f4c2015-05-18 16:43:57 -0700674 sinfo->state = kCsDevice;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800675 } else {
Alan Jeone6959b72014-10-16 17:05:25 +0900676 if (sinfo->serial) {
677 free(sinfo->serial);
678 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800679 free(sinfo);
680 return NULL;
681 }
682
683 int fd = create_service_thread(wait_for_state, sinfo);
684 return create_local_socket(fd);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700685 } else if (!strncmp(name, "connect:", 8)) {
Alan Jeone6959b72014-10-16 17:05:25 +0900686 char* host = strdup(name + 8);
687 int fd = create_service_thread(connect_service, host);
Benoit Goby3f9f9ce2013-03-29 18:22:36 -0700688 return create_local_socket(fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800689 }
690 return NULL;
691}
692#endif /* ADB_HOST */