blob: 446c70e9a79e4ea8972e715ae925226613f2c9bd [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
17#define TRACE_TAG TRACE_ADB
18
19#include <stdio.h>
20#include <stdlib.h>
21#include <ctype.h>
22#include <stdarg.h>
23#include <errno.h>
24#include <string.h>
25#include <time.h>
Mike Lockwood1f546e62009-05-25 18:17:55 -040026#include <sys/time.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080027
28#include "sysdeps.h"
29#include "adb.h"
30
31#if !ADB_HOST
32#include <private/android_filesystem_config.h>
Mike Lockwood5f4b0512009-08-04 20:37:51 -040033#include <linux/capability.h>
34#include <linux/prctl.h>
Xavier Ducroheta09fbd12009-05-20 17:33:53 -070035#else
36#include "usb_vendors.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080037#endif
38
39
40int HOST = 0;
41
42static const char *adb_device_banner = "device";
43
44void fatal(const char *fmt, ...)
45{
46 va_list ap;
47 va_start(ap, fmt);
48 fprintf(stderr, "error: ");
49 vfprintf(stderr, fmt, ap);
50 fprintf(stderr, "\n");
51 va_end(ap);
52 exit(-1);
53}
54
55void fatal_errno(const char *fmt, ...)
56{
57 va_list ap;
58 va_start(ap, fmt);
59 fprintf(stderr, "error: %s: ", strerror(errno));
60 vfprintf(stderr, fmt, ap);
61 fprintf(stderr, "\n");
62 va_end(ap);
63 exit(-1);
64}
65
66int adb_trace_mask;
67
68/* read a comma/space/colum/semi-column separated list of tags
69 * from the ADB_TRACE environment variable and build the trace
70 * mask from it. note that '1' and 'all' are special cases to
71 * enable all tracing
72 */
73void adb_trace_init(void)
74{
75 const char* p = getenv("ADB_TRACE");
76 const char* q;
77
78 static const struct {
79 const char* tag;
80 int flag;
81 } tags[] = {
82 { "1", 0 },
83 { "all", 0 },
84 { "adb", TRACE_ADB },
85 { "sockets", TRACE_SOCKETS },
86 { "packets", TRACE_PACKETS },
87 { "rwx", TRACE_RWX },
88 { "usb", TRACE_USB },
89 { "sync", TRACE_SYNC },
90 { "sysdeps", TRACE_SYSDEPS },
91 { "transport", TRACE_TRANSPORT },
92 { "jdwp", TRACE_JDWP },
93 { NULL, 0 }
94 };
95
96 if (p == NULL)
97 return;
98
99 /* use a comma/column/semi-colum/space separated list */
100 while (*p) {
101 int len, tagn;
102
103 q = strpbrk(p, " ,:;");
104 if (q == NULL) {
105 q = p + strlen(p);
106 }
107 len = q - p;
108
109 for (tagn = 0; tags[tagn].tag != NULL; tagn++)
110 {
111 int taglen = strlen(tags[tagn].tag);
112
113 if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
114 {
115 int flag = tags[tagn].flag;
116 if (flag == 0) {
117 adb_trace_mask = ~0;
118 return;
119 }
120 adb_trace_mask |= (1 << flag);
121 break;
122 }
123 }
124 p = q;
125 if (*p)
126 p++;
127 }
128}
129
130
131apacket *get_apacket(void)
132{
133 apacket *p = malloc(sizeof(apacket));
134 if(p == 0) fatal("failed to allocate an apacket");
135 memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
136 return p;
137}
138
139void put_apacket(apacket *p)
140{
141 free(p);
142}
143
144void handle_online(void)
145{
146 D("adb: online\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800147}
148
149void handle_offline(atransport *t)
150{
151 D("adb: offline\n");
152 //Close the associated usb
153 run_transport_disconnects(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800154}
155
156#if TRACE_PACKETS
157#define DUMPMAX 32
158void print_packet(const char *label, apacket *p)
159{
160 char *tag;
161 char *x;
162 unsigned count;
163
164 switch(p->msg.command){
165 case A_SYNC: tag = "SYNC"; break;
166 case A_CNXN: tag = "CNXN" ; break;
167 case A_OPEN: tag = "OPEN"; break;
168 case A_OKAY: tag = "OKAY"; break;
169 case A_CLSE: tag = "CLSE"; break;
170 case A_WRTE: tag = "WRTE"; break;
171 default: tag = "????"; break;
172 }
173
174 fprintf(stderr, "%s: %s %08x %08x %04x \"",
175 label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
176 count = p->msg.data_length;
177 x = (char*) p->data;
178 if(count > DUMPMAX) {
179 count = DUMPMAX;
180 tag = "\n";
181 } else {
182 tag = "\"\n";
183 }
184 while(count-- > 0){
185 if((*x >= ' ') && (*x < 127)) {
186 fputc(*x, stderr);
187 } else {
188 fputc('.', stderr);
189 }
190 x++;
191 }
192 fprintf(stderr, tag);
193}
194#endif
195
196static void send_ready(unsigned local, unsigned remote, atransport *t)
197{
198 D("Calling send_ready \n");
199 apacket *p = get_apacket();
200 p->msg.command = A_OKAY;
201 p->msg.arg0 = local;
202 p->msg.arg1 = remote;
203 send_packet(p, t);
204}
205
206static void send_close(unsigned local, unsigned remote, atransport *t)
207{
208 D("Calling send_close \n");
209 apacket *p = get_apacket();
210 p->msg.command = A_CLSE;
211 p->msg.arg0 = local;
212 p->msg.arg1 = remote;
213 send_packet(p, t);
214}
215
216static void send_connect(atransport *t)
217{
218 D("Calling send_connect \n");
219 apacket *cp = get_apacket();
220 cp->msg.command = A_CNXN;
221 cp->msg.arg0 = A_VERSION;
222 cp->msg.arg1 = MAX_PAYLOAD;
223 snprintf((char*) cp->data, sizeof cp->data, "%s::",
224 HOST ? "host" : adb_device_banner);
225 cp->msg.data_length = strlen((char*) cp->data) + 1;
226 send_packet(cp, t);
227#if ADB_HOST
228 /* XXX why sleep here? */
229 // allow the device some time to respond to the connect message
230 adb_sleep_ms(1000);
231#endif
232}
233
234static char *connection_state_name(atransport *t)
235{
236 if (t == NULL) {
237 return "unknown";
238 }
239
240 switch(t->connection_state) {
241 case CS_BOOTLOADER:
242 return "bootloader";
243 case CS_DEVICE:
244 return "device";
245 case CS_OFFLINE:
246 return "offline";
247 default:
248 return "unknown";
249 }
250}
251
252void parse_banner(char *banner, atransport *t)
253{
254 char *type, *product, *end;
255
256 D("parse_banner: %s\n", banner);
257 type = banner;
258 product = strchr(type, ':');
259 if(product) {
260 *product++ = 0;
261 } else {
262 product = "";
263 }
264
265 /* remove trailing ':' */
266 end = strchr(product, ':');
267 if(end) *end = 0;
268
269 /* save product name in device structure */
270 if (t->product == NULL) {
271 t->product = strdup(product);
272 } else if (strcmp(product, t->product) != 0) {
273 free(t->product);
274 t->product = strdup(product);
275 }
276
277 if(!strcmp(type, "bootloader")){
278 D("setting connection_state to CS_BOOTLOADER\n");
279 t->connection_state = CS_BOOTLOADER;
280 update_transports();
281 return;
282 }
283
284 if(!strcmp(type, "device")) {
285 D("setting connection_state to CS_DEVICE\n");
286 t->connection_state = CS_DEVICE;
287 update_transports();
288 return;
289 }
290
291 if(!strcmp(type, "recovery")) {
292 D("setting connection_state to CS_RECOVERY\n");
293 t->connection_state = CS_RECOVERY;
294 update_transports();
295 return;
296 }
297
298 t->connection_state = CS_HOST;
299}
300
301void handle_packet(apacket *p, atransport *t)
302{
303 asocket *s;
304
305 D("handle_packet() %d\n", p->msg.command);
306
307 print_packet("recv", p);
308
309 switch(p->msg.command){
310 case A_SYNC:
311 if(p->msg.arg0){
312 send_packet(p, t);
313 if(HOST) send_connect(t);
314 } else {
315 t->connection_state = CS_OFFLINE;
316 handle_offline(t);
317 send_packet(p, t);
318 }
319 return;
320
321 case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
322 /* XXX verify version, etc */
323 if(t->connection_state != CS_OFFLINE) {
324 t->connection_state = CS_OFFLINE;
325 handle_offline(t);
326 }
327 parse_banner((char*) p->data, t);
328 handle_online();
329 if(!HOST) send_connect(t);
330 break;
331
332 case A_OPEN: /* OPEN(local-id, 0, "destination") */
333 if(t->connection_state != CS_OFFLINE) {
334 char *name = (char*) p->data;
335 name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
336 s = create_local_service_socket(name);
337 if(s == 0) {
338 send_close(0, p->msg.arg0, t);
339 } else {
340 s->peer = create_remote_socket(p->msg.arg0, t);
341 s->peer->peer = s;
342 send_ready(s->id, s->peer->id, t);
343 s->ready(s);
344 }
345 }
346 break;
347
348 case A_OKAY: /* READY(local-id, remote-id, "") */
349 if(t->connection_state != CS_OFFLINE) {
350 if((s = find_local_socket(p->msg.arg1))) {
351 if(s->peer == 0) {
352 s->peer = create_remote_socket(p->msg.arg0, t);
353 s->peer->peer = s;
354 }
355 s->ready(s);
356 }
357 }
358 break;
359
360 case A_CLSE: /* CLOSE(local-id, remote-id, "") */
361 if(t->connection_state != CS_OFFLINE) {
362 if((s = find_local_socket(p->msg.arg1))) {
363 s->close(s);
364 }
365 }
366 break;
367
368 case A_WRTE:
369 if(t->connection_state != CS_OFFLINE) {
370 if((s = find_local_socket(p->msg.arg1))) {
371 unsigned rid = p->msg.arg0;
372 p->len = p->msg.data_length;
373
374 if(s->enqueue(s, p) == 0) {
375 D("Enqueue the socket\n");
376 send_ready(s->id, rid, t);
377 }
378 return;
379 }
380 }
381 break;
382
383 default:
384 printf("handle_packet: what is %08x?!\n", p->msg.command);
385 }
386
387 put_apacket(p);
388}
389
390alistener listener_list = {
391 .next = &listener_list,
392 .prev = &listener_list,
393};
394
395static void ss_listener_event_func(int _fd, unsigned ev, void *_l)
396{
397 asocket *s;
398
399 if(ev & FDE_READ) {
400 struct sockaddr addr;
401 socklen_t alen;
402 int fd;
403
404 alen = sizeof(addr);
405 fd = adb_socket_accept(_fd, &addr, &alen);
406 if(fd < 0) return;
407
408 adb_socket_setbufsize(fd, CHUNK_SIZE);
409
410 s = create_local_socket(fd);
411 if(s) {
412 connect_to_smartsocket(s);
413 return;
414 }
415
416 adb_close(fd);
417 }
418}
419
420static void listener_event_func(int _fd, unsigned ev, void *_l)
421{
422 alistener *l = _l;
423 asocket *s;
424
425 if(ev & FDE_READ) {
426 struct sockaddr addr;
427 socklen_t alen;
428 int fd;
429
430 alen = sizeof(addr);
431 fd = adb_socket_accept(_fd, &addr, &alen);
432 if(fd < 0) return;
433
434 s = create_local_socket(fd);
435 if(s) {
436 s->transport = l->transport;
437 connect_to_remote(s, l->connect_to);
438 return;
439 }
440
441 adb_close(fd);
442 }
443}
444
445static void free_listener(alistener* l)
446{
447 if (l->next) {
448 l->next->prev = l->prev;
449 l->prev->next = l->next;
450 l->next = l->prev = l;
451 }
452
453 // closes the corresponding fd
454 fdevent_remove(&l->fde);
455
456 if (l->local_name)
457 free((char*)l->local_name);
458
459 if (l->connect_to)
460 free((char*)l->connect_to);
461
462 if (l->transport) {
463 remove_transport_disconnect(l->transport, &l->disconnect);
464 }
465 free(l);
466}
467
468static void listener_disconnect(void* _l, atransport* t)
469{
470 alistener* l = _l;
471
472 free_listener(l);
473}
474
475int local_name_to_fd(const char *name)
476{
477 int port;
478
479 if(!strncmp("tcp:", name, 4)){
480 int ret;
481 port = atoi(name + 4);
482 ret = socket_loopback_server(port, SOCK_STREAM);
483 return ret;
484 }
485#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */
486 // It's non-sensical to support the "reserved" space on the adb host side
487 if(!strncmp(name, "local:", 6)) {
488 return socket_local_server(name + 6,
489 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
490 } else if(!strncmp(name, "localabstract:", 14)) {
491 return socket_local_server(name + 14,
492 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
493 } else if(!strncmp(name, "localfilesystem:", 16)) {
494 return socket_local_server(name + 16,
495 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
496 }
497
498#endif
499 printf("unknown local portname '%s'\n", name);
500 return -1;
501}
502
503static int remove_listener(const char *local_name, const char *connect_to, atransport* transport)
504{
505 alistener *l;
506
507 for (l = listener_list.next; l != &listener_list; l = l->next) {
508 if (!strcmp(local_name, l->local_name) &&
509 !strcmp(connect_to, l->connect_to) &&
510 l->transport && l->transport == transport) {
511
512 listener_disconnect(l, transport);
513 return 0;
514 }
515 }
516
517 return -1;
518}
519
520static int install_listener(const char *local_name, const char *connect_to, atransport* transport)
521{
522 alistener *l;
523
524 //printf("install_listener('%s','%s')\n", local_name, connect_to);
525
526 for(l = listener_list.next; l != &listener_list; l = l->next){
527 if(strcmp(local_name, l->local_name) == 0) {
528 char *cto;
529
530 /* can't repurpose a smartsocket */
531 if(l->connect_to[0] == '*') {
532 return -1;
533 }
534
535 cto = strdup(connect_to);
536 if(cto == 0) {
537 return -1;
538 }
539
540 //printf("rebinding '%s' to '%s'\n", local_name, connect_to);
541 free((void*) l->connect_to);
542 l->connect_to = cto;
543 if (l->transport != transport) {
544 remove_transport_disconnect(l->transport, &l->disconnect);
545 l->transport = transport;
546 add_transport_disconnect(l->transport, &l->disconnect);
547 }
548 return 0;
549 }
550 }
551
552 if((l = calloc(1, sizeof(alistener))) == 0) goto nomem;
553 if((l->local_name = strdup(local_name)) == 0) goto nomem;
554 if((l->connect_to = strdup(connect_to)) == 0) goto nomem;
555
556
557 l->fd = local_name_to_fd(local_name);
558 if(l->fd < 0) {
559 free((void*) l->local_name);
560 free((void*) l->connect_to);
561 free(l);
562 printf("cannot bind '%s'\n", local_name);
563 return -2;
564 }
565
566 close_on_exec(l->fd);
567 if(!strcmp(l->connect_to, "*smartsocket*")) {
568 fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);
569 } else {
570 fdevent_install(&l->fde, l->fd, listener_event_func, l);
571 }
572 fdevent_set(&l->fde, FDE_READ);
573
574 l->next = &listener_list;
575 l->prev = listener_list.prev;
576 l->next->prev = l;
577 l->prev->next = l;
578 l->transport = transport;
579
580 if (transport) {
581 l->disconnect.opaque = l;
582 l->disconnect.func = listener_disconnect;
583 add_transport_disconnect(transport, &l->disconnect);
584 }
585 return 0;
586
587nomem:
588 fatal("cannot allocate listener");
589 return 0;
590}
591
592#ifdef HAVE_FORKEXEC
593static void sigchld_handler(int n)
594{
595 int status;
596 while(waitpid(-1, &status, WNOHANG) > 0) ;
597}
598#endif
599
600#ifdef HAVE_WIN32_PROC
601static BOOL WINAPI ctrlc_handler(DWORD type)
602{
603 exit(STATUS_CONTROL_C_EXIT);
604 return TRUE;
605}
606#endif
607
608static void adb_cleanup(void)
609{
610 usb_cleanup();
611}
612
613void start_logging(void)
614{
615#ifdef HAVE_WIN32_PROC
616 char temp[ MAX_PATH ];
617 FILE* fnul;
618 FILE* flog;
619
620 GetTempPath( sizeof(temp) - 8, temp );
621 strcat( temp, "adb.log" );
622
623 /* Win32 specific redirections */
624 fnul = fopen( "NUL", "rt" );
625 if (fnul != NULL)
626 stdin[0] = fnul[0];
627
628 flog = fopen( temp, "at" );
629 if (flog == NULL)
630 flog = fnul;
631
632 setvbuf( flog, NULL, _IONBF, 0 );
633
634 stdout[0] = flog[0];
635 stderr[0] = flog[0];
636 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
637#else
638 int fd;
639
640 fd = unix_open("/dev/null", O_RDONLY);
641 dup2(fd, 0);
642
643 fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);
644 if(fd < 0) {
645 fd = unix_open("/dev/null", O_WRONLY);
646 }
647 dup2(fd, 1);
648 dup2(fd, 2);
649 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
650#endif
651}
652
653#if !ADB_HOST
654void start_device_log(void)
655{
656 int fd;
Mike Lockwood1f546e62009-05-25 18:17:55 -0400657 char path[PATH_MAX];
658 struct tm now;
659 time_t t;
660 char value[PROPERTY_VALUE_MAX];
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800661
Mike Lockwood1f546e62009-05-25 18:17:55 -0400662 // read the trace mask from persistent property persist.adb.trace_mask
663 // give up if the property is not set or cannot be parsed
664 property_get("persist.adb.trace_mask", value, "");
665 if (sscanf(value, "%x", &adb_trace_mask) != 1)
666 return;
667
668 adb_mkdir("/data/adb", 0775);
669 tzset();
670 time(&t);
671 localtime_r(&t, &now);
672 strftime(path, sizeof(path),
673 "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt",
674 &now);
675 fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800676 if (fd < 0)
677 return;
678
679 // redirect stdout and stderr to the log file
680 dup2(fd, 1);
681 dup2(fd, 2);
682 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
683
684 fd = unix_open("/dev/null", O_RDONLY);
685 dup2(fd, 0);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800686}
687#endif
688
689#if ADB_HOST
690int launch_server()
691{
692#ifdef HAVE_WIN32_PROC
693 /* we need to start the server in the background */
694 /* we create a PIPE that will be used to wait for the server's "OK" */
695 /* message since the pipe handles must be inheritable, we use a */
696 /* security attribute */
697 HANDLE pipe_read, pipe_write;
698 SECURITY_ATTRIBUTES sa;
699 STARTUPINFO startup;
700 PROCESS_INFORMATION pinfo;
701 char program_path[ MAX_PATH ];
702 int ret;
703
704 sa.nLength = sizeof(sa);
705 sa.lpSecurityDescriptor = NULL;
706 sa.bInheritHandle = TRUE;
707
708 /* create pipe, and ensure its read handle isn't inheritable */
709 ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 );
710 if (!ret) {
711 fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() );
712 return -1;
713 }
714
715 SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 );
716
717 ZeroMemory( &startup, sizeof(startup) );
718 startup.cb = sizeof(startup);
719 startup.hStdInput = GetStdHandle( STD_INPUT_HANDLE );
720 startup.hStdOutput = pipe_write;
721 startup.hStdError = GetStdHandle( STD_ERROR_HANDLE );
722 startup.dwFlags = STARTF_USESTDHANDLES;
723
724 ZeroMemory( &pinfo, sizeof(pinfo) );
725
726 /* get path of current program */
727 GetModuleFileName( NULL, program_path, sizeof(program_path) );
728
729 ret = CreateProcess(
730 program_path, /* program path */
731 "adb fork-server server",
732 /* the fork-server argument will set the
733 debug = 2 in the child */
734 NULL, /* process handle is not inheritable */
735 NULL, /* thread handle is not inheritable */
736 TRUE, /* yes, inherit some handles */
737 DETACHED_PROCESS, /* the new process doesn't have a console */
738 NULL, /* use parent's environment block */
739 NULL, /* use parent's starting directory */
740 &startup, /* startup info, i.e. std handles */
741 &pinfo );
742
743 CloseHandle( pipe_write );
744
745 if (!ret) {
746 fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() );
747 CloseHandle( pipe_read );
748 return -1;
749 }
750
751 CloseHandle( pinfo.hProcess );
752 CloseHandle( pinfo.hThread );
753
754 /* wait for the "OK\n" message */
755 {
756 char temp[3];
757 DWORD count;
758
759 ret = ReadFile( pipe_read, temp, 3, &count, NULL );
760 CloseHandle( pipe_read );
761 if ( !ret ) {
762 fprintf(stderr, "could not read ok from ADB Server, error = %ld\n", GetLastError() );
763 return -1;
764 }
765 if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
766 fprintf(stderr, "ADB server didn't ACK\n" );
767 return -1;
768 }
769 }
770#elif defined(HAVE_FORKEXEC)
771 char path[PATH_MAX];
772 int fd[2];
773
774 // set up a pipe so the child can tell us when it is ready.
775 // fd[0] will be parent's end, and fd[1] will get mapped to stderr in the child.
776 if (pipe(fd)) {
777 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
778 return -1;
779 }
Alexey Tarasov31664102009-10-22 02:55:00 +1100780 get_my_path(path, PATH_MAX);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800781 pid_t pid = fork();
782 if(pid < 0) return -1;
783
784 if (pid == 0) {
785 // child side of the fork
786
787 // redirect stderr to the pipe
788 // we use stderr instead of stdout due to stdout's buffering behavior.
789 adb_close(fd[0]);
790 dup2(fd[1], STDERR_FILENO);
791 adb_close(fd[1]);
792
793 // child process
794 int result = execl(path, "adb", "fork-server", "server", NULL);
795 // this should not return
796 fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
797 } else {
798 // parent side of the fork
799
800 char temp[3];
801
802 temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
803 // wait for the "OK\n" message
804 adb_close(fd[1]);
805 int ret = adb_read(fd[0], temp, 3);
806 adb_close(fd[0]);
807 if (ret < 0) {
808 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", errno);
809 return -1;
810 }
811 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
812 fprintf(stderr, "ADB server didn't ACK\n" );
813 return -1;
814 }
815
816 setsid();
817 }
818#else
819#error "cannot implement background server start on this platform"
820#endif
821 return 0;
822}
823#endif
824
825int adb_main(int is_daemon)
826{
827#if !ADB_HOST
828 int secure = 0;
Mike Lockwood2f38b692009-08-24 15:58:40 -0700829 int port;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800830 char value[PROPERTY_VALUE_MAX];
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800831#endif
832
833 atexit(adb_cleanup);
834#ifdef HAVE_WIN32_PROC
835 SetConsoleCtrlHandler( ctrlc_handler, TRUE );
836#elif defined(HAVE_FORKEXEC)
837 signal(SIGCHLD, sigchld_handler);
838 signal(SIGPIPE, SIG_IGN);
839#endif
840
841 init_transport_registration();
842
843
844#if ADB_HOST
845 HOST = 1;
Xavier Ducroheta09fbd12009-05-20 17:33:53 -0700846 usb_vendors_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800847 usb_init();
Mike Lockwoodcef31a02009-08-26 12:50:22 -0700848 local_init(ADB_LOCAL_TRANSPORT_PORT);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800849
850 if(install_listener("tcp:5037", "*smartsocket*", NULL)) {
851 exit(1);
852 }
853#else
854 /* run adbd in secure mode if ro.secure is set and
855 ** we are not in the emulator
856 */
857 property_get("ro.kernel.qemu", value, "");
858 if (strcmp(value, "1") != 0) {
859 property_get("ro.secure", value, "");
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700860 if (strcmp(value, "1") == 0) {
861 // don't run as root if ro.secure is set...
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800862 secure = 1;
The Android Open Source Projecte037fd72009-03-13 13:04:37 -0700863
864 // ... except we allow running as root in userdebug builds if the
865 // service.adb.root property has been set by the "adb root" command
866 property_get("ro.debuggable", value, "");
867 if (strcmp(value, "1") == 0) {
868 property_get("service.adb.root", value, "");
869 if (strcmp(value, "1") == 0) {
870 secure = 0;
871 }
872 }
873 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800874 }
875
876 /* don't listen on port 5037 if we are running in secure mode */
877 /* don't run as root if we are running in secure mode */
878 if (secure) {
Mike Lockwood5f4b0512009-08-04 20:37:51 -0400879 struct __user_cap_header_struct header;
880 struct __user_cap_data_struct cap;
881
882 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
883
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800884 /* add extra groups:
885 ** AID_ADB to access the USB driver
886 ** AID_LOG to read system logs (adb logcat)
887 ** AID_INPUT to diagnose input issues (getevent)
888 ** AID_INET to diagnose network issues (netcfg, ping)
889 ** AID_GRAPHICS to access the frame buffer
The Android Open Source Project20155492009-03-11 12:12:01 -0700890 ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
Mike Lockwood6a3075c2009-05-25 13:52:00 -0400891 ** AID_SDCARD_RW to allow writing to the SD card
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800892 */
The Android Open Source Project20155492009-03-11 12:12:01 -0700893 gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
Mike Lockwood6a3075c2009-05-25 13:52:00 -0400894 AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_RW };
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800895 setgroups(sizeof(groups)/sizeof(groups[0]), groups);
896
897 /* then switch user and group to "shell" */
898 setgid(AID_SHELL);
899 setuid(AID_SHELL);
900
Mike Lockwood5f4b0512009-08-04 20:37:51 -0400901 /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
902 header.version = _LINUX_CAPABILITY_VERSION;
903 header.pid = 0;
904 cap.effective = cap.permitted = (1 << CAP_SYS_BOOT);
905 cap.inheritable = 0;
906 capset(&header, &cap);
907
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800908 D("Local port 5037 disabled\n");
909 } else {
910 if(install_listener("tcp:5037", "*smartsocket*", NULL)) {
911 exit(1);
912 }
913 }
914
915 /* for the device, start the usb transport if the
Mike Lockwood8e2ceae2010-04-20 14:06:40 -0400916 ** android usb device exists and the "service.adb.tcp.port" and
917 ** "persist.adb.tcp.port" properties are not set.
918 ** Otherwise start the network transport.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800919 */
Mike Lockwood8e2ceae2010-04-20 14:06:40 -0400920 property_get("service.adb.tcp.port", value, "");
921 if (!value[0])
922 property_get("persist.adb.tcp.port", value, "");
Mike Lockwoodcef31a02009-08-26 12:50:22 -0700923 if (sscanf(value, "%d", &port) == 1 && port > 0) {
924 // listen on TCP port specified by service.adb.tcp.port property
925 local_init(port);
926 } else if (access("/dev/android_adb", F_OK) == 0) {
927 // listen on USB
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800928 usb_init();
929 } else {
Mike Lockwoodcef31a02009-08-26 12:50:22 -0700930 // listen on default port
931 local_init(ADB_LOCAL_TRANSPORT_PORT);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800932 }
933 init_jdwp();
934#endif
935
936 if (is_daemon)
937 {
938 // inform our parent that we are up and running.
939#ifdef HAVE_WIN32_PROC
940 DWORD count;
941 WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );
942#elif defined(HAVE_FORKEXEC)
943 fprintf(stderr, "OK\n");
944#endif
945 start_logging();
946 }
947
948 fdevent_loop();
949
950 usb_cleanup();
951
952 return 0;
953}
954
955int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s)
956{
957 atransport *transport = NULL;
958 char buf[4096];
959
960 if(!strcmp(service, "kill")) {
961 fprintf(stderr,"adb server killed by remote request\n");
962 fflush(stdout);
963 adb_write(reply_fd, "OKAY", 4);
964 usb_cleanup();
965 exit(0);
966 }
967
968#if ADB_HOST
969 // "transport:" is used for switching transport with a specified serial number
970 // "transport-usb:" is used for switching transport to the only USB transport
971 // "transport-local:" is used for switching transport to the only local transport
972 // "transport-any:" is used for switching transport to the only transport
973 if (!strncmp(service, "transport", strlen("transport"))) {
974 char* error_string = "unknown failure";
975 transport_type type = kTransportAny;
976
977 if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
978 type = kTransportUsb;
979 } else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
980 type = kTransportLocal;
981 } else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
982 type = kTransportAny;
983 } else if (!strncmp(service, "transport:", strlen("transport:"))) {
984 service += strlen("transport:");
985 serial = strdup(service);
986 }
987
988 transport = acquire_one_transport(CS_ANY, type, serial, &error_string);
989
990 if (transport) {
991 s->transport = transport;
992 adb_write(reply_fd, "OKAY", 4);
993 } else {
994 sendfailmsg(reply_fd, error_string);
995 }
996 return 1;
997 }
998
999 // return a list of all connected devices
1000 if (!strcmp(service, "devices")) {
1001 char buffer[4096];
1002 memset(buf, 0, sizeof(buf));
1003 memset(buffer, 0, sizeof(buffer));
1004 D("Getting device list \n");
1005 list_transports(buffer, sizeof(buffer));
1006 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer),buffer);
1007 D("Wrote device list \n");
1008 writex(reply_fd, buf, strlen(buf));
1009 return 0;
1010 }
1011
Mike Lockwood2f38b692009-08-24 15:58:40 -07001012 // add a new TCP transport
1013 if (!strncmp(service, "connect:", 8)) {
1014 char buffer[4096];
1015 int port, fd;
1016 char* host = service + 8;
1017 char* portstr = strchr(host, ':');
1018
1019 if (!portstr) {
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001020 snprintf(buffer, sizeof(buffer), "unable to parse %s as <host>:<port>", host);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001021 goto done;
1022 }
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001023 if (find_transport(host)) {
1024 snprintf(buffer, sizeof(buffer), "Already connected to %s", host);
1025 goto done;
1026 }
1027
Mike Lockwood2f38b692009-08-24 15:58:40 -07001028 // zero terminate host by overwriting the ':'
1029 *portstr++ = 0;
1030 if (sscanf(portstr, "%d", &port) == 0) {
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001031 snprintf(buffer, sizeof(buffer), "bad port number %s", portstr);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001032 goto done;
1033 }
1034
1035 fd = socket_network_client(host, port, SOCK_STREAM);
1036 if (fd < 0) {
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001037 snprintf(buffer, sizeof(buffer), "unable to connect to %s:%d", host, port);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001038 goto done;
1039 }
1040
1041 D("client: connected on remote on fd %d\n", fd);
1042 close_on_exec(fd);
1043 disable_tcp_nagle(fd);
1044 snprintf(buf, sizeof buf, "%s:%d", host, port);
1045 register_socket_transport(fd, buf, port, 0);
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001046 snprintf(buffer, sizeof(buffer), "connected to %s:%d", host, port);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001047
1048done:
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001049 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
1050 writex(reply_fd, buf, strlen(buf));
1051 return 0;
1052 }
1053
1054 // remove TCP transport
1055 if (!strncmp(service, "disconnect:", 11)) {
1056 char buffer[4096];
1057 memset(buffer, 0, sizeof(buffer));
1058 char* serial = service + 11;
1059 atransport *t = find_transport(serial);
1060
1061 if (t) {
1062 unregister_transport(t);
1063 } else {
1064 snprintf(buffer, sizeof(buffer), "No such device %s", serial);
1065 }
1066
1067 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001068 writex(reply_fd, buf, strlen(buf));
1069 return 0;
1070 }
1071
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001072 // returns our value for ADB_SERVER_VERSION
1073 if (!strcmp(service, "version")) {
1074 char version[12];
1075 snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION);
1076 snprintf(buf, sizeof buf, "OKAY%04x%s", (unsigned)strlen(version), version);
1077 writex(reply_fd, buf, strlen(buf));
1078 return 0;
1079 }
1080
1081 if(!strncmp(service,"get-serialno",strlen("get-serialno"))) {
1082 char *out = "unknown";
1083 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1084 if (transport && transport->serial) {
1085 out = transport->serial;
1086 }
1087 snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out);
1088 writex(reply_fd, buf, strlen(buf));
1089 return 0;
1090 }
1091 // indicates a new emulator instance has started
1092 if (!strncmp(service,"emulator:",9)) {
1093 int port = atoi(service+9);
1094 local_connect(port);
1095 /* we don't even need to send a reply */
1096 return 0;
1097 }
1098#endif // ADB_HOST
1099
1100 if(!strncmp(service,"forward:",8) || !strncmp(service,"killforward:",12)) {
1101 char *local, *remote, *err;
1102 int r;
1103 atransport *transport;
1104
1105 int createForward = strncmp(service,"kill",4);
1106
1107 local = service + (createForward ? 8 : 12);
1108 remote = strchr(local,';');
1109 if(remote == 0) {
1110 sendfailmsg(reply_fd, "malformed forward spec");
1111 return 0;
1112 }
1113
1114 *remote++ = 0;
1115 if((local[0] == 0) || (remote[0] == 0) || (remote[0] == '*')){
1116 sendfailmsg(reply_fd, "malformed forward spec");
1117 return 0;
1118 }
1119
1120 transport = acquire_one_transport(CS_ANY, ttype, serial, &err);
1121 if (!transport) {
1122 sendfailmsg(reply_fd, err);
1123 return 0;
1124 }
1125
1126 if (createForward) {
1127 r = install_listener(local, remote, transport);
1128 } else {
1129 r = remove_listener(local, remote, transport);
1130 }
1131 if(r == 0) {
1132 /* 1st OKAY is connect, 2nd OKAY is status */
1133 writex(reply_fd, "OKAYOKAY", 8);
1134 return 0;
1135 }
1136
1137 if (createForward) {
1138 sendfailmsg(reply_fd, (r == -1) ? "cannot rebind smartsocket" : "cannot bind socket");
1139 } else {
1140 sendfailmsg(reply_fd, "cannot remove listener");
1141 }
1142 return 0;
1143 }
1144
1145 if(!strncmp(service,"get-state",strlen("get-state"))) {
1146 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1147 char *state = connection_state_name(transport);
1148 snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(state),state);
1149 writex(reply_fd, buf, strlen(buf));
1150 return 0;
1151 }
1152 return -1;
1153}
1154
1155#if !ADB_HOST
1156int recovery_mode = 0;
1157#endif
1158
1159int main(int argc, char **argv)
1160{
1161 adb_trace_init();
1162#if ADB_HOST
1163 adb_sysdeps_init();
1164 return adb_commandline(argc - 1, argv + 1);
1165#else
1166 if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
1167 adb_device_banner = "recovery";
1168 recovery_mode = 1;
1169 }
Mike Lockwood1f546e62009-05-25 18:17:55 -04001170
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001171 start_device_log();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001172 return adb_main(0);
1173#endif
1174}