services.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545
  1. /*
  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. #include <stdlib.h>
  17. #include <stdio.h>
  18. #include <unistd.h>
  19. #include <string.h>
  20. #include <errno.h>
  21. #include "sysdeps.h"
  22. #define TRACE_TAG TRACE_SERVICES
  23. #include "adb.h"
  24. #include "file_sync_service.h"
  25. #if ADB_HOST
  26. # ifndef HAVE_WINSOCK
  27. # include <netinet/in.h>
  28. # include <netdb.h>
  29. # include <sys/ioctl.h>
  30. # endif
  31. #else
  32. # include <cutils/android_reboot.h>
  33. #endif
  34. typedef struct stinfo stinfo;
  35. struct stinfo {
  36. void (*func)(int fd, void *cookie);
  37. int fd;
  38. void *cookie;
  39. };
  40. void *service_bootstrap_func(void *x)
  41. {
  42. stinfo *sti = x;
  43. sti->func(sti->fd, sti->cookie);
  44. free(sti);
  45. return 0;
  46. }
  47. #if ADB_HOST
  48. ADB_MUTEX_DEFINE( dns_lock );
  49. static void dns_service(int fd, void *cookie)
  50. {
  51. char *hostname = cookie;
  52. struct hostent *hp;
  53. unsigned zero = 0;
  54. adb_mutex_lock(&dns_lock);
  55. hp = gethostbyname(hostname);
  56. free(cookie);
  57. if(hp == 0) {
  58. writex(fd, &zero, 4);
  59. } else {
  60. writex(fd, hp->h_addr, 4);
  61. }
  62. adb_mutex_unlock(&dns_lock);
  63. adb_close(fd);
  64. }
  65. #else
  66. extern int recovery_mode;
  67. static void recover_service(int s, void *cookie)
  68. {
  69. unsigned char buf[4096];
  70. unsigned count = (unsigned) cookie;
  71. int fd;
  72. fd = adb_creat("/tmp/update", 0644);
  73. if(fd < 0) {
  74. adb_close(s);
  75. return;
  76. }
  77. while(count > 0) {
  78. unsigned xfer = (count > 4096) ? 4096 : count;
  79. if(readx(s, buf, xfer)) break;
  80. if(writex(fd, buf, xfer)) break;
  81. count -= xfer;
  82. }
  83. if(count == 0) {
  84. writex(s, "OKAY", 4);
  85. } else {
  86. writex(s, "FAIL", 4);
  87. }
  88. adb_close(fd);
  89. adb_close(s);
  90. fd = adb_creat("/tmp/update.begin", 0644);
  91. adb_close(fd);
  92. }
  93. void restart_root_service(int fd, void *cookie)
  94. {
  95. char buf[100];
  96. char value[PROPERTY_VALUE_MAX];
  97. if (getuid() == 0) {
  98. snprintf(buf, sizeof(buf), "adbd is already running as root\n");
  99. writex(fd, buf, strlen(buf));
  100. adb_close(fd);
  101. } else {
  102. property_get("ro.debuggable", value, "");
  103. if (strcmp(value, "1") != 0) {
  104. snprintf(buf, sizeof(buf), "adbd cannot run as root in production builds\n");
  105. writex(fd, buf, strlen(buf));
  106. adb_close(fd);
  107. return;
  108. }
  109. property_set("service.adb.root", "1");
  110. snprintf(buf, sizeof(buf), "restarting adbd as root\n");
  111. writex(fd, buf, strlen(buf));
  112. adb_close(fd);
  113. }
  114. }
  115. void restart_tcp_service(int fd, void *cookie)
  116. {
  117. char buf[100];
  118. char value[PROPERTY_VALUE_MAX];
  119. int port = (int)cookie;
  120. if (port <= 0) {
  121. snprintf(buf, sizeof(buf), "invalid port\n");
  122. writex(fd, buf, strlen(buf));
  123. adb_close(fd);
  124. return;
  125. }
  126. snprintf(value, sizeof(value), "%d", port);
  127. property_set("service.adb.tcp.port", value);
  128. snprintf(buf, sizeof(buf), "restarting in TCP mode port: %d\n", port);
  129. writex(fd, buf, strlen(buf));
  130. adb_close(fd);
  131. }
  132. void restart_usb_service(int fd, void *cookie)
  133. {
  134. char buf[100];
  135. property_set("service.adb.tcp.port", "0");
  136. snprintf(buf, sizeof(buf), "restarting in USB mode\n");
  137. writex(fd, buf, strlen(buf));
  138. adb_close(fd);
  139. }
  140. void reboot_service(int fd, void *arg)
  141. {
  142. char buf[100];
  143. int pid, ret;
  144. sync();
  145. /* Attempt to unmount the SD card first.
  146. * No need to bother checking for errors.
  147. */
  148. /* ask vdc to unmount it */
  149. execl("/sbin/reboot", "/sbin/reboot", arg, NULL);
  150. free(arg);
  151. adb_close(fd);
  152. }
  153. #endif
  154. #if 0
  155. static void echo_service(int fd, void *cookie)
  156. {
  157. char buf[4096];
  158. int r;
  159. char *p;
  160. int c;
  161. for(;;) {
  162. r = read(fd, buf, 4096);
  163. if(r == 0) goto done;
  164. if(r < 0) {
  165. if(errno == EINTR) continue;
  166. else goto done;
  167. }
  168. c = r;
  169. p = buf;
  170. while(c > 0) {
  171. r = write(fd, p, c);
  172. if(r > 0) {
  173. c -= r;
  174. p += r;
  175. continue;
  176. }
  177. if((r < 0) && (errno == EINTR)) continue;
  178. goto done;
  179. }
  180. }
  181. done:
  182. close(fd);
  183. }
  184. #endif
  185. static int create_service_thread(void (*func)(int, void *), void *cookie)
  186. {
  187. stinfo *sti;
  188. adb_thread_t t;
  189. int s[2];
  190. if(adb_socketpair(s)) {
  191. printf("cannot create service socket pair\n");
  192. return -1;
  193. }
  194. sti = malloc(sizeof(stinfo));
  195. if(sti == 0) fatal("cannot allocate stinfo");
  196. sti->func = func;
  197. sti->cookie = cookie;
  198. sti->fd = s[1];
  199. if(adb_thread_create( &t, service_bootstrap_func, sti)){
  200. free(sti);
  201. adb_close(s[0]);
  202. adb_close(s[1]);
  203. printf("cannot create service thread\n");
  204. return -1;
  205. }
  206. D("service thread started, %d:%d\n",s[0], s[1]);
  207. return s[0];
  208. }
  209. #if !ADB_HOST
  210. static int create_subprocess(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
  211. {
  212. #ifdef HAVE_WIN32_PROC
  213. D("create_subprocess(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
  214. fprintf(stderr, "error: create_subprocess not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
  215. return -1;
  216. #else /* !HAVE_WIN32_PROC */
  217. char *devname;
  218. int ptm;
  219. ptm = unix_open("/dev/ptmx", O_RDWR); // | O_NOCTTY);
  220. if(ptm < 0){
  221. printf("[ cannot open /dev/ptmx - %s ]\n",strerror(errno));
  222. return -1;
  223. }
  224. fcntl(ptm, F_SETFD, FD_CLOEXEC);
  225. if(grantpt(ptm) || unlockpt(ptm) ||
  226. ((devname = (char*) ptsname(ptm)) == 0)){
  227. printf("[ trouble with /dev/ptmx - %s ]\n", strerror(errno));
  228. adb_close(ptm);
  229. return -1;
  230. }
  231. *pid = fork();
  232. if(*pid < 0) {
  233. printf("- fork failed: %s -\n", strerror(errno));
  234. adb_close(ptm);
  235. return -1;
  236. }
  237. if(*pid == 0){
  238. int pts;
  239. setsid();
  240. pts = unix_open(devname, O_RDWR);
  241. if(pts < 0) {
  242. fprintf(stderr, "child failed to open pseudo-term slave: %s\n", devname);
  243. exit(-1);
  244. }
  245. dup2(pts, 0);
  246. dup2(pts, 1);
  247. dup2(pts, 2);
  248. adb_close(pts);
  249. adb_close(ptm);
  250. // set OOM adjustment to zero
  251. char text[64];
  252. snprintf(text, sizeof text, "/proc/%d/oom_score_adj", getpid());
  253. int fd = adb_open(text, O_WRONLY);
  254. if (fd >= 0) {
  255. adb_write(fd, "0", 1);
  256. adb_close(fd);
  257. } else {
  258. D("adb: unable to open %s\n", text);
  259. }
  260. execl(cmd, cmd, arg0, arg1, NULL);
  261. fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
  262. cmd, strerror(errno), errno);
  263. exit(-1);
  264. } else {
  265. // Don't set child's OOM adjustment to zero.
  266. // Let the child do it itself, as sometimes the parent starts
  267. // running before the child has a /proc/pid/oom_adj.
  268. // """adb: unable to open /proc/644/oom_adj""" seen in some logs.
  269. return ptm;
  270. }
  271. #endif /* !HAVE_WIN32_PROC */
  272. }
  273. #endif /* !ABD_HOST */
  274. #if ADB_HOST
  275. #define SHELL_COMMAND "/bin/sh"
  276. #else
  277. #define SHELL_COMMAND "/bin/adb_shell"
  278. #endif
  279. #if !ADB_HOST
  280. static void subproc_waiter_service(int fd, void *cookie)
  281. {
  282. pid_t pid = (pid_t)cookie;
  283. D("entered. fd=%d of pid=%d\n", fd, pid);
  284. for (;;) {
  285. int status;
  286. pid_t p = waitpid(pid, &status, 0);
  287. if (p == pid) {
  288. D("fd=%d, post waitpid(pid=%d) status=%04x\n", fd, p, status);
  289. if (WIFSIGNALED(status)) {
  290. D("*** Killed by signal %d\n", WTERMSIG(status));
  291. break;
  292. } else if (!WIFEXITED(status)) {
  293. D("*** Didn't exit!!. status %d\n", status);
  294. break;
  295. } else if (WEXITSTATUS(status) >= 0) {
  296. D("*** Exit code %d\n", WEXITSTATUS(status));
  297. break;
  298. }
  299. }
  300. }
  301. D("shell exited fd=%d of pid=%d err=%d\n", fd, pid, errno);
  302. if (SHELL_EXIT_NOTIFY_FD >=0) {
  303. int res;
  304. res = writex(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd));
  305. D("notified shell exit via fd=%d for pid=%d res=%d errno=%d\n",
  306. SHELL_EXIT_NOTIFY_FD, pid, res, errno);
  307. }
  308. }
  309. static int create_subproc_thread(const char *name)
  310. {
  311. stinfo *sti;
  312. adb_thread_t t;
  313. int ret_fd;
  314. pid_t pid;
  315. if(name) {
  316. ret_fd = create_subprocess(SHELL_COMMAND, "-c", name, &pid);
  317. } else {
  318. ret_fd = create_subprocess(SHELL_COMMAND, "-", 0, &pid);
  319. }
  320. D("create_subprocess() ret_fd=%d pid=%d\n", ret_fd, pid);
  321. sti = malloc(sizeof(stinfo));
  322. if(sti == 0) fatal("cannot allocate stinfo");
  323. sti->func = subproc_waiter_service;
  324. sti->cookie = (void*)pid;
  325. sti->fd = ret_fd;
  326. if(adb_thread_create( &t, service_bootstrap_func, sti)){
  327. free(sti);
  328. adb_close(ret_fd);
  329. printf("cannot create service thread\n");
  330. return -1;
  331. }
  332. D("service thread started, fd=%d pid=%d\n",ret_fd, pid);
  333. return ret_fd;
  334. }
  335. #endif
  336. int service_to_fd(const char *name)
  337. {
  338. int ret = -1;
  339. if(!strncmp(name, "tcp:", 4)) {
  340. int port = atoi(name + 4);
  341. name = strchr(name + 4, ':');
  342. if(name == 0) {
  343. ret = socket_loopback_client(port, SOCK_STREAM);
  344. if (ret >= 0)
  345. disable_tcp_nagle(ret);
  346. } else {
  347. #if ADB_HOST
  348. adb_mutex_lock(&dns_lock);
  349. ret = socket_network_client(name + 1, port, SOCK_STREAM);
  350. adb_mutex_unlock(&dns_lock);
  351. #else
  352. return -1;
  353. #endif
  354. }
  355. #ifndef HAVE_WINSOCK /* winsock doesn't implement unix domain sockets */
  356. } else if(!strncmp(name, "local:", 6)) {
  357. ret = socket_local_client(name + 6,
  358. ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
  359. } else if(!strncmp(name, "localreserved:", 14)) {
  360. ret = socket_local_client(name + 14,
  361. ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
  362. } else if(!strncmp(name, "localabstract:", 14)) {
  363. ret = socket_local_client(name + 14,
  364. ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
  365. } else if(!strncmp(name, "localfilesystem:", 16)) {
  366. ret = socket_local_client(name + 16,
  367. ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
  368. #endif
  369. #if ADB_HOST
  370. } else if(!strncmp("dns:", name, 4)){
  371. char *n = strdup(name + 4);
  372. if(n == 0) return -1;
  373. ret = create_service_thread(dns_service, n);
  374. #else /* !ADB_HOST */
  375. } else if(!strncmp("dev:", name, 4)) {
  376. ret = unix_open(name + 4, O_RDWR);
  377. } else if(!strncmp(name, "framebuffer:", 12)) {
  378. ret = create_service_thread(framebuffer_service, 0);
  379. } else if(recovery_mode && !strncmp(name, "recover:", 8)) {
  380. ret = create_service_thread(recover_service, (void*) atoi(name + 8));
  381. } else if (!strncmp(name, "jdwp:", 5)) {
  382. ret = create_jdwp_connection_fd(atoi(name+5));
  383. } else if (!strncmp(name, "log:", 4)) {
  384. ret = create_service_thread(log_service, get_log_file_path(name + 4));
  385. } else if(!HOST && !strncmp(name, "shell:", 6)) {
  386. if(name[6]) {
  387. ret = create_subproc_thread(name + 6);
  388. } else {
  389. ret = create_subproc_thread(0);
  390. }
  391. } else if(!strncmp(name, "sync:", 5)) {
  392. ret = create_service_thread(file_sync_service, NULL);
  393. } else if(!strncmp(name, "remount:", 8)) {
  394. ret = create_service_thread(remount_service, NULL);
  395. } else if(!strncmp(name, "reboot:", 7)) {
  396. void* arg = strdup(name + 7);
  397. if(arg == 0) return -1;
  398. ret = create_service_thread(reboot_service, arg);
  399. } else if(!strncmp(name, "root:", 5)) {
  400. ret = create_service_thread(restart_root_service, NULL);
  401. } else if(!strncmp(name, "backup:", 7)) {
  402. char* arg = strdup(name+7);
  403. if (arg == NULL) return -1;
  404. ret = backup_service(BACKUP, arg);
  405. } else if(!strncmp(name, "restore:", 8)) {
  406. ret = backup_service(RESTORE, NULL);
  407. } else if(!strncmp(name, "tcpip:", 6)) {
  408. int port;
  409. if (sscanf(name + 6, "%d", &port) == 0) {
  410. port = 0;
  411. }
  412. ret = create_service_thread(restart_tcp_service, (void *)port);
  413. } else if(!strncmp(name, "usb:", 4)) {
  414. ret = create_service_thread(restart_usb_service, NULL);
  415. #endif
  416. #if 0
  417. } else if(!strncmp(name, "echo:", 5)){
  418. ret = create_service_thread(echo_service, 0);
  419. #endif
  420. }
  421. if (ret >= 0) {
  422. close_on_exec(ret);
  423. }
  424. return ret;
  425. }
  426. #if ADB_HOST
  427. struct state_info {
  428. transport_type transport;
  429. char* serial;
  430. int state;
  431. };
  432. static void wait_for_state(int fd, void* cookie)
  433. {
  434. struct state_info* sinfo = cookie;
  435. char* err = "unknown error";
  436. D("wait_for_state %d\n", sinfo->state);
  437. atransport *t = acquire_one_transport(sinfo->state, sinfo->transport, sinfo->serial, &err);
  438. if(t != 0) {
  439. writex(fd, "OKAY", 4);
  440. } else {
  441. sendfailmsg(fd, err);
  442. }
  443. if (sinfo->serial)
  444. free(sinfo->serial);
  445. free(sinfo);
  446. adb_close(fd);
  447. D("wait_for_state is done\n");
  448. }
  449. #endif
  450. #if ADB_HOST
  451. asocket* host_service_to_socket(const char* name, const char *serial)
  452. {
  453. if (!strcmp(name,"track-devices")) {
  454. return create_device_tracker();
  455. } else if (!strncmp(name, "wait-for-", strlen("wait-for-"))) {
  456. struct state_info* sinfo = malloc(sizeof(struct state_info));
  457. if (serial)
  458. sinfo->serial = strdup(serial);
  459. else
  460. sinfo->serial = NULL;
  461. name += strlen("wait-for-");
  462. if (!strncmp(name, "local", strlen("local"))) {
  463. sinfo->transport = kTransportLocal;
  464. sinfo->state = CS_DEVICE;
  465. } else if (!strncmp(name, "usb", strlen("usb"))) {
  466. sinfo->transport = kTransportUsb;
  467. sinfo->state = CS_DEVICE;
  468. } else if (!strncmp(name, "any", strlen("any"))) {
  469. sinfo->transport = kTransportAny;
  470. sinfo->state = CS_DEVICE;
  471. } else {
  472. free(sinfo);
  473. return NULL;
  474. }
  475. int fd = create_service_thread(wait_for_state, sinfo);
  476. return create_local_socket(fd);
  477. }
  478. return NULL;
  479. }
  480. #endif /* ADB_HOST */