blob: b5d93f8ef3dc367ccaaf83c8ef0fc16988437c34 [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>
Scott Andersonc7993af2012-05-25 13:55:46 -070024#include <stddef.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080025#include <string.h>
26#include <time.h>
Mike Lockwood1f546e62009-05-25 18:17:55 -040027#include <sys/time.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080028
29#include "sysdeps.h"
30#include "adb.h"
Benoit Gobyd5fcafa2012-04-12 12:23:49 -070031#include "adb_auth.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080032
Scott Andersone82c2db2012-05-25 14:10:02 -070033#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
34
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080035#if !ADB_HOST
36#include <private/android_filesystem_config.h>
Mike Lockwood5f4b0512009-08-04 20:37:51 -040037#include <linux/capability.h>
38#include <linux/prctl.h>
Jeff Sharkey885342a2012-08-14 21:00:22 -070039#include <sys/mount.h>
Xavier Ducroheta09fbd12009-05-20 17:33:53 -070040#else
41#include "usb_vendors.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042#endif
43
JP Abgrall408fa572011-03-16 15:57:42 -070044#if ADB_TRACE
45ADB_MUTEX_DEFINE( D_lock );
46#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080047
48int HOST = 0;
Matt Gumbeld7b33082012-11-14 10:16:17 -080049int gListenAll = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080050
Benoit Gobyd5fcafa2012-04-12 12:23:49 -070051static int auth_enabled = 0;
52
Scott Andersone82c2db2012-05-25 14:10:02 -070053#if !ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080054static const char *adb_device_banner = "device";
Scott Andersone82c2db2012-05-25 14:10:02 -070055#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080056
57void fatal(const char *fmt, ...)
58{
59 va_list ap;
60 va_start(ap, fmt);
61 fprintf(stderr, "error: ");
62 vfprintf(stderr, fmt, ap);
63 fprintf(stderr, "\n");
64 va_end(ap);
65 exit(-1);
66}
67
68void fatal_errno(const char *fmt, ...)
69{
70 va_list ap;
71 va_start(ap, fmt);
72 fprintf(stderr, "error: %s: ", strerror(errno));
73 vfprintf(stderr, fmt, ap);
74 fprintf(stderr, "\n");
75 va_end(ap);
76 exit(-1);
77}
78
79int adb_trace_mask;
80
81/* read a comma/space/colum/semi-column separated list of tags
82 * from the ADB_TRACE environment variable and build the trace
83 * mask from it. note that '1' and 'all' are special cases to
84 * enable all tracing
85 */
86void adb_trace_init(void)
87{
88 const char* p = getenv("ADB_TRACE");
89 const char* q;
90
91 static const struct {
92 const char* tag;
93 int flag;
94 } tags[] = {
95 { "1", 0 },
96 { "all", 0 },
97 { "adb", TRACE_ADB },
98 { "sockets", TRACE_SOCKETS },
99 { "packets", TRACE_PACKETS },
100 { "rwx", TRACE_RWX },
101 { "usb", TRACE_USB },
102 { "sync", TRACE_SYNC },
103 { "sysdeps", TRACE_SYSDEPS },
104 { "transport", TRACE_TRANSPORT },
105 { "jdwp", TRACE_JDWP },
JP Abgrall408fa572011-03-16 15:57:42 -0700106 { "services", TRACE_SERVICES },
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700107 { "auth", TRACE_AUTH },
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800108 { NULL, 0 }
109 };
110
111 if (p == NULL)
112 return;
113
114 /* use a comma/column/semi-colum/space separated list */
115 while (*p) {
116 int len, tagn;
117
118 q = strpbrk(p, " ,:;");
119 if (q == NULL) {
120 q = p + strlen(p);
121 }
122 len = q - p;
123
124 for (tagn = 0; tags[tagn].tag != NULL; tagn++)
125 {
126 int taglen = strlen(tags[tagn].tag);
127
128 if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
129 {
130 int flag = tags[tagn].flag;
131 if (flag == 0) {
132 adb_trace_mask = ~0;
133 return;
134 }
135 adb_trace_mask |= (1 << flag);
136 break;
137 }
138 }
139 p = q;
140 if (*p)
141 p++;
142 }
143}
144
Vladimir Chtchetkine28781b02012-02-27 10:41:53 -0800145#if !ADB_HOST
146/*
147 * Implements ADB tracing inside the emulator.
148 */
149
150#include <stdarg.h>
151
152/*
153 * Redefine open and write for qemu_pipe.h that contains inlined references
154 * to those routines. We will redifine them back after qemu_pipe.h inclusion.
155 */
156
157#undef open
158#undef write
159#define open adb_open
160#define write adb_write
161#include <hardware/qemu_pipe.h>
162#undef open
163#undef write
164#define open ___xxx_open
165#define write ___xxx_write
166
167/* A handle to adb-debug qemud service in the emulator. */
168int adb_debug_qemu = -1;
169
170/* Initializes connection with the adb-debug qemud service in the emulator. */
171static int adb_qemu_trace_init(void)
172{
173 char con_name[32];
174
175 if (adb_debug_qemu >= 0) {
176 return 0;
177 }
178
179 /* adb debugging QEMUD service connection request. */
180 snprintf(con_name, sizeof(con_name), "qemud:adb-debug");
181 adb_debug_qemu = qemu_pipe_open(con_name);
182 return (adb_debug_qemu >= 0) ? 0 : -1;
183}
184
185void adb_qemu_trace(const char* fmt, ...)
186{
187 va_list args;
188 va_start(args, fmt);
189 char msg[1024];
190
191 if (adb_debug_qemu >= 0) {
192 vsnprintf(msg, sizeof(msg), fmt, args);
193 adb_write(adb_debug_qemu, msg, strlen(msg));
194 }
195}
196#endif /* !ADB_HOST */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800197
198apacket *get_apacket(void)
199{
200 apacket *p = malloc(sizeof(apacket));
201 if(p == 0) fatal("failed to allocate an apacket");
202 memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
203 return p;
204}
205
206void put_apacket(apacket *p)
207{
208 free(p);
209}
210
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700211void handle_online(atransport *t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800212{
213 D("adb: online\n");
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700214 t->online = 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800215}
216
217void handle_offline(atransport *t)
218{
219 D("adb: offline\n");
220 //Close the associated usb
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700221 t->online = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800222 run_transport_disconnects(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800223}
224
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700225#if DEBUG_PACKETS
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800226#define DUMPMAX 32
227void print_packet(const char *label, apacket *p)
228{
229 char *tag;
230 char *x;
231 unsigned count;
232
233 switch(p->msg.command){
234 case A_SYNC: tag = "SYNC"; break;
235 case A_CNXN: tag = "CNXN" ; break;
236 case A_OPEN: tag = "OPEN"; break;
237 case A_OKAY: tag = "OKAY"; break;
238 case A_CLSE: tag = "CLSE"; break;
239 case A_WRTE: tag = "WRTE"; break;
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700240 case A_AUTH: tag = "AUTH"; break;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800241 default: tag = "????"; break;
242 }
243
244 fprintf(stderr, "%s: %s %08x %08x %04x \"",
245 label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
246 count = p->msg.data_length;
247 x = (char*) p->data;
248 if(count > DUMPMAX) {
249 count = DUMPMAX;
250 tag = "\n";
251 } else {
252 tag = "\"\n";
253 }
254 while(count-- > 0){
255 if((*x >= ' ') && (*x < 127)) {
256 fputc(*x, stderr);
257 } else {
258 fputc('.', stderr);
259 }
260 x++;
261 }
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700262 fputs(tag, stderr);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800263}
264#endif
265
266static void send_ready(unsigned local, unsigned remote, atransport *t)
267{
268 D("Calling send_ready \n");
269 apacket *p = get_apacket();
270 p->msg.command = A_OKAY;
271 p->msg.arg0 = local;
272 p->msg.arg1 = remote;
273 send_packet(p, t);
274}
275
276static void send_close(unsigned local, unsigned remote, atransport *t)
277{
278 D("Calling send_close \n");
279 apacket *p = get_apacket();
280 p->msg.command = A_CLSE;
281 p->msg.arg0 = local;
282 p->msg.arg1 = remote;
283 send_packet(p, t);
284}
285
Scott Andersone82c2db2012-05-25 14:10:02 -0700286static size_t fill_connect_data(char *buf, size_t bufsize)
287{
288#if ADB_HOST
289 return snprintf(buf, bufsize, "host::") + 1;
290#else
291 static const char *cnxn_props[] = {
292 "ro.product.name",
293 "ro.product.model",
294 "ro.product.device",
295 };
296 static const int num_cnxn_props = ARRAY_SIZE(cnxn_props);
297 int i;
298 size_t remaining = bufsize;
299 size_t len;
300
301 len = snprintf(buf, remaining, "%s::", adb_device_banner);
302 remaining -= len;
303 buf += len;
304 for (i = 0; i < num_cnxn_props; i++) {
305 char value[PROPERTY_VALUE_MAX];
306 property_get(cnxn_props[i], value, "");
307 len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i], value);
308 remaining -= len;
309 buf += len;
310 }
311
312 return bufsize - remaining + 1;
313#endif
314}
315
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800316static void send_connect(atransport *t)
317{
318 D("Calling send_connect \n");
319 apacket *cp = get_apacket();
320 cp->msg.command = A_CNXN;
321 cp->msg.arg0 = A_VERSION;
322 cp->msg.arg1 = MAX_PAYLOAD;
Scott Andersone82c2db2012-05-25 14:10:02 -0700323 cp->msg.data_length = fill_connect_data((char *)cp->data,
324 sizeof(cp->data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800325 send_packet(cp, t);
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700326}
327
328static void send_auth_request(atransport *t)
329{
330 D("Calling send_auth_request\n");
331 apacket *p;
332 int ret;
333
334 ret = adb_auth_generate_token(t->token, sizeof(t->token));
335 if (ret != sizeof(t->token)) {
336 D("Error generating token ret=%d\n", ret);
337 return;
338 }
339
340 p = get_apacket();
341 memcpy(p->data, t->token, ret);
342 p->msg.command = A_AUTH;
343 p->msg.arg0 = ADB_AUTH_TOKEN;
344 p->msg.data_length = ret;
345 send_packet(p, t);
346}
347
348static void send_auth_response(uint8_t *token, size_t token_size, atransport *t)
349{
350 D("Calling send_auth_response\n");
351 apacket *p = get_apacket();
352 int ret;
353
354 ret = adb_auth_sign(t->key, token, token_size, p->data);
355 if (!ret) {
356 D("Error signing the token\n");
357 put_apacket(p);
358 return;
359 }
360
361 p->msg.command = A_AUTH;
362 p->msg.arg0 = ADB_AUTH_SIGNATURE;
363 p->msg.data_length = ret;
364 send_packet(p, t);
365}
366
367static void send_auth_publickey(atransport *t)
368{
369 D("Calling send_auth_publickey\n");
370 apacket *p = get_apacket();
371 int ret;
372
373 ret = adb_auth_get_userkey(p->data, sizeof(p->data));
374 if (!ret) {
375 D("Failed to get user public key\n");
376 put_apacket(p);
377 return;
378 }
379
380 p->msg.command = A_AUTH;
381 p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;
382 p->msg.data_length = ret;
383 send_packet(p, t);
384}
385
386void adb_auth_verified(atransport *t)
387{
388 handle_online(t);
389 send_connect(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800390}
391
392static char *connection_state_name(atransport *t)
393{
394 if (t == NULL) {
395 return "unknown";
396 }
397
398 switch(t->connection_state) {
399 case CS_BOOTLOADER:
400 return "bootloader";
401 case CS_DEVICE:
402 return "device";
403 case CS_OFFLINE:
404 return "offline";
405 default:
406 return "unknown";
407 }
408}
409
Scott Andersone82c2db2012-05-25 14:10:02 -0700410/* qual_overwrite is used to overwrite a qualifier string. dst is a
411 * pointer to a char pointer. It is assumed that if *dst is non-NULL, it
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700412 * was malloc'ed and needs to freed. *dst will be set to a dup of src.
Scott Andersone82c2db2012-05-25 14:10:02 -0700413 */
414static void qual_overwrite(char **dst, const char *src)
415{
416 if (!dst)
417 return;
418
419 free(*dst);
420 *dst = NULL;
421
422 if (!src || !*src)
423 return;
424
425 *dst = strdup(src);
426}
427
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800428void parse_banner(char *banner, atransport *t)
429{
Scott Andersone82c2db2012-05-25 14:10:02 -0700430 static const char *prop_seps = ";";
431 static const char key_val_sep = '=';
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700432 char *cp;
433 char *type;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800434
435 D("parse_banner: %s\n", banner);
436 type = banner;
Scott Andersone82c2db2012-05-25 14:10:02 -0700437 cp = strchr(type, ':');
438 if (cp) {
439 *cp++ = 0;
440 /* Nothing is done with second field. */
441 cp = strchr(cp, ':');
442 if (cp) {
443 char *save;
444 char *key;
Scott Anderson1b7a7e82012-06-05 17:54:27 -0700445 key = adb_strtok_r(cp + 1, prop_seps, &save);
Scott Andersone82c2db2012-05-25 14:10:02 -0700446 while (key) {
447 cp = strchr(key, key_val_sep);
448 if (cp) {
449 *cp++ = '\0';
450 if (!strcmp(key, "ro.product.name"))
451 qual_overwrite(&t->product, cp);
452 else if (!strcmp(key, "ro.product.model"))
453 qual_overwrite(&t->model, cp);
454 else if (!strcmp(key, "ro.product.device"))
455 qual_overwrite(&t->device, cp);
456 }
Scott Anderson1b7a7e82012-06-05 17:54:27 -0700457 key = adb_strtok_r(NULL, prop_seps, &save);
Scott Andersone82c2db2012-05-25 14:10:02 -0700458 }
459 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800460 }
461
462 if(!strcmp(type, "bootloader")){
463 D("setting connection_state to CS_BOOTLOADER\n");
464 t->connection_state = CS_BOOTLOADER;
465 update_transports();
466 return;
467 }
468
469 if(!strcmp(type, "device")) {
470 D("setting connection_state to CS_DEVICE\n");
471 t->connection_state = CS_DEVICE;
472 update_transports();
473 return;
474 }
475
476 if(!strcmp(type, "recovery")) {
477 D("setting connection_state to CS_RECOVERY\n");
478 t->connection_state = CS_RECOVERY;
479 update_transports();
480 return;
481 }
482
Doug Zongker447f0612012-01-09 14:54:53 -0800483 if(!strcmp(type, "sideload")) {
484 D("setting connection_state to CS_SIDELOAD\n");
485 t->connection_state = CS_SIDELOAD;
486 update_transports();
487 return;
488 }
489
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800490 t->connection_state = CS_HOST;
491}
492
493void handle_packet(apacket *p, atransport *t)
494{
495 asocket *s;
496
Viral Mehta899913f2010-06-16 18:41:28 +0530497 D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],
498 ((char*) (&(p->msg.command)))[1],
499 ((char*) (&(p->msg.command)))[2],
500 ((char*) (&(p->msg.command)))[3]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800501 print_packet("recv", p);
502
503 switch(p->msg.command){
504 case A_SYNC:
505 if(p->msg.arg0){
506 send_packet(p, t);
507 if(HOST) send_connect(t);
508 } else {
509 t->connection_state = CS_OFFLINE;
510 handle_offline(t);
511 send_packet(p, t);
512 }
513 return;
514
515 case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
516 /* XXX verify version, etc */
517 if(t->connection_state != CS_OFFLINE) {
518 t->connection_state = CS_OFFLINE;
519 handle_offline(t);
520 }
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700521
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800522 parse_banner((char*) p->data, t);
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700523
524 if (HOST || !auth_enabled) {
525 handle_online(t);
526 if(!HOST) send_connect(t);
527 } else {
528 send_auth_request(t);
529 }
530 break;
531
532 case A_AUTH:
533 if (p->msg.arg0 == ADB_AUTH_TOKEN) {
534 t->key = adb_auth_nextkey(t->key);
535 if (t->key) {
536 send_auth_response(p->data, p->msg.data_length, t);
537 } else {
538 /* No more private keys to try, send the public key */
539 send_auth_publickey(t);
540 }
541 } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
542 if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {
543 adb_auth_verified(t);
544 t->failed_auth_attempts = 0;
545 } else {
546 if (t->failed_auth_attempts++ > 10)
547 adb_sleep_ms(1000);
548 send_auth_request(t);
549 }
550 } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
551 adb_auth_confirm_key(p->data, p->msg.data_length, t);
552 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800553 break;
554
555 case A_OPEN: /* OPEN(local-id, 0, "destination") */
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700556 if (t->online) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800557 char *name = (char*) p->data;
558 name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
559 s = create_local_service_socket(name);
560 if(s == 0) {
561 send_close(0, p->msg.arg0, t);
562 } else {
563 s->peer = create_remote_socket(p->msg.arg0, t);
564 s->peer->peer = s;
565 send_ready(s->id, s->peer->id, t);
566 s->ready(s);
567 }
568 }
569 break;
570
571 case A_OKAY: /* READY(local-id, remote-id, "") */
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700572 if (t->online) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800573 if((s = find_local_socket(p->msg.arg1))) {
574 if(s->peer == 0) {
575 s->peer = create_remote_socket(p->msg.arg0, t);
576 s->peer->peer = s;
577 }
578 s->ready(s);
579 }
580 }
581 break;
582
583 case A_CLSE: /* CLOSE(local-id, remote-id, "") */
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700584 if (t->online) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800585 if((s = find_local_socket(p->msg.arg1))) {
586 s->close(s);
587 }
588 }
589 break;
590
591 case A_WRTE:
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700592 if (t->online) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800593 if((s = find_local_socket(p->msg.arg1))) {
594 unsigned rid = p->msg.arg0;
595 p->len = p->msg.data_length;
596
597 if(s->enqueue(s, p) == 0) {
598 D("Enqueue the socket\n");
599 send_ready(s->id, rid, t);
600 }
601 return;
602 }
603 }
604 break;
605
606 default:
607 printf("handle_packet: what is %08x?!\n", p->msg.command);
608 }
609
610 put_apacket(p);
611}
612
613alistener listener_list = {
614 .next = &listener_list,
615 .prev = &listener_list,
616};
617
618static void ss_listener_event_func(int _fd, unsigned ev, void *_l)
619{
620 asocket *s;
621
622 if(ev & FDE_READ) {
623 struct sockaddr addr;
624 socklen_t alen;
625 int fd;
626
627 alen = sizeof(addr);
628 fd = adb_socket_accept(_fd, &addr, &alen);
629 if(fd < 0) return;
630
631 adb_socket_setbufsize(fd, CHUNK_SIZE);
632
633 s = create_local_socket(fd);
634 if(s) {
635 connect_to_smartsocket(s);
636 return;
637 }
638
639 adb_close(fd);
640 }
641}
642
643static void listener_event_func(int _fd, unsigned ev, void *_l)
644{
645 alistener *l = _l;
646 asocket *s;
647
648 if(ev & FDE_READ) {
649 struct sockaddr addr;
650 socklen_t alen;
651 int fd;
652
653 alen = sizeof(addr);
654 fd = adb_socket_accept(_fd, &addr, &alen);
655 if(fd < 0) return;
656
657 s = create_local_socket(fd);
658 if(s) {
659 s->transport = l->transport;
660 connect_to_remote(s, l->connect_to);
661 return;
662 }
663
664 adb_close(fd);
665 }
666}
667
668static void free_listener(alistener* l)
669{
670 if (l->next) {
671 l->next->prev = l->prev;
672 l->prev->next = l->next;
673 l->next = l->prev = l;
674 }
675
676 // closes the corresponding fd
677 fdevent_remove(&l->fde);
678
679 if (l->local_name)
680 free((char*)l->local_name);
681
682 if (l->connect_to)
683 free((char*)l->connect_to);
684
685 if (l->transport) {
686 remove_transport_disconnect(l->transport, &l->disconnect);
687 }
688 free(l);
689}
690
691static void listener_disconnect(void* _l, atransport* t)
692{
693 alistener* l = _l;
694
695 free_listener(l);
696}
697
698int local_name_to_fd(const char *name)
699{
700 int port;
701
702 if(!strncmp("tcp:", name, 4)){
703 int ret;
704 port = atoi(name + 4);
Matt Gumbeld7b33082012-11-14 10:16:17 -0800705
706 if (gListenAll > 0) {
707 ret = socket_inaddr_any_server(port, SOCK_STREAM);
708 } else {
709 ret = socket_loopback_server(port, SOCK_STREAM);
710 }
711
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800712 return ret;
713 }
714#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */
715 // It's non-sensical to support the "reserved" space on the adb host side
716 if(!strncmp(name, "local:", 6)) {
717 return socket_local_server(name + 6,
718 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
719 } else if(!strncmp(name, "localabstract:", 14)) {
720 return socket_local_server(name + 14,
721 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
722 } else if(!strncmp(name, "localfilesystem:", 16)) {
723 return socket_local_server(name + 16,
724 ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
725 }
726
727#endif
728 printf("unknown local portname '%s'\n", name);
729 return -1;
730}
731
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100732// Write a single line describing a listener to a user-provided buffer.
733// Appends a trailing zero, even in case of truncation, but the function
734// returns the full line length.
735// If |buffer| is NULL, does not write but returns required size.
736static int format_listener(alistener* l, char* buffer, size_t buffer_len) {
737 // Format is simply:
738 //
739 // <device-serial> " " <local-name> " " <remote-name> "\n"
740 //
741 int local_len = strlen(l->local_name);
742 int connect_len = strlen(l->connect_to);
743 int serial_len = strlen(l->transport->serial);
744
745 if (buffer != NULL) {
746 snprintf(buffer, buffer_len, "%s %s %s\n",
747 l->transport->serial, l->local_name, l->connect_to);
748 }
749 // NOTE: snprintf() on Windows returns -1 in case of truncation, so
750 // return the computed line length instead.
751 return local_len + connect_len + serial_len + 3;
752}
753
754// Write the list of current listeners (network redirections) into a
755// user-provided buffer. Appends a trailing zero, even in case of
756// trunctaion, but return the full size in bytes.
757// If |buffer| is NULL, does not write but returns required size.
758static int format_listeners(char* buf, size_t buflen)
759{
760 alistener* l;
761 int result = 0;
762 for (l = listener_list.next; l != &listener_list; l = l->next) {
763 // Ignore special listeners like those for *smartsocket*
764 if (l->connect_to[0] == '*')
765 continue;
766 int len = format_listener(l, buf, buflen);
767 // Ensure there is space for the trailing zero.
768 result += len;
769 if (buf != NULL) {
770 buf += len;
771 buflen -= len;
772 if (buflen <= 0)
773 break;
774 }
775 }
776 return result;
777}
778
779static int remove_listener(const char *local_name, atransport* transport)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800780{
781 alistener *l;
782
783 for (l = listener_list.next; l != &listener_list; l = l->next) {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100784 if (!strcmp(local_name, l->local_name)) {
785 listener_disconnect(l, l->transport);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800786 return 0;
787 }
788 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800789 return -1;
790}
791
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100792static void remove_all_listeners(void)
793{
794 alistener *l, *l_next;
795 for (l = listener_list.next; l != &listener_list; l = l_next) {
796 l_next = l->next;
797 // Never remove smart sockets.
798 if (l->connect_to[0] == '*')
799 continue;
800 listener_disconnect(l, l->transport);
801 }
802}
803
804// error/status codes for install_listener.
805typedef enum {
806 INSTALL_STATUS_OK = 0,
807 INSTALL_STATUS_INTERNAL_ERROR = -1,
808 INSTALL_STATUS_CANNOT_BIND = -2,
809 INSTALL_STATUS_CANNOT_REBIND = -3,
810} install_status_t;
811
812static install_status_t install_listener(const char *local_name,
813 const char *connect_to,
814 atransport* transport,
815 int no_rebind)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800816{
817 alistener *l;
818
819 //printf("install_listener('%s','%s')\n", local_name, connect_to);
820
821 for(l = listener_list.next; l != &listener_list; l = l->next){
822 if(strcmp(local_name, l->local_name) == 0) {
823 char *cto;
824
825 /* can't repurpose a smartsocket */
826 if(l->connect_to[0] == '*') {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100827 return INSTALL_STATUS_INTERNAL_ERROR;
828 }
829
830 /* can't repurpose a listener if 'no_rebind' is true */
831 if (no_rebind) {
832 return INSTALL_STATUS_CANNOT_REBIND;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800833 }
834
835 cto = strdup(connect_to);
836 if(cto == 0) {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100837 return INSTALL_STATUS_INTERNAL_ERROR;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800838 }
839
840 //printf("rebinding '%s' to '%s'\n", local_name, connect_to);
841 free((void*) l->connect_to);
842 l->connect_to = cto;
843 if (l->transport != transport) {
844 remove_transport_disconnect(l->transport, &l->disconnect);
845 l->transport = transport;
846 add_transport_disconnect(l->transport, &l->disconnect);
847 }
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100848 return INSTALL_STATUS_OK;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800849 }
850 }
851
852 if((l = calloc(1, sizeof(alistener))) == 0) goto nomem;
853 if((l->local_name = strdup(local_name)) == 0) goto nomem;
854 if((l->connect_to = strdup(connect_to)) == 0) goto nomem;
855
856
857 l->fd = local_name_to_fd(local_name);
858 if(l->fd < 0) {
859 free((void*) l->local_name);
860 free((void*) l->connect_to);
861 free(l);
862 printf("cannot bind '%s'\n", local_name);
863 return -2;
864 }
865
866 close_on_exec(l->fd);
867 if(!strcmp(l->connect_to, "*smartsocket*")) {
868 fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);
869 } else {
870 fdevent_install(&l->fde, l->fd, listener_event_func, l);
871 }
872 fdevent_set(&l->fde, FDE_READ);
873
874 l->next = &listener_list;
875 l->prev = listener_list.prev;
876 l->next->prev = l;
877 l->prev->next = l;
878 l->transport = transport;
879
880 if (transport) {
881 l->disconnect.opaque = l;
882 l->disconnect.func = listener_disconnect;
883 add_transport_disconnect(transport, &l->disconnect);
884 }
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100885 return INSTALL_STATUS_OK;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800886
887nomem:
888 fatal("cannot allocate listener");
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +0100889 return INSTALL_STATUS_INTERNAL_ERROR;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800890}
891
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800892#ifdef HAVE_WIN32_PROC
893static BOOL WINAPI ctrlc_handler(DWORD type)
894{
895 exit(STATUS_CONTROL_C_EXIT);
896 return TRUE;
897}
898#endif
899
900static void adb_cleanup(void)
901{
902 usb_cleanup();
903}
904
905void start_logging(void)
906{
907#ifdef HAVE_WIN32_PROC
908 char temp[ MAX_PATH ];
909 FILE* fnul;
910 FILE* flog;
911
912 GetTempPath( sizeof(temp) - 8, temp );
913 strcat( temp, "adb.log" );
914
915 /* Win32 specific redirections */
916 fnul = fopen( "NUL", "rt" );
917 if (fnul != NULL)
918 stdin[0] = fnul[0];
919
920 flog = fopen( temp, "at" );
921 if (flog == NULL)
922 flog = fnul;
923
924 setvbuf( flog, NULL, _IONBF, 0 );
925
926 stdout[0] = flog[0];
927 stderr[0] = flog[0];
928 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
929#else
930 int fd;
931
932 fd = unix_open("/dev/null", O_RDONLY);
933 dup2(fd, 0);
JP Abgrall408fa572011-03-16 15:57:42 -0700934 adb_close(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800935
936 fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);
937 if(fd < 0) {
938 fd = unix_open("/dev/null", O_WRONLY);
939 }
940 dup2(fd, 1);
941 dup2(fd, 2);
JP Abgrall408fa572011-03-16 15:57:42 -0700942 adb_close(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800943 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
944#endif
945}
946
947#if !ADB_HOST
948void start_device_log(void)
949{
950 int fd;
Mike Lockwood1f546e62009-05-25 18:17:55 -0400951 char path[PATH_MAX];
952 struct tm now;
953 time_t t;
954 char value[PROPERTY_VALUE_MAX];
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800955
Mike Lockwood1f546e62009-05-25 18:17:55 -0400956 // read the trace mask from persistent property persist.adb.trace_mask
957 // give up if the property is not set or cannot be parsed
958 property_get("persist.adb.trace_mask", value, "");
959 if (sscanf(value, "%x", &adb_trace_mask) != 1)
960 return;
961
962 adb_mkdir("/data/adb", 0775);
963 tzset();
964 time(&t);
965 localtime_r(&t, &now);
966 strftime(path, sizeof(path),
967 "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt",
968 &now);
969 fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800970 if (fd < 0)
971 return;
972
973 // redirect stdout and stderr to the log file
974 dup2(fd, 1);
975 dup2(fd, 2);
976 fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
Benoit Goby95ef8282011-02-01 18:57:41 -0800977 adb_close(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800978
979 fd = unix_open("/dev/null", O_RDONLY);
980 dup2(fd, 0);
Benoit Goby95ef8282011-02-01 18:57:41 -0800981 adb_close(fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800982}
983#endif
984
985#if ADB_HOST
Stefan Hilzingera84a42e2010-04-19 12:21:12 +0100986int launch_server(int server_port)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800987{
988#ifdef HAVE_WIN32_PROC
989 /* we need to start the server in the background */
990 /* we create a PIPE that will be used to wait for the server's "OK" */
991 /* message since the pipe handles must be inheritable, we use a */
992 /* security attribute */
993 HANDLE pipe_read, pipe_write;
Ray Donnelly267aa8b2012-11-29 01:18:50 +0000994 HANDLE stdout_handle, stderr_handle;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800995 SECURITY_ATTRIBUTES sa;
996 STARTUPINFO startup;
997 PROCESS_INFORMATION pinfo;
998 char program_path[ MAX_PATH ];
999 int ret;
1000
1001 sa.nLength = sizeof(sa);
1002 sa.lpSecurityDescriptor = NULL;
1003 sa.bInheritHandle = TRUE;
1004
1005 /* create pipe, and ensure its read handle isn't inheritable */
1006 ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 );
1007 if (!ret) {
1008 fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() );
1009 return -1;
1010 }
1011
1012 SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 );
1013
Ray Donnelly267aa8b2012-11-29 01:18:50 +00001014 /* Some programs want to launch an adb command and collect its output by
1015 * calling CreateProcess with inheritable stdout/stderr handles, then
1016 * using read() to get its output. When this happens, the stdout/stderr
1017 * handles passed to the adb client process will also be inheritable.
1018 * When starting the adb server here, care must be taken to reset them
1019 * to non-inheritable.
1020 * Otherwise, something bad happens: even if the adb command completes,
1021 * the calling process is stuck while read()-ing from the stdout/stderr
1022 * descriptors, because they're connected to corresponding handles in the
1023 * adb server process (even if the latter never uses/writes to them).
1024 */
1025 stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE );
1026 stderr_handle = GetStdHandle( STD_ERROR_HANDLE );
1027 if (stdout_handle != INVALID_HANDLE_VALUE) {
1028 SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 );
1029 }
1030 if (stderr_handle != INVALID_HANDLE_VALUE) {
1031 SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 );
1032 }
1033
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001034 ZeroMemory( &startup, sizeof(startup) );
1035 startup.cb = sizeof(startup);
1036 startup.hStdInput = GetStdHandle( STD_INPUT_HANDLE );
1037 startup.hStdOutput = pipe_write;
1038 startup.hStdError = GetStdHandle( STD_ERROR_HANDLE );
1039 startup.dwFlags = STARTF_USESTDHANDLES;
1040
1041 ZeroMemory( &pinfo, sizeof(pinfo) );
1042
1043 /* get path of current program */
1044 GetModuleFileName( NULL, program_path, sizeof(program_path) );
1045
1046 ret = CreateProcess(
1047 program_path, /* program path */
1048 "adb fork-server server",
1049 /* the fork-server argument will set the
1050 debug = 2 in the child */
1051 NULL, /* process handle is not inheritable */
1052 NULL, /* thread handle is not inheritable */
1053 TRUE, /* yes, inherit some handles */
1054 DETACHED_PROCESS, /* the new process doesn't have a console */
1055 NULL, /* use parent's environment block */
1056 NULL, /* use parent's starting directory */
1057 &startup, /* startup info, i.e. std handles */
1058 &pinfo );
1059
1060 CloseHandle( pipe_write );
1061
1062 if (!ret) {
1063 fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() );
1064 CloseHandle( pipe_read );
1065 return -1;
1066 }
1067
1068 CloseHandle( pinfo.hProcess );
1069 CloseHandle( pinfo.hThread );
1070
1071 /* wait for the "OK\n" message */
1072 {
1073 char temp[3];
1074 DWORD count;
1075
1076 ret = ReadFile( pipe_read, temp, 3, &count, NULL );
1077 CloseHandle( pipe_read );
1078 if ( !ret ) {
1079 fprintf(stderr, "could not read ok from ADB Server, error = %ld\n", GetLastError() );
1080 return -1;
1081 }
1082 if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
1083 fprintf(stderr, "ADB server didn't ACK\n" );
1084 return -1;
1085 }
1086 }
1087#elif defined(HAVE_FORKEXEC)
1088 char path[PATH_MAX];
1089 int fd[2];
1090
1091 // set up a pipe so the child can tell us when it is ready.
1092 // fd[0] will be parent's end, and fd[1] will get mapped to stderr in the child.
1093 if (pipe(fd)) {
1094 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
1095 return -1;
1096 }
Alexey Tarasov31664102009-10-22 02:55:00 +11001097 get_my_path(path, PATH_MAX);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001098 pid_t pid = fork();
1099 if(pid < 0) return -1;
1100
1101 if (pid == 0) {
1102 // child side of the fork
1103
1104 // redirect stderr to the pipe
1105 // we use stderr instead of stdout due to stdout's buffering behavior.
1106 adb_close(fd[0]);
1107 dup2(fd[1], STDERR_FILENO);
1108 adb_close(fd[1]);
1109
Matt Gumbeld7b33082012-11-14 10:16:17 -08001110 char str_port[30];
1111 snprintf(str_port, sizeof(str_port), "%d", server_port);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001112 // child process
Matt Gumbeld7b33082012-11-14 10:16:17 -08001113 int result = execl(path, "adb", "-P", str_port, "fork-server", "server", NULL);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001114 // this should not return
1115 fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
1116 } else {
1117 // parent side of the fork
1118
1119 char temp[3];
1120
1121 temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
1122 // wait for the "OK\n" message
1123 adb_close(fd[1]);
1124 int ret = adb_read(fd[0], temp, 3);
JP Abgrall408fa572011-03-16 15:57:42 -07001125 int saved_errno = errno;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001126 adb_close(fd[0]);
1127 if (ret < 0) {
JP Abgrall408fa572011-03-16 15:57:42 -07001128 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001129 return -1;
1130 }
1131 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
1132 fprintf(stderr, "ADB server didn't ACK\n" );
1133 return -1;
1134 }
1135
1136 setsid();
1137 }
1138#else
1139#error "cannot implement background server start on this platform"
1140#endif
1141 return 0;
1142}
1143#endif
1144
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001145/* Constructs a local name of form tcp:port.
1146 * target_str points to the target string, it's content will be overwritten.
1147 * target_size is the capacity of the target string.
1148 * server_port is the port number to use for the local name.
1149 */
1150void build_local_name(char* target_str, size_t target_size, int server_port)
1151{
1152 snprintf(target_str, target_size, "tcp:%d", server_port);
1153}
1154
Nick Kralevichbd9206b2012-01-19 10:18:59 -08001155#if !ADB_HOST
1156static int should_drop_privileges() {
Nick Kralevich5890fe32012-01-19 13:11:35 -08001157#ifndef ALLOW_ADBD_ROOT
1158 return 1;
1159#else /* ALLOW_ADBD_ROOT */
Nick Kralevichbd9206b2012-01-19 10:18:59 -08001160 int secure = 0;
1161 char value[PROPERTY_VALUE_MAX];
1162
1163 /* run adbd in secure mode if ro.secure is set and
1164 ** we are not in the emulator
1165 */
1166 property_get("ro.kernel.qemu", value, "");
1167 if (strcmp(value, "1") != 0) {
1168 property_get("ro.secure", value, "1");
1169 if (strcmp(value, "1") == 0) {
1170 // don't run as root if ro.secure is set...
1171 secure = 1;
1172
1173 // ... except we allow running as root in userdebug builds if the
1174 // service.adb.root property has been set by the "adb root" command
1175 property_get("ro.debuggable", value, "");
1176 if (strcmp(value, "1") == 0) {
1177 property_get("service.adb.root", value, "");
1178 if (strcmp(value, "1") == 0) {
1179 secure = 0;
1180 }
1181 }
1182 }
1183 }
1184 return secure;
Nick Kralevich5890fe32012-01-19 13:11:35 -08001185#endif /* ALLOW_ADBD_ROOT */
Nick Kralevichbd9206b2012-01-19 10:18:59 -08001186}
1187#endif /* !ADB_HOST */
1188
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001189int adb_main(int is_daemon, int server_port)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001190{
1191#if !ADB_HOST
Mike Lockwood2f38b692009-08-24 15:58:40 -07001192 int port;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001193 char value[PROPERTY_VALUE_MAX];
Nick Kralevicheb68fa82012-04-02 13:00:35 -07001194
1195 umask(000);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001196#endif
1197
1198 atexit(adb_cleanup);
1199#ifdef HAVE_WIN32_PROC
1200 SetConsoleCtrlHandler( ctrlc_handler, TRUE );
1201#elif defined(HAVE_FORKEXEC)
JP Abgrall408fa572011-03-16 15:57:42 -07001202 // No SIGCHLD. Let the service subproc handle its children.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001203 signal(SIGPIPE, SIG_IGN);
1204#endif
1205
1206 init_transport_registration();
1207
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001208#if ADB_HOST
1209 HOST = 1;
Xavier Ducroheta09fbd12009-05-20 17:33:53 -07001210 usb_vendors_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001211 usb_init();
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001212 local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
Benoit Gobyd5fcafa2012-04-12 12:23:49 -07001213 adb_auth_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001214
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001215 char local_name[30];
1216 build_local_name(local_name, sizeof(local_name), server_port);
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001217 if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001218 exit(1);
1219 }
1220#else
Benoit Gobyd5fcafa2012-04-12 12:23:49 -07001221 property_get("ro.adb.secure", value, "0");
1222 auth_enabled = !strcmp(value, "1");
1223 if (auth_enabled)
1224 adb_auth_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001225
Jeff Sharkeyd6d42862012-09-06 13:05:40 -07001226 // Our external storage path may be different than apps, since
1227 // we aren't able to bind mount after dropping root.
1228 const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
1229 if (NULL != adb_external_storage) {
1230 setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
1231 } else {
1232 D("Warning: ADB_EXTERNAL_STORAGE is not set. Leaving EXTERNAL_STORAGE"
1233 " unchanged.\n");
1234 }
1235
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001236 /* don't listen on a port (default 5037) if running in secure mode */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001237 /* don't run as root if we are running in secure mode */
Nick Kralevichbd9206b2012-01-19 10:18:59 -08001238 if (should_drop_privileges()) {
Mike Lockwood5f4b0512009-08-04 20:37:51 -04001239 struct __user_cap_header_struct header;
1240 struct __user_cap_data_struct cap;
1241
Nick Kralevich44db9902010-08-27 14:35:07 -07001242 if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {
1243 exit(1);
1244 }
Mike Lockwood5f4b0512009-08-04 20:37:51 -04001245
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001246 /* add extra groups:
1247 ** AID_ADB to access the USB driver
1248 ** AID_LOG to read system logs (adb logcat)
1249 ** AID_INPUT to diagnose input issues (getevent)
1250 ** AID_INET to diagnose network issues (netcfg, ping)
1251 ** AID_GRAPHICS to access the frame buffer
The Android Open Source Project20155492009-03-11 12:12:01 -07001252 ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
Dianne Hackborn50458cf2012-03-07 12:57:14 -08001253 ** AID_SDCARD_R to allow reading from the SD card
Mike Lockwood6a3075c2009-05-25 13:52:00 -04001254 ** AID_SDCARD_RW to allow writing to the SD card
Mike Lockwoodd969faa2010-02-24 16:07:23 -05001255 ** AID_MOUNT to allow unmounting the SD card before rebooting
JP Abgrall61b90bd2011-11-09 10:30:08 -08001256 ** AID_NET_BW_STATS to read out qtaguid statistics
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001257 */
The Android Open Source Project20155492009-03-11 12:12:01 -07001258 gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
Dianne Hackborn50458cf2012-03-07 12:57:14 -08001259 AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,
1260 AID_MOUNT, AID_NET_BW_STATS };
Nick Kralevich44db9902010-08-27 14:35:07 -07001261 if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
1262 exit(1);
1263 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001264
1265 /* then switch user and group to "shell" */
Nick Kralevich44db9902010-08-27 14:35:07 -07001266 if (setgid(AID_SHELL) != 0) {
1267 exit(1);
1268 }
1269 if (setuid(AID_SHELL) != 0) {
1270 exit(1);
1271 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001272
Mike Lockwood5f4b0512009-08-04 20:37:51 -04001273 /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
1274 header.version = _LINUX_CAPABILITY_VERSION;
1275 header.pid = 0;
1276 cap.effective = cap.permitted = (1 << CAP_SYS_BOOT);
1277 cap.inheritable = 0;
1278 capset(&header, &cap);
1279
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001280 D("Local port disabled\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001281 } else {
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001282 char local_name[30];
1283 build_local_name(local_name, sizeof(local_name), server_port);
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001284 if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001285 exit(1);
1286 }
1287 }
1288
Mike J. Chen1dd55c52012-07-20 18:16:21 -07001289 int usb = 0;
1290 if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
Mike Lockwoodcef31a02009-08-26 12:50:22 -07001291 // listen on USB
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001292 usb_init();
Mike J. Chen1dd55c52012-07-20 18:16:21 -07001293 usb = 1;
1294 }
1295
1296 // If one of these properties is set, also listen on that port
1297 // If one of the properties isn't set and we couldn't listen on usb,
1298 // listen on the default port.
1299 property_get("service.adb.tcp.port", value, "");
1300 if (!value[0]) {
1301 property_get("persist.adb.tcp.port", value, "");
1302 }
1303 if (sscanf(value, "%d", &port) == 1 && port > 0) {
1304 printf("using port=%d\n", port);
1305 // listen on TCP port specified by service.adb.tcp.port property
1306 local_init(port);
1307 } else if (!usb) {
Mike Lockwoodcef31a02009-08-26 12:50:22 -07001308 // listen on default port
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001309 local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001310 }
Mike J. Chen1dd55c52012-07-20 18:16:21 -07001311
JP Abgrall408fa572011-03-16 15:57:42 -07001312 D("adb_main(): pre init_jdwp()\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001313 init_jdwp();
JP Abgrall408fa572011-03-16 15:57:42 -07001314 D("adb_main(): post init_jdwp()\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001315#endif
1316
1317 if (is_daemon)
1318 {
1319 // inform our parent that we are up and running.
1320#ifdef HAVE_WIN32_PROC
1321 DWORD count;
1322 WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );
1323#elif defined(HAVE_FORKEXEC)
1324 fprintf(stderr, "OK\n");
1325#endif
1326 start_logging();
1327 }
JP Abgrall408fa572011-03-16 15:57:42 -07001328 D("Event loop starting\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001329
1330 fdevent_loop();
1331
1332 usb_cleanup();
1333
1334 return 0;
1335}
1336
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001337#if ADB_HOST
1338void connect_device(char* host, char* buffer, int buffer_size)
1339{
1340 int port, fd;
1341 char* portstr = strchr(host, ':');
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001342 char hostbuf[100];
1343 char serial[100];
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001344
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001345 strncpy(hostbuf, host, sizeof(hostbuf) - 1);
1346 if (portstr) {
Scott Andersonc7993af2012-05-25 13:55:46 -07001347 if (portstr - host >= (ptrdiff_t)sizeof(hostbuf)) {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001348 snprintf(buffer, buffer_size, "bad host name %s", host);
1349 return;
1350 }
1351 // zero terminate the host at the point we found the colon
1352 hostbuf[portstr - host] = 0;
1353 if (sscanf(portstr + 1, "%d", &port) == 0) {
1354 snprintf(buffer, buffer_size, "bad port number %s", portstr);
1355 return;
1356 }
1357 } else {
1358 port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001359 }
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001360
1361 snprintf(serial, sizeof(serial), "%s:%d", hostbuf, port);
1362 if (find_transport(serial)) {
1363 snprintf(buffer, buffer_size, "already connected to %s", serial);
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001364 return;
1365 }
1366
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001367 fd = socket_network_client(hostbuf, port, SOCK_STREAM);
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001368 if (fd < 0) {
1369 snprintf(buffer, buffer_size, "unable to connect to %s:%d", host, port);
1370 return;
1371 }
1372
1373 D("client: connected on remote on fd %d\n", fd);
1374 close_on_exec(fd);
1375 disable_tcp_nagle(fd);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001376 register_socket_transport(fd, serial, port, 0);
1377 snprintf(buffer, buffer_size, "connected to %s", serial);
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001378}
1379
1380void connect_emulator(char* port_spec, char* buffer, int buffer_size)
1381{
1382 char* port_separator = strchr(port_spec, ',');
1383 if (!port_separator) {
1384 snprintf(buffer, buffer_size,
1385 "unable to parse '%s' as <console port>,<adb port>",
1386 port_spec);
1387 return;
1388 }
1389
1390 // Zero-terminate console port and make port_separator point to 2nd port.
1391 *port_separator++ = 0;
1392 int console_port = strtol(port_spec, NULL, 0);
1393 int adb_port = strtol(port_separator, NULL, 0);
1394 if (!(console_port > 0 && adb_port > 0)) {
1395 *(port_separator - 1) = ',';
1396 snprintf(buffer, buffer_size,
1397 "Invalid port numbers: Expected positive numbers, got '%s'",
1398 port_spec);
1399 return;
1400 }
1401
1402 /* Check if the emulator is already known.
1403 * Note: There's a small but harmless race condition here: An emulator not
1404 * present just yet could be registered by another invocation right
1405 * after doing this check here. However, local_connect protects
1406 * against double-registration too. From here, a better error message
1407 * can be produced. In the case of the race condition, the very specific
1408 * error message won't be shown, but the data doesn't get corrupted. */
1409 atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
1410 if (known_emulator != NULL) {
1411 snprintf(buffer, buffer_size,
1412 "Emulator on port %d already registered.", adb_port);
1413 return;
1414 }
1415
1416 /* Check if more emulators can be registered. Similar unproblematic
1417 * race condition as above. */
1418 int candidate_slot = get_available_local_transport_index();
1419 if (candidate_slot < 0) {
1420 snprintf(buffer, buffer_size, "Cannot accept more emulators.");
1421 return;
1422 }
1423
1424 /* Preconditions met, try to connect to the emulator. */
1425 if (!local_connect_arbitrary_ports(console_port, adb_port)) {
1426 snprintf(buffer, buffer_size,
1427 "Connected to emulator on ports %d,%d", console_port, adb_port);
1428 } else {
1429 snprintf(buffer, buffer_size,
1430 "Could not connect to emulator on ports %d,%d",
1431 console_port, adb_port);
1432 }
1433}
1434#endif
1435
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001436int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s)
1437{
1438 atransport *transport = NULL;
1439 char buf[4096];
1440
1441 if(!strcmp(service, "kill")) {
1442 fprintf(stderr,"adb server killed by remote request\n");
1443 fflush(stdout);
1444 adb_write(reply_fd, "OKAY", 4);
1445 usb_cleanup();
1446 exit(0);
1447 }
1448
1449#if ADB_HOST
1450 // "transport:" is used for switching transport with a specified serial number
1451 // "transport-usb:" is used for switching transport to the only USB transport
1452 // "transport-local:" is used for switching transport to the only local transport
1453 // "transport-any:" is used for switching transport to the only transport
1454 if (!strncmp(service, "transport", strlen("transport"))) {
1455 char* error_string = "unknown failure";
1456 transport_type type = kTransportAny;
1457
1458 if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
1459 type = kTransportUsb;
1460 } else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
1461 type = kTransportLocal;
1462 } else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
1463 type = kTransportAny;
1464 } else if (!strncmp(service, "transport:", strlen("transport:"))) {
1465 service += strlen("transport:");
Tom Marlin3175c8e2011-07-27 12:56:14 -05001466 serial = service;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001467 }
1468
1469 transport = acquire_one_transport(CS_ANY, type, serial, &error_string);
1470
1471 if (transport) {
1472 s->transport = transport;
1473 adb_write(reply_fd, "OKAY", 4);
1474 } else {
1475 sendfailmsg(reply_fd, error_string);
1476 }
1477 return 1;
1478 }
1479
1480 // return a list of all connected devices
Scott Andersone109d262012-04-20 11:21:14 -07001481 if (!strncmp(service, "devices", 7)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001482 char buffer[4096];
Scott Andersone109d262012-04-20 11:21:14 -07001483 int use_long = !strcmp(service+7, "-l");
1484 if (use_long || service[7] == 0) {
1485 memset(buf, 0, sizeof(buf));
1486 memset(buffer, 0, sizeof(buffer));
1487 D("Getting device list \n");
1488 list_transports(buffer, sizeof(buffer), use_long);
1489 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer),buffer);
1490 D("Wrote device list \n");
1491 writex(reply_fd, buf, strlen(buf));
1492 return 0;
1493 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001494 }
1495
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001496 // add a new TCP transport, device or emulator
Mike Lockwood2f38b692009-08-24 15:58:40 -07001497 if (!strncmp(service, "connect:", 8)) {
1498 char buffer[4096];
Mike Lockwood2f38b692009-08-24 15:58:40 -07001499 char* host = service + 8;
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001500 if (!strncmp(host, "emu:", 4)) {
1501 connect_emulator(host + 4, buffer, sizeof(buffer));
1502 } else {
1503 connect_device(host, buffer, sizeof(buffer));
Mike Lockwood2f38b692009-08-24 15:58:40 -07001504 }
Stefan Hilzingerd9d1ca42010-04-26 10:17:43 +01001505 // Send response for emulator and device
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001506 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
1507 writex(reply_fd, buf, strlen(buf));
1508 return 0;
1509 }
1510
1511 // remove TCP transport
1512 if (!strncmp(service, "disconnect:", 11)) {
1513 char buffer[4096];
1514 memset(buffer, 0, sizeof(buffer));
1515 char* serial = service + 11;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001516 if (serial[0] == 0) {
1517 // disconnect from all TCP devices
1518 unregister_all_tcp_transports();
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001519 } else {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001520 char hostbuf[100];
1521 // assume port 5555 if no port is specified
1522 if (!strchr(serial, ':')) {
1523 snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555", serial);
1524 serial = hostbuf;
1525 }
1526 atransport *t = find_transport(serial);
1527
1528 if (t) {
1529 unregister_transport(t);
1530 } else {
1531 snprintf(buffer, sizeof(buffer), "No such device %s", serial);
1532 }
Mike Lockwood74d7ff82009-10-11 23:04:18 -04001533 }
1534
1535 snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
Mike Lockwood2f38b692009-08-24 15:58:40 -07001536 writex(reply_fd, buf, strlen(buf));
1537 return 0;
1538 }
1539
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001540 // returns our value for ADB_SERVER_VERSION
1541 if (!strcmp(service, "version")) {
1542 char version[12];
1543 snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION);
1544 snprintf(buf, sizeof buf, "OKAY%04x%s", (unsigned)strlen(version), version);
1545 writex(reply_fd, buf, strlen(buf));
1546 return 0;
1547 }
1548
1549 if(!strncmp(service,"get-serialno",strlen("get-serialno"))) {
1550 char *out = "unknown";
1551 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1552 if (transport && transport->serial) {
1553 out = transport->serial;
1554 }
1555 snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out);
1556 writex(reply_fd, buf, strlen(buf));
1557 return 0;
1558 }
Scott Andersone109d262012-04-20 11:21:14 -07001559 if(!strncmp(service,"get-devpath",strlen("get-devpath"))) {
1560 char *out = "unknown";
1561 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1562 if (transport && transport->devpath) {
1563 out = transport->devpath;
1564 }
1565 snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out);
1566 writex(reply_fd, buf, strlen(buf));
1567 return 0;
1568 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001569 // indicates a new emulator instance has started
1570 if (!strncmp(service,"emulator:",9)) {
1571 int port = atoi(service+9);
1572 local_connect(port);
1573 /* we don't even need to send a reply */
1574 return 0;
1575 }
1576#endif // ADB_HOST
1577
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001578 if(!strcmp(service,"list-forward")) {
1579 // Create the list of forward redirections.
1580 char header[9];
1581 int buffer_size = format_listeners(NULL, 0);
1582 // Add one byte for the trailing zero.
1583 char* buffer = malloc(buffer_size+1);
1584 (void) format_listeners(buffer, buffer_size+1);
1585 snprintf(header, sizeof header, "OKAY%04x", buffer_size);
1586 writex(reply_fd, header, 8);
1587 writex(reply_fd, buffer, buffer_size);
1588 free(buffer);
1589 return 0;
1590 }
1591
1592 if (!strcmp(service,"killforward-all")) {
1593 remove_all_listeners();
1594 adb_write(reply_fd, "OKAYOKAY", 8);
1595 return 0;
1596 }
1597
1598 if(!strncmp(service,"forward:",8) ||
1599 !strncmp(service,"killforward:",12)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001600 char *local, *remote, *err;
1601 int r;
1602 atransport *transport;
1603
1604 int createForward = strncmp(service,"kill",4);
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001605 int no_rebind = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001606
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001607 local = strchr(service, ':') + 1;
1608
1609 // Handle forward:norebind:<local>... here
1610 if (createForward && !strncmp(local, "norebind:", 9)) {
1611 no_rebind = 1;
1612 local = strchr(local, ':') + 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001613 }
1614
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001615 remote = strchr(local,';');
1616
1617 if (createForward) {
1618 // Check forward: parameter format: '<local>;<remote>'
1619 if(remote == 0) {
1620 sendfailmsg(reply_fd, "malformed forward spec");
1621 return 0;
1622 }
1623
1624 *remote++ = 0;
1625 if((local[0] == 0) || (remote[0] == 0) || (remote[0] == '*')){
1626 sendfailmsg(reply_fd, "malformed forward spec");
1627 return 0;
1628 }
1629 } else {
1630 // Check killforward: parameter format: '<local>'
1631 if (local[0] == 0) {
1632 sendfailmsg(reply_fd, "malformed forward spec");
1633 return 0;
1634 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001635 }
1636
1637 transport = acquire_one_transport(CS_ANY, ttype, serial, &err);
1638 if (!transport) {
1639 sendfailmsg(reply_fd, err);
1640 return 0;
1641 }
1642
1643 if (createForward) {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001644 r = install_listener(local, remote, transport, no_rebind);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001645 } else {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001646 r = remove_listener(local, transport);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001647 }
1648 if(r == 0) {
1649 /* 1st OKAY is connect, 2nd OKAY is status */
1650 writex(reply_fd, "OKAYOKAY", 8);
1651 return 0;
1652 }
1653
1654 if (createForward) {
David 'Digit' Turner0d82fbf2012-11-14 15:01:55 +01001655 const char* message;
1656 switch (r) {
1657 case INSTALL_STATUS_CANNOT_BIND:
1658 message = "cannot bind to socket";
1659 break;
1660 case INSTALL_STATUS_CANNOT_REBIND:
1661 message = "cannot rebind existing socket";
1662 break;
1663 default:
1664 message = "internal error";
1665 }
1666 sendfailmsg(reply_fd, message);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001667 } else {
1668 sendfailmsg(reply_fd, "cannot remove listener");
1669 }
1670 return 0;
1671 }
1672
1673 if(!strncmp(service,"get-state",strlen("get-state"))) {
1674 transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1675 char *state = connection_state_name(transport);
1676 snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(state),state);
1677 writex(reply_fd, buf, strlen(buf));
1678 return 0;
1679 }
1680 return -1;
1681}
1682
1683#if !ADB_HOST
1684int recovery_mode = 0;
1685#endif
1686
1687int main(int argc, char **argv)
1688{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001689#if ADB_HOST
1690 adb_sysdeps_init();
JP Abgrall408fa572011-03-16 15:57:42 -07001691 adb_trace_init();
1692 D("Handling commandline()\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001693 return adb_commandline(argc - 1, argv + 1);
1694#else
Vladimir Chtchetkine28781b02012-02-27 10:41:53 -08001695 /* If adbd runs inside the emulator this will enable adb tracing via
1696 * adb-debug qemud service in the emulator. */
1697 adb_qemu_trace_init();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001698 if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
1699 adb_device_banner = "recovery";
1700 recovery_mode = 1;
1701 }
Mike Lockwood1f546e62009-05-25 18:17:55 -04001702
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001703 start_device_log();
JP Abgrall408fa572011-03-16 15:57:42 -07001704 D("Handling main()\n");
Stefan Hilzingera84a42e2010-04-19 12:21:12 +01001705 return adb_main(0, DEFAULT_ADB_PORT);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001706#endif
1707}