blob: 184744717ce464d4665fd8bc18986cbd26e62c66 [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
Dan Albert33134262015-03-19 15:21:08 -070017#define TRACE_TAG TRACE_SERVICES
18
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 Hughese67f1f82015-04-30 17:32:03 -070034#include <base/file.h>
Elliott Hughes6c34bba2015-04-17 20:11:08 -070035#include <base/stringprintf.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070036#include <base/strings.h>
Elliott Hughes6c34bba2015-04-17 20:11:08 -070037
Dan Albert76649012015-02-24 15:51:19 -080038#if !ADB_HOST
39#include "cutils/android_reboot.h"
40#include "cutils/properties.h"
41#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080043#include "adb.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080044#include "adb_io.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080045#include "file_sync_service.h"
Elliott Hughesec7a6672015-03-16 21:58:32 +000046#include "remount_service.h"
Dan Albert76649012015-02-24 15:51:19 -080047#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080048
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080049struct stinfo {
50 void (*func)(int fd, void *cookie);
51 int fd;
52 void *cookie;
53};
54
55
56void *service_bootstrap_func(void *x)
57{
Dan Albertbac34742015-02-25 17:51:28 -080058 stinfo* sti = reinterpret_cast<stinfo*>(x);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080059 sti->func(sti->fd, sti->cookie);
60 free(sti);
61 return 0;
62}
63
Benoit Goby9470c2f2013-02-20 15:04:53 -080064#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080065
Elliott Hughesab52c182015-05-01 17:04:38 -070066void restart_root_service(int fd, void *cookie) {
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070067 if (getuid() == 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070068 WriteFdExactly(fd, "adbd is already running as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070069 adb_close(fd);
70 } else {
Elliott Hughesab52c182015-05-01 17:04:38 -070071 char value[PROPERTY_VALUE_MAX];
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070072 property_get("ro.debuggable", value, "");
73 if (strcmp(value, "1") != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070074 WriteFdExactly(fd, "adbd cannot run as root in production builds\n");
Mike Lockwoodff196702009-08-24 15:58:40 -070075 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070076 return;
77 }
78
Benoit Goby7941cf82012-03-16 14:44:17 -070079 property_set("service.adb.root", "1");
Elliott Hughesab52c182015-05-01 17:04:38 -070080 WriteFdExactly(fd, "restarting adbd as root\n");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070081 adb_close(fd);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -070082 }
83}
84
Elliott Hughesab52c182015-05-01 17:04:38 -070085void restart_unroot_service(int fd, void *cookie) {
Dan Pasanen98858812014-10-06 12:57:20 -050086 if (getuid() != 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070087 WriteFdExactly(fd, "adbd not running as root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050088 adb_close(fd);
89 } else {
90 property_set("service.adb.root", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -070091 WriteFdExactly(fd, "restarting adbd as non root\n");
Dan Pasanen98858812014-10-06 12:57:20 -050092 adb_close(fd);
93 }
94}
95
Elliott Hughesab52c182015-05-01 17:04:38 -070096void restart_tcp_service(int fd, void *cookie) {
Elliott Hughesccecf142014-01-16 10:53:11 -080097 int port = (int) (uintptr_t) cookie;
Mike Lockwoodff196702009-08-24 15:58:40 -070098 if (port <= 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -070099 WriteFdFmt(fd, "invalid port %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700100 adb_close(fd);
101 return;
102 }
103
Elliott Hughesab52c182015-05-01 17:04:38 -0700104 char value[PROPERTY_VALUE_MAX];
Mike Lockwoodff196702009-08-24 15:58:40 -0700105 snprintf(value, sizeof(value), "%d", port);
106 property_set("service.adb.tcp.port", value);
Elliott Hughesab52c182015-05-01 17:04:38 -0700107 WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700108 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700109}
110
Elliott Hughesab52c182015-05-01 17:04:38 -0700111void restart_usb_service(int fd, void *cookie) {
Mike Lockwoodff196702009-08-24 15:58:40 -0700112 property_set("service.adb.tcp.port", "0");
Elliott Hughesab52c182015-05-01 17:04:38 -0700113 WriteFdExactly(fd, "restarting in USB mode\n");
Mike Lockwoodff196702009-08-24 15:58:40 -0700114 adb_close(fd);
Mike Lockwoodff196702009-08-24 15:58:40 -0700115}
116
Tao Bao175b7bb2015-03-29 11:22:34 -0700117static bool reboot_service_impl(int fd, const char* arg) {
118 const char* reboot_arg = arg;
119 bool auto_reboot = false;
120
121 if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) {
122 auto_reboot = true;
123 reboot_arg = "sideload";
124 }
125
Tao Bao175b7bb2015-03-29 11:22:34 -0700126 // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot"
127 // in the command file.
128 if (strcmp(reboot_arg, "sideload") == 0) {
129 if (getuid() != 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700130 WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n");
Tao Bao175b7bb2015-03-29 11:22:34 -0700131 return false;
132 }
133
134 const char* const recovery_dir = "/cache/recovery";
135 const char* const command_file = "/cache/recovery/command";
136 // Ensure /cache/recovery exists.
137 if (adb_mkdir(recovery_dir, 0770) == -1 && errno != EEXIST) {
138 D("Failed to create directory '%s': %s\n", recovery_dir, strerror(errno));
139 return false;
140 }
141
142 bool write_status = android::base::WriteStringToFile(
143 auto_reboot ? "--sideload_auto_reboot" : "--sideload", command_file);
144 if (!write_status) {
145 return false;
146 }
147
148 reboot_arg = "recovery";
149 }
Mike Lockwoodee156622009-08-04 20:37:51 -0400150
151 sync();
Mike Lockwoodd969faa2010-02-24 16:07:23 -0500152
Tao Bao175b7bb2015-03-29 11:22:34 -0700153 char property_val[PROPERTY_VALUE_MAX];
154 int ret = snprintf(property_val, sizeof(property_val), "reboot,%s", reboot_arg);
155 if (ret >= static_cast<int>(sizeof(property_val))) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700156 WriteFdFmt(fd, "reboot string too long: %d\n", ret);
Tao Bao175b7bb2015-03-29 11:22:34 -0700157 return false;
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700158 }
159
160 ret = property_set(ANDROID_RB_PROPERTY, property_val);
Mike Lockwoodee156622009-08-04 20:37:51 -0400161 if (ret < 0) {
Elliott Hughesab52c182015-05-01 17:04:38 -0700162 WriteFdFmt(fd, "reboot failed: %d\n", ret);
Tao Bao175b7bb2015-03-29 11:22:34 -0700163 return false;
Mike Lockwoodee156622009-08-04 20:37:51 -0400164 }
Tao Bao175b7bb2015-03-29 11:22:34 -0700165
166 return true;
167}
168
169void reboot_service(int fd, void* arg)
170{
171 if (reboot_service_impl(fd, static_cast<const char*>(arg))) {
172 // Don't return early. Give the reboot command time to take effect
173 // to avoid messing up scripts which do "adb reboot && adb wait-for-device"
Elliott Hughesa7090b92015-04-17 17:03:59 -0700174 while (true) {
Tao Bao175b7bb2015-03-29 11:22:34 -0700175 pause();
176 }
177 }
178
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400179 free(arg);
Mike Lockwoodee156622009-08-04 20:37:51 -0400180 adb_close(fd);
181}
182
David 'Digit' Turner25258692013-03-21 21:07:42 +0100183void reverse_service(int fd, void* arg)
184{
Dan Albertbac34742015-02-25 17:51:28 -0800185 const char* command = reinterpret_cast<const char*>(arg);
David 'Digit' Turner25258692013-03-21 21:07:42 +0100186
187 if (handle_forward_request(command, kTransportAny, NULL, fd) < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700188 SendFail(fd, "not a reverse forwarding command");
David 'Digit' Turner25258692013-03-21 21:07:42 +0100189 }
190 free(arg);
191 adb_close(fd);
192}
193
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800194#endif
195
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800196static int create_service_thread(void (*func)(int, void *), void *cookie)
197{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800198 int s[2];
Dan Albertbac34742015-02-25 17:51:28 -0800199 if (adb_socketpair(s)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800200 printf("cannot create service socket pair\n");
201 return -1;
202 }
leozwangcbf02672014-08-15 09:51:27 -0700203 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800204
Dan Albertbac34742015-02-25 17:51:28 -0800205 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
206 if (sti == nullptr) {
207 fatal("cannot allocate stinfo");
208 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800209 sti->func = func;
210 sti->cookie = cookie;
211 sti->fd = s[1];
212
Dan Albertbac34742015-02-25 17:51:28 -0800213 adb_thread_t t;
214 if (adb_thread_create(&t, service_bootstrap_func, sti)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800215 free(sti);
216 adb_close(s[0]);
217 adb_close(s[1]);
218 printf("cannot create service thread\n");
219 return -1;
220 }
221
222 D("service thread started, %d:%d\n",s[0], s[1]);
223 return s[0];
224}
225
JP Abgrall408fa572011-03-16 15:57:42 -0700226#if !ADB_HOST
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700227
228static void init_subproc_child()
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800229{
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700230 setsid();
231
Rom Lemarchand07ce7ca2014-06-20 16:30:54 -0700232 // Set OOM score adjustment to prevent killing
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700233 int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700234 if (fd >= 0) {
235 adb_write(fd, "0", 1);
236 adb_close(fd);
237 } else {
Rom Lemarchand07ce7ca2014-06-20 16:30:54 -0700238 D("adb: unable to update oom_score_adj\n");
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700239 }
240}
241
242static int create_subproc_pty(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
243{
244 D("create_subproc_pty(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
Yabin Cuie77b6a02014-11-11 09:24:11 -0800245#if defined(_WIN32)
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700246 fprintf(stderr, "error: create_subproc_pty not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
JP Abgrall408fa572011-03-16 15:57:42 -0700247 return -1;
Yabin Cuie77b6a02014-11-11 09:24:11 -0800248#else
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800249 int ptm;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800250
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700251 ptm = unix_open("/dev/ptmx", O_RDWR | O_CLOEXEC); // | O_NOCTTY);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800252 if(ptm < 0){
253 printf("[ cannot open /dev/ptmx - %s ]\n",strerror(errno));
254 return -1;
255 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800256
Elliott Hughesd2352882014-07-29 11:32:16 -0700257 char devname[64];
258 if(grantpt(ptm) || unlockpt(ptm) || ptsname_r(ptm, devname, sizeof(devname)) != 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800259 printf("[ trouble with /dev/ptmx - %s ]\n", strerror(errno));
JP Abgrall408fa572011-03-16 15:57:42 -0700260 adb_close(ptm);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800261 return -1;
262 }
263
JP Abgrall408fa572011-03-16 15:57:42 -0700264 *pid = fork();
265 if(*pid < 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800266 printf("- fork failed: %s -\n", strerror(errno));
JP Abgrall408fa572011-03-16 15:57:42 -0700267 adb_close(ptm);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800268 return -1;
269 }
270
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700271 if (*pid == 0) {
272 init_subproc_child();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800273
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700274 int pts = unix_open(devname, O_RDWR | O_CLOEXEC);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700275 if (pts < 0) {
JP Abgrall408fa572011-03-16 15:57:42 -0700276 fprintf(stderr, "child failed to open pseudo-term slave: %s\n", devname);
277 exit(-1);
278 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800279
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700280 dup2(pts, STDIN_FILENO);
281 dup2(pts, STDOUT_FILENO);
282 dup2(pts, STDERR_FILENO);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800283
Benoit Goby95ef8282011-02-01 18:57:41 -0800284 adb_close(pts);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800285 adb_close(ptm);
286
JP Abgrall408fa572011-03-16 15:57:42 -0700287 execl(cmd, cmd, arg0, arg1, NULL);
288 fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
289 cmd, strerror(errno), errno);
290 exit(-1);
291 } else {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800292 return ptm;
293 }
Yabin Cuie77b6a02014-11-11 09:24:11 -0800294#endif /* !defined(_WIN32) */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800295}
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700296
297static int create_subproc_raw(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
298{
299 D("create_subproc_raw(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
Yabin Cuie77b6a02014-11-11 09:24:11 -0800300#if defined(_WIN32)
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700301 fprintf(stderr, "error: create_subproc_raw not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
302 return -1;
Yabin Cuie77b6a02014-11-11 09:24:11 -0800303#else
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700304
305 // 0 is parent socket, 1 is child socket
306 int sv[2];
leozwangcbf02672014-08-15 09:51:27 -0700307 if (adb_socketpair(sv) < 0) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700308 printf("[ cannot create socket pair - %s ]\n", strerror(errno));
309 return -1;
310 }
leozwangcbf02672014-08-15 09:51:27 -0700311 D("socketpair: (%d,%d)", sv[0], sv[1]);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700312
313 *pid = fork();
314 if (*pid < 0) {
315 printf("- fork failed: %s -\n", strerror(errno));
316 adb_close(sv[0]);
317 adb_close(sv[1]);
318 return -1;
319 }
320
321 if (*pid == 0) {
322 adb_close(sv[0]);
323 init_subproc_child();
324
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700325 dup2(sv[1], STDIN_FILENO);
326 dup2(sv[1], STDOUT_FILENO);
Jeff Sharkey960df972014-06-09 17:30:57 -0700327 dup2(sv[1], STDERR_FILENO);
328
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700329 adb_close(sv[1]);
330
331 execl(cmd, cmd, arg0, arg1, NULL);
332 fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
333 cmd, strerror(errno), errno);
334 exit(-1);
335 } else {
336 adb_close(sv[1]);
337 return sv[0];
338 }
Yabin Cuie77b6a02014-11-11 09:24:11 -0800339#endif /* !defined(_WIN32) */
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700340}
JP Abgrall408fa572011-03-16 15:57:42 -0700341#endif /* !ABD_HOST */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800342
343#if ADB_HOST
344#define SHELL_COMMAND "/bin/sh"
345#else
346#define SHELL_COMMAND "/system/bin/sh"
347#endif
348
JP Abgrall408fa572011-03-16 15:57:42 -0700349#if !ADB_HOST
350static void subproc_waiter_service(int fd, void *cookie)
351{
Elliott Hughesccecf142014-01-16 10:53:11 -0800352 pid_t pid = (pid_t) (uintptr_t) cookie;
JP Abgrall408fa572011-03-16 15:57:42 -0700353
354 D("entered. fd=%d of pid=%d\n", fd, pid);
Elliott Hughesa7090b92015-04-17 17:03:59 -0700355 while (true) {
JP Abgrall408fa572011-03-16 15:57:42 -0700356 int status;
357 pid_t p = waitpid(pid, &status, 0);
358 if (p == pid) {
359 D("fd=%d, post waitpid(pid=%d) status=%04x\n", fd, p, status);
360 if (WIFSIGNALED(status)) {
361 D("*** Killed by signal %d\n", WTERMSIG(status));
362 break;
363 } else if (!WIFEXITED(status)) {
364 D("*** Didn't exit!!. status %d\n", status);
365 break;
366 } else if (WEXITSTATUS(status) >= 0) {
367 D("*** Exit code %d\n", WEXITSTATUS(status));
368 break;
369 }
370 }
JP Abgrall408fa572011-03-16 15:57:42 -0700371 }
372 D("shell exited fd=%d of pid=%d err=%d\n", fd, pid, errno);
373 if (SHELL_EXIT_NOTIFY_FD >=0) {
374 int res;
Dan Albertcc731cc2015-02-24 21:26:58 -0800375 res = WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd)) ? 0 : -1;
JP Abgrall408fa572011-03-16 15:57:42 -0700376 D("notified shell exit via fd=%d for pid=%d res=%d errno=%d\n",
377 SHELL_EXIT_NOTIFY_FD, pid, res, errno);
378 }
379}
380
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700381static int create_subproc_thread(const char *name, const subproc_mode mode)
JP Abgrall408fa572011-03-16 15:57:42 -0700382{
JP Abgrall408fa572011-03-16 15:57:42 -0700383 adb_thread_t t;
384 int ret_fd;
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700385 pid_t pid = -1;
386
387 const char *arg0, *arg1;
388 if (name == 0 || *name == 0) {
389 arg0 = "-"; arg1 = 0;
JP Abgrall408fa572011-03-16 15:57:42 -0700390 } else {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700391 arg0 = "-c"; arg1 = name;
JP Abgrall408fa572011-03-16 15:57:42 -0700392 }
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700393
394 switch (mode) {
395 case SUBPROC_PTY:
396 ret_fd = create_subproc_pty(SHELL_COMMAND, arg0, arg1, &pid);
397 break;
398 case SUBPROC_RAW:
399 ret_fd = create_subproc_raw(SHELL_COMMAND, arg0, arg1, &pid);
400 break;
401 default:
402 fprintf(stderr, "invalid subproc_mode %d\n", mode);
403 return -1;
404 }
405 D("create_subproc ret_fd=%d pid=%d\n", ret_fd, pid);
JP Abgrall408fa572011-03-16 15:57:42 -0700406
Dan Albertbac34742015-02-25 17:51:28 -0800407 stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
JP Abgrall408fa572011-03-16 15:57:42 -0700408 if(sti == 0) fatal("cannot allocate stinfo");
409 sti->func = subproc_waiter_service;
Elliott Hughesccecf142014-01-16 10:53:11 -0800410 sti->cookie = (void*) (uintptr_t) pid;
JP Abgrall408fa572011-03-16 15:57:42 -0700411 sti->fd = ret_fd;
412
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700413 if (adb_thread_create(&t, service_bootstrap_func, sti)) {
JP Abgrall408fa572011-03-16 15:57:42 -0700414 free(sti);
415 adb_close(ret_fd);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700416 fprintf(stderr, "cannot create service thread\n");
JP Abgrall408fa572011-03-16 15:57:42 -0700417 return -1;
418 }
419
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700420 D("service thread started, fd=%d pid=%d\n", ret_fd, pid);
JP Abgrall408fa572011-03-16 15:57:42 -0700421 return ret_fd;
422}
423#endif
424
The Android Open Source Projectdd7bc332009-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 Projectdd7bc332009-03-03 19:32:55 -0800438 ret = socket_network_client(name + 1, port, SOCK_STREAM);
The Android Open Source Projectdd7bc332009-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 Goby9470c2f2013-02-20 15:04:53 -0800457#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800458 } else if(!strncmp("dev:", name, 4)) {
Nick Kralevichfe8d7f42014-07-18 20:57:35 -0700459 ret = unix_open(name + 4, O_RDWR | O_CLOEXEC);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800460 } else if(!strncmp(name, "framebuffer:", 12)) {
461 ret = create_service_thread(framebuffer_service, 0);
The Android Open Source Projectdd7bc332009-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 Projectdd7bc332009-03-03 19:32:55 -0800464 } else if(!HOST && !strncmp(name, "shell:", 6)) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700465 ret = create_subproc_thread(name + 6, SUBPROC_PTY);
466 } else if(!HOST && !strncmp(name, "exec:", 5)) {
467 ret = create_subproc_thread(name + 5, SUBPROC_RAW);
The Android Open Source Projectdd7bc332009-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 Lockwoodee156622009-08-04 20:37:51 -0400472 } else if(!strncmp(name, "reboot:", 7)) {
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400473 void* arg = strdup(name + 7);
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700474 if (arg == NULL) return -1;
Mike Lockwoodb6b40072009-09-19 16:52:58 -0400475 ret = create_service_thread(reboot_service, arg);
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700476 } else if(!strncmp(name, "root:", 5)) {
477 ret = create_service_thread(restart_root_service, NULL);
Dan Pasanen98858812014-10-06 12:57:20 -0500478 } else if(!strncmp(name, "unroot:", 7)) {
479 ret = create_service_thread(restart_unroot_service, NULL);
Christopher Tated2f54152011-04-21 12:53:28 -0700480 } else if(!strncmp(name, "backup:", 7)) {
Elliott Hughes6c34bba2015-04-17 20:11:08 -0700481 ret = create_subproc_thread(android::base::StringPrintf("/system/bin/bu backup %s",
482 (name + 7)).c_str(), SUBPROC_RAW);
Christopher Tate702967a2011-05-17 15:52:54 -0700483 } else if(!strncmp(name, "restore:", 8)) {
Jeff Sharkey5d9d4342014-05-26 18:30:43 -0700484 ret = create_subproc_thread("/system/bin/bu restore", SUBPROC_RAW);
Mike Lockwoodff196702009-08-24 15:58:40 -0700485 } else if(!strncmp(name, "tcpip:", 6)) {
486 int port;
Spencer Low943ef232015-01-25 17:38:36 -0800487 if (sscanf(name + 6, "%d", &port) != 1) {
Mike Lockwoodff196702009-08-24 15:58:40 -0700488 port = 0;
489 }
Elliott Hughesccecf142014-01-16 10:53:11 -0800490 ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700491 } else if(!strncmp(name, "usb:", 4)) {
492 ret = create_service_thread(restart_usb_service, NULL);
David 'Digit' Turner25258692013-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 Lawrenceec900bb2014-10-09 14:22:49 +0000503 } else if(!strncmp(name, "disable-verity:", 15)) {
Paul Lawrence982089d2014-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 Projectdd7bc332009-03-03 19:32:55 -0800507#endif
The Android Open Source Projectdd7bc332009-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 {
517 transport_type transport;
518 char* serial;
519 int state;
520};
521
522static void wait_for_state(int fd, void* cookie)
523{
Dan Albertbac34742015-02-25 17:51:28 -0800524 state_info* sinfo = reinterpret_cast<state_info*>(cookie);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800525
526 D("wait_for_state %d\n", sinfo->state);
527
Elliott Hughes7be29c82015-04-16 22:54:44 -0700528 std::string error_msg = "unknown error";
529 atransport* t = acquire_one_transport(sinfo->state, sinfo->transport, sinfo->serial, &error_msg);
530 if (t != 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700531 SendOkay(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800532 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700533 SendFail(fd, error_msg);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800534 }
535
536 if (sinfo->serial)
537 free(sinfo->serial);
538 free(sinfo);
539 adb_close(fd);
540 D("wait_for_state is done\n");
541}
Benoit Goby1c45ee92013-03-29 18:22:36 -0700542
Elliott Hughese67f1f82015-04-30 17:32:03 -0700543static void connect_device(const std::string& host, std::string* response) {
544 if (host.empty()) {
545 *response = "empty host name";
546 return;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700547 }
548
Elliott Hughese67f1f82015-04-30 17:32:03 -0700549 std::vector<std::string> pieces = android::base::Split(host, ":");
550 const std::string& hostname = pieces[0];
Benoit Goby1c45ee92013-03-29 18:22:36 -0700551
Elliott Hughese67f1f82015-04-30 17:32:03 -0700552 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
553 if (pieces.size() > 1) {
554 if (sscanf(pieces[1].c_str(), "%d", &port) != 1) {
555 *response = android::base::StringPrintf("bad port number %s", pieces[1].c_str());
556 return;
557 }
558 }
559
560 // This may look like we're putting 'host' back together,
561 // but we're actually inserting the default port if necessary.
562 std::string serial = android::base::StringPrintf("%s:%d", hostname.c_str(), port);
563
564 int fd = socket_network_client_timeout(hostname.c_str(), port, SOCK_STREAM, 10);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700565 if (fd < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700566 *response = android::base::StringPrintf("unable to connect to %s:%d",
567 hostname.c_str(), port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700568 return;
569 }
570
571 D("client: connected on remote on fd %d\n", fd);
572 close_on_exec(fd);
573 disable_tcp_nagle(fd);
574
Elliott Hughese67f1f82015-04-30 17:32:03 -0700575 int ret = register_socket_transport(fd, serial.c_str(), port, 0);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700576 if (ret < 0) {
577 adb_close(fd);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700578 *response = android::base::StringPrintf("already connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700579 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700580 *response = android::base::StringPrintf("connected to %s", serial.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700581 }
582}
583
Elliott Hughese67f1f82015-04-30 17:32:03 -0700584void connect_emulator(const std::string& port_spec, std::string* response) {
585 std::vector<std::string> pieces = android::base::Split(port_spec, ",");
586 if (pieces.size() != 2) {
587 *response = android::base::StringPrintf("unable to parse '%s' as <console port>,<adb port>",
588 port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700589 return;
590 }
591
Elliott Hughese67f1f82015-04-30 17:32:03 -0700592 int console_port = strtol(pieces[0].c_str(), NULL, 0);
593 int adb_port = strtol(pieces[1].c_str(), NULL, 0);
594 if (console_port <= 0 || adb_port <= 0) {
595 *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str());
Benoit Goby1c45ee92013-03-29 18:22:36 -0700596 return;
597 }
598
Elliott Hughese67f1f82015-04-30 17:32:03 -0700599 // Check if the emulator is already known.
600 // Note: There's a small but harmless race condition here: An emulator not
601 // present just yet could be registered by another invocation right
602 // after doing this check here. However, local_connect protects
603 // against double-registration too. From here, a better error message
604 // can be produced. In the case of the race condition, the very specific
605 // error message won't be shown, but the data doesn't get corrupted.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700606 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700607 if (known_emulator != nullptr) {
608 *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700609 return;
610 }
611
Elliott Hughese67f1f82015-04-30 17:32:03 -0700612 // Check if more emulators can be registered. Similar unproblematic
613 // race condition as above.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700614 int candidate_slot = get_available_local_transport_index();
615 if (candidate_slot < 0) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700616 *response = "Cannot accept more emulators";
Benoit Goby1c45ee92013-03-29 18:22:36 -0700617 return;
618 }
619
Elliott Hughese67f1f82015-04-30 17:32:03 -0700620 // Preconditions met, try to connect to the emulator.
Benoit Goby1c45ee92013-03-29 18:22:36 -0700621 if (!local_connect_arbitrary_ports(console_port, adb_port)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700622 *response = android::base::StringPrintf("Connected to emulator on ports %d,%d",
623 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700624 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700625 *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d",
626 console_port, adb_port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700627 }
628}
629
630static void connect_service(int fd, void* cookie)
631{
Dan Albertbac34742015-02-25 17:51:28 -0800632 char *host = reinterpret_cast<char*>(cookie);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700633
Elliott Hughese67f1f82015-04-30 17:32:03 -0700634 std::string response;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700635 if (!strncmp(host, "emu:", 4)) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700636 connect_emulator(host + 4, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700637 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700638 connect_device(host, &response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700639 }
640
641 // Send response for emulator and device
Elliott Hughese67f1f82015-04-30 17:32:03 -0700642 SendProtocolString(fd, response);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700643 adb_close(fd);
644}
The Android Open Source Projectdd7bc332009-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 Albertbac34742015-02-25 17:51:28 -0800653 auto sinfo = reinterpret_cast<state_info*>(malloc(sizeof(state_info)));
Elliott Hughesdc3b4592015-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 Projectdd7bc332009-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"))) {
667 sinfo->transport = kTransportLocal;
668 sinfo->state = CS_DEVICE;
669 } else if (!strncmp(name, "usb", strlen("usb"))) {
670 sinfo->transport = kTransportUsb;
671 sinfo->state = CS_DEVICE;
672 } else if (!strncmp(name, "any", strlen("any"))) {
673 sinfo->transport = kTransportAny;
674 sinfo->state = CS_DEVICE;
675 } else {
676 free(sinfo);
677 return NULL;
678 }
679
680 int fd = create_service_thread(wait_for_state, sinfo);
681 return create_local_socket(fd);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700682 } else if (!strncmp(name, "connect:", 8)) {
683 const char *host = name + 8;
684 int fd = create_service_thread(connect_service, (void *)host);
685 return create_local_socket(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800686 }
687 return NULL;
688}
689#endif /* ADB_HOST */