android-tools: add recipe
[openpandora.oe.git] / recipes / android-tools / android-tools / add_adbd.patch
1 ## Description: add some description
2 ## Origin/Author: add some origin or author
3 ## Bug: bug URL
4 Index: android-tools-4.2.2+git20130218/core/adbd/adb.c
5 ===================================================================
6 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7 +++ android-tools-4.2.2+git20130218/core/adbd/adb.c     2013-06-18 17:12:17.000000000 -0300
8 @@ -0,0 +1,1719 @@
9 +/*
10 + * Copyright (C) 2007 The Android Open Source Project
11 + *
12 + * Licensed under the Apache License, Version 2.0 (the "License");
13 + * you may not use this file except in compliance with the License.
14 + * You may obtain a copy of the License at
15 + *
16 + *      http://www.apache.org/licenses/LICENSE-2.0
17 + *
18 + * Unless required by applicable law or agreed to in writing, software
19 + * distributed under the License is distributed on an "AS IS" BASIS,
20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 + * See the License for the specific language governing permissions and
22 + * limitations under the License.
23 + */
24 +
25 +#define  TRACE_TAG   TRACE_ADB
26 +
27 +#include <stdio.h>
28 +#include <stdlib.h>
29 +#include <ctype.h>
30 +#include <stdarg.h>
31 +#include <errno.h>
32 +#include <stddef.h>
33 +#include <string.h>
34 +#include <time.h>
35 +#include <sys/time.h>
36 +#include <stdint.h>
37 +
38 +#include "sysdeps.h"
39 +#include "adb.h"
40 +#include "adb_auth.h"
41 +
42 +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
43 +
44 +#if !ADB_HOST
45 +#include "android_filesystem_config.h"
46 +#include <linux/capability.h>
47 +#include <linux/prctl.h>
48 +#include <sys/mount.h>
49 +#else
50 +#include "usb_vendors.h"
51 +#endif
52 +
53 +#if ADB_TRACE
54 +ADB_MUTEX_DEFINE( D_lock );
55 +#endif
56 +
57 +int HOST = 0;
58 +int gListenAll = 0;
59 +
60 +static int auth_enabled = 0;
61 +
62 +#if !ADB_HOST
63 +static const char *adb_device_banner = "device";
64 +#endif
65 +
66 +void fatal(const char *fmt, ...)
67 +{
68 +    va_list ap;
69 +    va_start(ap, fmt);
70 +    fprintf(stderr, "error: ");
71 +    vfprintf(stderr, fmt, ap);
72 +    fprintf(stderr, "\n");
73 +    va_end(ap);
74 +    exit(-1);
75 +}
76 +
77 +void fatal_errno(const char *fmt, ...)
78 +{
79 +    va_list ap;
80 +    va_start(ap, fmt);
81 +    fprintf(stderr, "error: %s: ", strerror(errno));
82 +    vfprintf(stderr, fmt, ap);
83 +    fprintf(stderr, "\n");
84 +    va_end(ap);
85 +    exit(-1);
86 +}
87 +
88 +int   adb_trace_mask;
89 +
90 +/* read a comma/space/colum/semi-column separated list of tags
91 + * from the ADB_TRACE environment variable and build the trace
92 + * mask from it. note that '1' and 'all' are special cases to
93 + * enable all tracing
94 + */
95 +void  adb_trace_init(void)
96 +{
97 +    const char*  p = getenv("ADB_TRACE");
98 +    const char*  q;
99 +
100 +    static const struct {
101 +        const char*  tag;
102 +        int           flag;
103 +    } tags[] = {
104 +        { "1", 0 },
105 +        { "all", 0 },
106 +        { "adb", TRACE_ADB },
107 +        { "sockets", TRACE_SOCKETS },
108 +        { "packets", TRACE_PACKETS },
109 +        { "rwx", TRACE_RWX },
110 +        { "usb", TRACE_USB },
111 +        { "sync", TRACE_SYNC },
112 +        { "sysdeps", TRACE_SYSDEPS },
113 +        { "transport", TRACE_TRANSPORT },
114 +        { "jdwp", TRACE_JDWP },
115 +        { "services", TRACE_SERVICES },
116 +        { "auth", TRACE_AUTH },
117 +        { NULL, 0 }
118 +    };
119 +
120 +    if (p == NULL)
121 +            return;
122 +
123 +    /* use a comma/column/semi-colum/space separated list */
124 +    while (*p) {
125 +        int  len, tagn;
126 +
127 +        q = strpbrk(p, " ,:;");
128 +        if (q == NULL) {
129 +            q = p + strlen(p);
130 +        }
131 +        len = q - p;
132 +
133 +        for (tagn = 0; tags[tagn].tag != NULL; tagn++)
134 +        {
135 +            int  taglen = strlen(tags[tagn].tag);
136 +
137 +            if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
138 +            {
139 +                int  flag = tags[tagn].flag;
140 +                if (flag == 0) {
141 +                    adb_trace_mask = ~0;
142 +                    return;
143 +                }
144 +                adb_trace_mask |= (1 << flag);
145 +                break;
146 +            }
147 +        }
148 +        p = q;
149 +        if (*p)
150 +            p++;
151 +    }
152 +}
153 +
154 +#if !ADB_HOST
155 +/*
156 + * Implements ADB tracing inside the emulator.
157 + */
158 +
159 +#include <stdarg.h>
160 +
161 +/*
162 + * Redefine open and write for qemu_pipe.h that contains inlined references
163 + * to those routines. We will redifine them back after qemu_pipe.h inclusion.
164 + */
165 +
166 +#undef open
167 +#undef write
168 +#define open    adb_open
169 +#define write   adb_write
170 +#include "qemu_pipe.h"
171 +#undef open
172 +#undef write
173 +#define open    ___xxx_open
174 +#define write   ___xxx_write
175 +
176 +/* A handle to adb-debug qemud service in the emulator. */
177 +int   adb_debug_qemu = -1;
178 +
179 +/* Initializes connection with the adb-debug qemud service in the emulator. */
180 +static int adb_qemu_trace_init(void)
181 +{
182 +    char con_name[32];
183 +
184 +    if (adb_debug_qemu >= 0) {
185 +        return 0;
186 +    }
187 +
188 +    /* adb debugging QEMUD service connection request. */
189 +    snprintf(con_name, sizeof(con_name), "qemud:adb-debug");
190 +    adb_debug_qemu = qemu_pipe_open(con_name);
191 +    return (adb_debug_qemu >= 0) ? 0 : -1;
192 +}
193 +
194 +void adb_qemu_trace(const char* fmt, ...)
195 +{
196 +    va_list args;
197 +    va_start(args, fmt);
198 +    char msg[1024];
199 +
200 +    if (adb_debug_qemu >= 0) {
201 +        vsnprintf(msg, sizeof(msg), fmt, args);
202 +        adb_write(adb_debug_qemu, msg, strlen(msg));
203 +    }
204 +}
205 +#endif  /* !ADB_HOST */
206 +
207 +apacket *get_apacket(void)
208 +{
209 +    apacket *p = malloc(sizeof(apacket));
210 +    if(p == 0) fatal("failed to allocate an apacket");
211 +    memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
212 +    return p;
213 +}
214 +
215 +void put_apacket(apacket *p)
216 +{
217 +    free(p);
218 +}
219 +
220 +void handle_online(atransport *t)
221 +{
222 +    D("adb: online\n");
223 +    t->online = 1;
224 +}
225 +
226 +void handle_offline(atransport *t)
227 +{
228 +    D("adb: offline\n");
229 +    //Close the associated usb
230 +    t->online = 0;
231 +    run_transport_disconnects(t);
232 +}
233 +
234 +#if DEBUG_PACKETS
235 +#define DUMPMAX 32
236 +void print_packet(const char *label, apacket *p)
237 +{
238 +    char *tag;
239 +    char *x;
240 +    unsigned count;
241 +
242 +    switch(p->msg.command){
243 +    case A_SYNC: tag = "SYNC"; break;
244 +    case A_CNXN: tag = "CNXN" ; break;
245 +    case A_OPEN: tag = "OPEN"; break;
246 +    case A_OKAY: tag = "OKAY"; break;
247 +    case A_CLSE: tag = "CLSE"; break;
248 +    case A_WRTE: tag = "WRTE"; break;
249 +    case A_AUTH: tag = "AUTH"; break;
250 +    default: tag = "????"; break;
251 +    }
252 +
253 +    fprintf(stderr, "%s: %s %08x %08x %04x \"",
254 +            label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
255 +    count = p->msg.data_length;
256 +    x = (char*) p->data;
257 +    if(count > DUMPMAX) {
258 +        count = DUMPMAX;
259 +        tag = "\n";
260 +    } else {
261 +        tag = "\"\n";
262 +    }
263 +    while(count-- > 0){
264 +        if((*x >= ' ') && (*x < 127)) {
265 +            fputc(*x, stderr);
266 +        } else {
267 +            fputc('.', stderr);
268 +        }
269 +        x++;
270 +    }
271 +    fputs(tag, stderr);
272 +}
273 +#endif
274 +
275 +static void send_ready(unsigned local, unsigned remote, atransport *t)
276 +{
277 +    D("Calling send_ready \n");
278 +    apacket *p = get_apacket();
279 +    p->msg.command = A_OKAY;
280 +    p->msg.arg0 = local;
281 +    p->msg.arg1 = remote;
282 +    send_packet(p, t);
283 +}
284 +
285 +static void send_close(unsigned local, unsigned remote, atransport *t)
286 +{
287 +    D("Calling send_close \n");
288 +    apacket *p = get_apacket();
289 +    p->msg.command = A_CLSE;
290 +    p->msg.arg0 = local;
291 +    p->msg.arg1 = remote;
292 +    send_packet(p, t);
293 +}
294 +
295 +static size_t fill_connect_data(char *buf, size_t bufsize)
296 +{
297 +#if ADB_HOST
298 +    return snprintf(buf, bufsize, "host::") + 1;
299 +#else
300 +    static const char *cnxn_props[] = {
301 +        "ro.product.name",
302 +        "ro.product.model",
303 +        "ro.product.device",
304 +    };
305 +    static const int num_cnxn_props = ARRAY_SIZE(cnxn_props);
306 +    static const char *values[] = {
307 +        "occam",
308 +        "Nexus 4",
309 +        "mako",
310 +    };
311 +    int i;
312 +    size_t remaining = bufsize;
313 +    size_t len;
314 +
315 +    len = snprintf(buf, remaining, "%s::", adb_device_banner);
316 +    remaining -= len;
317 +    buf += len;
318 +    for (i = 0; i < num_cnxn_props; i++) {
319 +        char value[PROPERTY_VALUE_MAX];
320 +        //property_get(cnxn_props[i], value, "");
321 +        len = snprintf(buf, remaining, "%s=%s;", cnxn_props[i], values[i]);
322 +        remaining -= len;
323 +        buf += len;
324 +    }
325 +
326 +    return bufsize - remaining + 1;
327 +#endif
328 +}
329 +
330 +static void send_connect(atransport *t)
331 +{
332 +    D("Calling send_connect \n");
333 +    apacket *cp = get_apacket();
334 +    cp->msg.command = A_CNXN;
335 +    cp->msg.arg0 = A_VERSION;
336 +    cp->msg.arg1 = MAX_PAYLOAD;
337 +    cp->msg.data_length = fill_connect_data((char *)cp->data,
338 +                                            sizeof(cp->data));
339 +    send_packet(cp, t);
340 +}
341 +
342 +static void send_auth_request(atransport *t)
343 +{
344 +    D("Calling send_auth_request\n");
345 +    apacket *p;
346 +    int ret;
347 +
348 +    ret = adb_auth_generate_token(t->token, sizeof(t->token));
349 +    if (ret != sizeof(t->token)) {
350 +        D("Error generating token ret=%d\n", ret);
351 +        return;
352 +    }
353 +
354 +    p = get_apacket();
355 +    memcpy(p->data, t->token, ret);
356 +    p->msg.command = A_AUTH;
357 +    p->msg.arg0 = ADB_AUTH_TOKEN;
358 +    p->msg.data_length = ret;
359 +    send_packet(p, t);
360 +}
361 +
362 +static void send_auth_response(uint8_t *token, size_t token_size, atransport *t)
363 +{
364 +    D("Calling send_auth_response\n");
365 +    apacket *p = get_apacket();
366 +    int ret;
367 +
368 +    ret = adb_auth_sign(t->key, token, token_size, p->data);
369 +    if (!ret) {
370 +        D("Error signing the token\n");
371 +        put_apacket(p);
372 +        return;
373 +    }
374 +
375 +    p->msg.command = A_AUTH;
376 +    p->msg.arg0 = ADB_AUTH_SIGNATURE;
377 +    p->msg.data_length = ret;
378 +    send_packet(p, t);
379 +}
380 +
381 +static void send_auth_publickey(atransport *t)
382 +{
383 +    D("Calling send_auth_publickey\n");
384 +    apacket *p = get_apacket();
385 +    int ret;
386 +
387 +    ret = adb_auth_get_userkey(p->data, sizeof(p->data));
388 +    if (!ret) {
389 +        D("Failed to get user public key\n");
390 +        put_apacket(p);
391 +        return;
392 +    }
393 +
394 +    p->msg.command = A_AUTH;
395 +    p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;
396 +    p->msg.data_length = ret;
397 +    send_packet(p, t);
398 +}
399 +
400 +void adb_auth_verified(atransport *t)
401 +{
402 +    handle_online(t);
403 +    send_connect(t);
404 +}
405 +
406 +static char *connection_state_name(atransport *t)
407 +{
408 +    if (t == NULL) {
409 +        return "unknown";
410 +    }
411 +
412 +    switch(t->connection_state) {
413 +    case CS_BOOTLOADER:
414 +        return "bootloader";
415 +    case CS_DEVICE:
416 +        return "device";
417 +    case CS_OFFLINE:
418 +        return "offline";
419 +    default:
420 +        return "unknown";
421 +    }
422 +}
423 +
424 +/* qual_overwrite is used to overwrite a qualifier string.  dst is a
425 + * pointer to a char pointer.  It is assumed that if *dst is non-NULL, it
426 + * was malloc'ed and needs to freed.  *dst will be set to a dup of src.
427 + */
428 +static void qual_overwrite(char **dst, const char *src)
429 +{
430 +    if (!dst)
431 +        return;
432 +
433 +    free(*dst);
434 +    *dst = NULL;
435 +
436 +    if (!src || !*src)
437 +        return;
438 +
439 +    *dst = strdup(src);
440 +}
441 +
442 +void parse_banner(char *banner, atransport *t)
443 +{
444 +    static const char *prop_seps = ";";
445 +    static const char key_val_sep = '=';
446 +    char *cp;
447 +    char *type;
448 +
449 +    D("parse_banner: %s\n", banner);
450 +    type = banner;
451 +    cp = strchr(type, ':');
452 +    if (cp) {
453 +        *cp++ = 0;
454 +        /* Nothing is done with second field. */
455 +        cp = strchr(cp, ':');
456 +        if (cp) {
457 +            char *save;
458 +            char *key;
459 +            key = adb_strtok_r(cp + 1, prop_seps, &save);
460 +            while (key) {
461 +                cp = strchr(key, key_val_sep);
462 +                if (cp) {
463 +                    *cp++ = '\0';
464 +                    if (!strcmp(key, "ro.product.name"))
465 +                        qual_overwrite(&t->product, cp);
466 +                    else if (!strcmp(key, "ro.product.model"))
467 +                        qual_overwrite(&t->model, cp);
468 +                    else if (!strcmp(key, "ro.product.device"))
469 +                        qual_overwrite(&t->device, cp);
470 +                }
471 +                key = adb_strtok_r(NULL, prop_seps, &save);
472 +            }
473 +        }
474 +    }
475 +
476 +    if(!strcmp(type, "bootloader")){
477 +        D("setting connection_state to CS_BOOTLOADER\n");
478 +        t->connection_state = CS_BOOTLOADER;
479 +        update_transports();
480 +        return;
481 +    }
482 +
483 +    if(!strcmp(type, "device")) {
484 +        D("setting connection_state to CS_DEVICE\n");
485 +        t->connection_state = CS_DEVICE;
486 +        update_transports();
487 +        return;
488 +    }
489 +
490 +    if(!strcmp(type, "recovery")) {
491 +        D("setting connection_state to CS_RECOVERY\n");
492 +        t->connection_state = CS_RECOVERY;
493 +        update_transports();
494 +        return;
495 +    }
496 +
497 +    if(!strcmp(type, "sideload")) {
498 +        D("setting connection_state to CS_SIDELOAD\n");
499 +        t->connection_state = CS_SIDELOAD;
500 +        update_transports();
501 +        return;
502 +    }
503 +
504 +    t->connection_state = CS_HOST;
505 +}
506 +
507 +void handle_packet(apacket *p, atransport *t)
508 +{
509 +    asocket *s;
510 +
511 +    D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],
512 +            ((char*) (&(p->msg.command)))[1],
513 +            ((char*) (&(p->msg.command)))[2],
514 +            ((char*) (&(p->msg.command)))[3]);
515 +    print_packet("recv", p);
516 +
517 +    switch(p->msg.command){
518 +    case A_SYNC:
519 +        if(p->msg.arg0){
520 +            send_packet(p, t);
521 +            if(HOST) send_connect(t);
522 +        } else {
523 +            t->connection_state = CS_OFFLINE;
524 +            handle_offline(t);
525 +            send_packet(p, t);
526 +        }
527 +        return;
528 +
529 +    case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
530 +            /* XXX verify version, etc */
531 +        if(t->connection_state != CS_OFFLINE) {
532 +            t->connection_state = CS_OFFLINE;
533 +            handle_offline(t);
534 +        }
535 +
536 +        parse_banner((char*) p->data, t);
537 +
538 +        if (HOST || !auth_enabled) {
539 +            handle_online(t);
540 +            if(!HOST) send_connect(t);
541 +        } else {
542 +            send_auth_request(t);
543 +        }
544 +        break;
545 +
546 +    case A_AUTH:
547 +        if (p->msg.arg0 == ADB_AUTH_TOKEN) {
548 +            t->key = adb_auth_nextkey(t->key);
549 +            if (t->key) {
550 +                send_auth_response(p->data, p->msg.data_length, t);
551 +            } else {
552 +                /* No more private keys to try, send the public key */
553 +                send_auth_publickey(t);
554 +            }
555 +        } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
556 +            if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {
557 +                adb_auth_verified(t);
558 +                t->failed_auth_attempts = 0;
559 +            } else {
560 +                if (t->failed_auth_attempts++ > 10)
561 +                    adb_sleep_ms(1000);
562 +                send_auth_request(t);
563 +            }
564 +        } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
565 +            adb_auth_confirm_key(p->data, p->msg.data_length, t);
566 +        }
567 +        break;
568 +
569 +    case A_OPEN: /* OPEN(local-id, 0, "destination") */
570 +        if (t->online) {
571 +            char *name = (char*) p->data;
572 +            name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
573 +            s = create_local_service_socket(name);
574 +            if(s == 0) {
575 +                send_close(0, p->msg.arg0, t);
576 +            } else {
577 +                s->peer = create_remote_socket(p->msg.arg0, t);
578 +                s->peer->peer = s;
579 +                send_ready(s->id, s->peer->id, t);
580 +                s->ready(s);
581 +            }
582 +        }
583 +        break;
584 +
585 +    case A_OKAY: /* READY(local-id, remote-id, "") */
586 +        if (t->online) {
587 +            if((s = find_local_socket(p->msg.arg1))) {
588 +                if(s->peer == 0) {
589 +                    s->peer = create_remote_socket(p->msg.arg0, t);
590 +                    s->peer->peer = s;
591 +                }
592 +                s->ready(s);
593 +            }
594 +        }
595 +        break;
596 +
597 +    case A_CLSE: /* CLOSE(local-id, remote-id, "") */
598 +        if (t->online) {
599 +            if((s = find_local_socket(p->msg.arg1))) {
600 +                s->close(s);
601 +            }
602 +        }
603 +        break;
604 +
605 +    case A_WRTE:
606 +        if (t->online) {
607 +            if((s = find_local_socket(p->msg.arg1))) {
608 +                unsigned rid = p->msg.arg0;
609 +                p->len = p->msg.data_length;
610 +
611 +                if(s->enqueue(s, p) == 0) {
612 +                    D("Enqueue the socket\n");
613 +                    send_ready(s->id, rid, t);
614 +                }
615 +                return;
616 +            }
617 +        }
618 +        break;
619 +
620 +    default:
621 +        printf("handle_packet: what is %08x?!\n", p->msg.command);
622 +    }
623 +
624 +    put_apacket(p);
625 +}
626 +
627 +alistener listener_list = {
628 +    .next = &listener_list,
629 +    .prev = &listener_list,
630 +};
631 +
632 +static void ss_listener_event_func(int _fd, unsigned ev, void *_l)
633 +{
634 +    asocket *s;
635 +
636 +    if(ev & FDE_READ) {
637 +        struct sockaddr addr;
638 +        socklen_t alen;
639 +        int fd;
640 +
641 +        alen = sizeof(addr);
642 +        fd = adb_socket_accept(_fd, &addr, &alen);
643 +        if(fd < 0) return;
644 +
645 +        adb_socket_setbufsize(fd, CHUNK_SIZE);
646 +
647 +        s = create_local_socket(fd);
648 +        if(s) {
649 +            connect_to_smartsocket(s);
650 +            return;
651 +        }
652 +
653 +        adb_close(fd);
654 +    }
655 +}
656 +
657 +static void listener_event_func(int _fd, unsigned ev, void *_l)
658 +{
659 +    alistener *l = _l;
660 +    asocket *s;
661 +
662 +    if(ev & FDE_READ) {
663 +        struct sockaddr addr;
664 +        socklen_t alen;
665 +        int fd;
666 +
667 +        alen = sizeof(addr);
668 +        fd = adb_socket_accept(_fd, &addr, &alen);
669 +        if(fd < 0) return;
670 +
671 +        s = create_local_socket(fd);
672 +        if(s) {
673 +            s->transport = l->transport;
674 +            connect_to_remote(s, l->connect_to);
675 +            return;
676 +        }
677 +
678 +        adb_close(fd);
679 +    }
680 +}
681 +
682 +static void  free_listener(alistener*  l)
683 +{
684 +    if (l->next) {
685 +        l->next->prev = l->prev;
686 +        l->prev->next = l->next;
687 +        l->next = l->prev = l;
688 +    }
689 +
690 +    // closes the corresponding fd
691 +    fdevent_remove(&l->fde);
692 +
693 +    if (l->local_name)
694 +        free((char*)l->local_name);
695 +
696 +    if (l->connect_to)
697 +        free((char*)l->connect_to);
698 +
699 +    if (l->transport) {
700 +        remove_transport_disconnect(l->transport, &l->disconnect);
701 +    }
702 +    free(l);
703 +}
704 +
705 +static void listener_disconnect(void*  _l, atransport*  t)
706 +{
707 +    alistener*  l = _l;
708 +
709 +    free_listener(l);
710 +}
711 +
712 +int local_name_to_fd(const char *name)
713 +{
714 +    int port;
715 +
716 +    if(!strncmp("tcp:", name, 4)){
717 +        int  ret;
718 +        port = atoi(name + 4);
719 +
720 +        if (gListenAll > 0) {
721 +            ret = socket_inaddr_any_server(port, SOCK_STREAM);
722 +        } else {
723 +            ret = socket_loopback_server(port, SOCK_STREAM);
724 +        }
725 +
726 +        return ret;
727 +    }
728 +#ifndef HAVE_WIN32_IPC  /* no Unix-domain sockets on Win32 */
729 +    // It's non-sensical to support the "reserved" space on the adb host side
730 +    if(!strncmp(name, "local:", 6)) {
731 +        return socket_local_server(name + 6,
732 +                ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
733 +    } else if(!strncmp(name, "localabstract:", 14)) {
734 +        return socket_local_server(name + 14,
735 +                ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
736 +    } else if(!strncmp(name, "localfilesystem:", 16)) {
737 +        return socket_local_server(name + 16,
738 +                ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
739 +    }
740 +
741 +#endif
742 +    printf("unknown local portname '%s'\n", name);
743 +    return -1;
744 +}
745 +
746 +// Write a single line describing a listener to a user-provided buffer.
747 +// Appends a trailing zero, even in case of truncation, but the function
748 +// returns the full line length.
749 +// If |buffer| is NULL, does not write but returns required size.
750 +static int format_listener(alistener* l, char* buffer, size_t buffer_len) {
751 +    // Format is simply:
752 +    //
753 +    //  <device-serial> " " <local-name> " " <remote-name> "\n"
754 +    //
755 +    int local_len = strlen(l->local_name);
756 +    int connect_len = strlen(l->connect_to);
757 +    int serial_len = strlen(l->transport->serial);
758 +
759 +    if (buffer != NULL) {
760 +        snprintf(buffer, buffer_len, "%s %s %s\n",
761 +                l->transport->serial, l->local_name, l->connect_to);
762 +    }
763 +    // NOTE: snprintf() on Windows returns -1 in case of truncation, so
764 +    // return the computed line length instead.
765 +    return local_len + connect_len + serial_len + 3;
766 +}
767 +
768 +// Write the list of current listeners (network redirections) into a
769 +// user-provided buffer. Appends a trailing zero, even in case of
770 +// trunctaion, but return the full size in bytes.
771 +// If |buffer| is NULL, does not write but returns required size.
772 +static int format_listeners(char* buf, size_t buflen)
773 +{
774 +    alistener* l;
775 +    int result = 0;
776 +    for (l = listener_list.next; l != &listener_list; l = l->next) {
777 +        // Ignore special listeners like those for *smartsocket*
778 +        if (l->connect_to[0] == '*')
779 +          continue;
780 +        int len = format_listener(l, buf, buflen);
781 +        // Ensure there is space for the trailing zero.
782 +        result += len;
783 +        if (buf != NULL) {
784 +          buf += len;
785 +          buflen -= len;
786 +          if (buflen <= 0)
787 +              break;
788 +        }
789 +    }
790 +    return result;
791 +}
792 +
793 +static int remove_listener(const char *local_name, atransport* transport)
794 +{
795 +    alistener *l;
796 +
797 +    for (l = listener_list.next; l != &listener_list; l = l->next) {
798 +        if (!strcmp(local_name, l->local_name)) {
799 +            listener_disconnect(l, l->transport);
800 +            return 0;
801 +        }
802 +    }
803 +    return -1;
804 +}
805 +
806 +static void remove_all_listeners(void)
807 +{
808 +    alistener *l, *l_next;
809 +    for (l = listener_list.next; l != &listener_list; l = l_next) {
810 +        l_next = l->next;
811 +        // Never remove smart sockets.
812 +        if (l->connect_to[0] == '*')
813 +            continue;
814 +        listener_disconnect(l, l->transport);
815 +    }
816 +}
817 +
818 +// error/status codes for install_listener.
819 +typedef enum {
820 +  INSTALL_STATUS_OK = 0,
821 +  INSTALL_STATUS_INTERNAL_ERROR = -1,
822 +  INSTALL_STATUS_CANNOT_BIND = -2,
823 +  INSTALL_STATUS_CANNOT_REBIND = -3,
824 +} install_status_t;
825 +
826 +static install_status_t install_listener(const char *local_name,
827 +                                         const char *connect_to,
828 +                                         atransport* transport,
829 +                                         int no_rebind)
830 +{
831 +    alistener *l;
832 +
833 +    printf("install_listener('%s','%s')\n", local_name, connect_to);
834 +
835 +    for(l = listener_list.next; l != &listener_list; l = l->next){
836 +        if(strcmp(local_name, l->local_name) == 0) {
837 +            char *cto;
838 +
839 +                /* can't repurpose a smartsocket */
840 +            if(l->connect_to[0] == '*') {
841 +                return INSTALL_STATUS_INTERNAL_ERROR;
842 +            }
843 +
844 +                /* can't repurpose a listener if 'no_rebind' is true */
845 +            if (no_rebind) {
846 +                return INSTALL_STATUS_CANNOT_REBIND;
847 +            }
848 +
849 +            cto = strdup(connect_to);
850 +            if(cto == 0) {
851 +                return INSTALL_STATUS_INTERNAL_ERROR;
852 +            }
853 +
854 +            //printf("rebinding '%s' to '%s'\n", local_name, connect_to);
855 +            free((void*) l->connect_to);
856 +            l->connect_to = cto;
857 +            if (l->transport != transport) {
858 +                remove_transport_disconnect(l->transport, &l->disconnect);
859 +                l->transport = transport;
860 +                add_transport_disconnect(l->transport, &l->disconnect);
861 +            }
862 +            return INSTALL_STATUS_OK;
863 +        }
864 +    }
865 +
866 +    if((l = calloc(1, sizeof(alistener))) == 0) goto nomem;
867 +    if((l->local_name = strdup(local_name)) == 0) goto nomem;
868 +    if((l->connect_to = strdup(connect_to)) == 0) goto nomem;
869 +
870 +
871 +    l->fd = local_name_to_fd(local_name);
872 +    if(l->fd < 0) {
873 +        free((void*) l->local_name);
874 +        free((void*) l->connect_to);
875 +        free(l);
876 +        printf("cannot bind '%s'\n", local_name);
877 +        return -2;
878 +    }
879 +
880 +    close_on_exec(l->fd);
881 +    if(!strcmp(l->connect_to, "*smartsocket*")) {
882 +        fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);
883 +    } else {
884 +        fdevent_install(&l->fde, l->fd, listener_event_func, l);
885 +    }
886 +    fdevent_set(&l->fde, FDE_READ);
887 +
888 +    l->next = &listener_list;
889 +    l->prev = listener_list.prev;
890 +    l->next->prev = l;
891 +    l->prev->next = l;
892 +    l->transport = transport;
893 +
894 +    if (transport) {
895 +        l->disconnect.opaque = l;
896 +        l->disconnect.func   = listener_disconnect;
897 +        add_transport_disconnect(transport, &l->disconnect);
898 +    }
899 +    return INSTALL_STATUS_OK;
900 +
901 +nomem:
902 +    fatal("cannot allocate listener");
903 +    return INSTALL_STATUS_INTERNAL_ERROR;
904 +}
905 +
906 +#ifdef HAVE_WIN32_PROC
907 +static BOOL WINAPI ctrlc_handler(DWORD type)
908 +{
909 +    exit(STATUS_CONTROL_C_EXIT);
910 +    return TRUE;
911 +}
912 +#endif
913 +
914 +static void adb_cleanup(void)
915 +{
916 +    usb_cleanup();
917 +}
918 +
919 +void start_logging(void)
920 +{
921 +#ifdef HAVE_WIN32_PROC
922 +    char    temp[ MAX_PATH ];
923 +    FILE*   fnul;
924 +    FILE*   flog;
925 +
926 +    GetTempPath( sizeof(temp) - 8, temp );
927 +    strcat( temp, "adb.log" );
928 +
929 +    /* Win32 specific redirections */
930 +    fnul = fopen( "NUL", "rt" );
931 +    if (fnul != NULL)
932 +        stdin[0] = fnul[0];
933 +
934 +    flog = fopen( temp, "at" );
935 +    if (flog == NULL)
936 +        flog = fnul;
937 +
938 +    setvbuf( flog, NULL, _IONBF, 0 );
939 +
940 +    stdout[0] = flog[0];
941 +    stderr[0] = flog[0];
942 +    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
943 +#else
944 +    int fd;
945 +
946 +    fd = unix_open("/dev/null", O_RDONLY);
947 +    dup2(fd, 0);
948 +    adb_close(fd);
949 +
950 +    fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);
951 +    if(fd < 0) {
952 +        fd = unix_open("/dev/null", O_WRONLY);
953 +    }
954 +    dup2(fd, 1);
955 +    dup2(fd, 2);
956 +    adb_close(fd);
957 +    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
958 +#endif
959 +}
960 +
961 +#if !ADB_HOST
962 +void start_device_log(void)
963 +{
964 +    int fd;
965 +    char    path[PATH_MAX];
966 +    struct tm now;
967 +    time_t t;
968 +    char value[PROPERTY_VALUE_MAX];
969 +
970 +    // read the trace mask from persistent property persist.adb.trace_mask
971 +    // give up if the property is not set or cannot be parsed
972 +    //property_get("persist.adb.trace_mask", value, "");
973 +    //if (sscanf(value, "%x", &adb_trace_mask) != 1)
974 +    return;
975 +
976 +    adb_mkdir("/data/adb", 0775);
977 +    tzset();
978 +    time(&t);
979 +    localtime_r(&t, &now);
980 +    strftime(path, sizeof(path),
981 +                "/data/adb/adb-%Y-%m-%d-%H-%M-%S.txt",
982 +                &now);
983 +    fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640);
984 +    if (fd < 0)
985 +        return;
986 +
987 +    // redirect stdout and stderr to the log file
988 +    dup2(fd, 1);
989 +    dup2(fd, 2);
990 +    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
991 +    adb_close(fd);
992 +
993 +    fd = unix_open("/dev/null", O_RDONLY);
994 +    dup2(fd, 0);
995 +    adb_close(fd);
996 +}
997 +#endif
998 +
999 +#if ADB_HOST
1000 +int launch_server(int server_port)
1001 +{
1002 +#ifdef HAVE_WIN32_PROC
1003 +    /* we need to start the server in the background                    */
1004 +    /* we create a PIPE that will be used to wait for the server's "OK" */
1005 +    /* message since the pipe handles must be inheritable, we use a     */
1006 +    /* security attribute                                               */
1007 +    HANDLE                pipe_read, pipe_write;
1008 +    HANDLE                stdout_handle, stderr_handle;
1009 +    SECURITY_ATTRIBUTES   sa;
1010 +    STARTUPINFO           startup;
1011 +    PROCESS_INFORMATION   pinfo;
1012 +    char                  program_path[ MAX_PATH ];
1013 +    int                   ret;
1014 +
1015 +    sa.nLength = sizeof(sa);
1016 +    sa.lpSecurityDescriptor = NULL;
1017 +    sa.bInheritHandle = TRUE;
1018 +
1019 +    /* create pipe, and ensure its read handle isn't inheritable */
1020 +    ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 );
1021 +    if (!ret) {
1022 +        fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() );
1023 +        return -1;
1024 +    }
1025 +
1026 +    SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 );
1027 +
1028 +    /* Some programs want to launch an adb command and collect its output by
1029 +     * calling CreateProcess with inheritable stdout/stderr handles, then
1030 +     * using read() to get its output. When this happens, the stdout/stderr
1031 +     * handles passed to the adb client process will also be inheritable.
1032 +     * When starting the adb server here, care must be taken to reset them
1033 +     * to non-inheritable.
1034 +     * Otherwise, something bad happens: even if the adb command completes,
1035 +     * the calling process is stuck while read()-ing from the stdout/stderr
1036 +     * descriptors, because they're connected to corresponding handles in the
1037 +     * adb server process (even if the latter never uses/writes to them).
1038 +     */
1039 +    stdout_handle = GetStdHandle( STD_OUTPUT_HANDLE );
1040 +    stderr_handle = GetStdHandle( STD_ERROR_HANDLE );
1041 +    if (stdout_handle != INVALID_HANDLE_VALUE) {
1042 +        SetHandleInformation( stdout_handle, HANDLE_FLAG_INHERIT, 0 );
1043 +    }
1044 +    if (stderr_handle != INVALID_HANDLE_VALUE) {
1045 +        SetHandleInformation( stderr_handle, HANDLE_FLAG_INHERIT, 0 );
1046 +    }
1047 +
1048 +    ZeroMemory( &startup, sizeof(startup) );
1049 +    startup.cb = sizeof(startup);
1050 +    startup.hStdInput  = GetStdHandle( STD_INPUT_HANDLE );
1051 +    startup.hStdOutput = pipe_write;
1052 +    startup.hStdError  = GetStdHandle( STD_ERROR_HANDLE );
1053 +    startup.dwFlags    = STARTF_USESTDHANDLES;
1054 +
1055 +    ZeroMemory( &pinfo, sizeof(pinfo) );
1056 +
1057 +    /* get path of current program */
1058 +    GetModuleFileName( NULL, program_path, sizeof(program_path) );
1059 +
1060 +    ret = CreateProcess(
1061 +            program_path,                              /* program path  */
1062 +            "adb fork-server server",
1063 +                                    /* the fork-server argument will set the
1064 +                                       debug = 2 in the child           */
1065 +            NULL,                   /* process handle is not inheritable */
1066 +            NULL,                    /* thread handle is not inheritable */
1067 +            TRUE,                          /* yes, inherit some handles */
1068 +            DETACHED_PROCESS, /* the new process doesn't have a console */
1069 +            NULL,                     /* use parent's environment block */
1070 +            NULL,                    /* use parent's starting directory */
1071 +            &startup,                 /* startup info, i.e. std handles */
1072 +            &pinfo );
1073 +
1074 +    CloseHandle( pipe_write );
1075 +
1076 +    if (!ret) {
1077 +        fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() );
1078 +        CloseHandle( pipe_read );
1079 +        return -1;
1080 +    }
1081 +
1082 +    CloseHandle( pinfo.hProcess );
1083 +    CloseHandle( pinfo.hThread );
1084 +
1085 +    /* wait for the "OK\n" message */
1086 +    {
1087 +        char  temp[3];
1088 +        DWORD  count;
1089 +
1090 +        ret = ReadFile( pipe_read, temp, 3, &count, NULL );
1091 +        CloseHandle( pipe_read );
1092 +        if ( !ret ) {
1093 +            fprintf(stderr, "could not read ok from ADB Server, error = %ld\n", GetLastError() );
1094 +            return -1;
1095 +        }
1096 +        if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
1097 +            fprintf(stderr, "ADB server didn't ACK\n" );
1098 +            return -1;
1099 +        }
1100 +    }
1101 +#elif defined(HAVE_FORKEXEC)
1102 +    char    path[PATH_MAX];
1103 +    int     fd[2];
1104 +
1105 +    // set up a pipe so the child can tell us when it is ready.
1106 +    // fd[0] will be parent's end, and fd[1] will get mapped to stderr in the child.
1107 +    if (pipe(fd)) {
1108 +        fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
1109 +        return -1;
1110 +    }
1111 +    get_my_path(path, PATH_MAX);
1112 +    pid_t pid = fork();
1113 +    if(pid < 0) return -1;
1114 +
1115 +    if (pid == 0) {
1116 +        // child side of the fork
1117 +
1118 +        // redirect stderr to the pipe
1119 +        // we use stderr instead of stdout due to stdout's buffering behavior.
1120 +        adb_close(fd[0]);
1121 +        dup2(fd[1], STDERR_FILENO);
1122 +        adb_close(fd[1]);
1123 +
1124 +        char str_port[30];
1125 +        snprintf(str_port, sizeof(str_port), "%d",  server_port);
1126 +        // child process
1127 +        int result = execl(path, "adb", "-P", str_port, "fork-server", "server", NULL);
1128 +        // this should not return
1129 +        fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
1130 +    } else  {
1131 +        // parent side of the fork
1132 +
1133 +        char  temp[3];
1134 +
1135 +        temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
1136 +        // wait for the "OK\n" message
1137 +        adb_close(fd[1]);
1138 +        int ret = adb_read(fd[0], temp, 3);
1139 +        int saved_errno = errno;
1140 +        adb_close(fd[0]);
1141 +        if (ret < 0) {
1142 +            fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
1143 +            return -1;
1144 +        }
1145 +        if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
1146 +            fprintf(stderr, "ADB server didn't ACK\n" );
1147 +            return -1;
1148 +        }
1149 +
1150 +        setsid();
1151 +    }
1152 +#else
1153 +#error "cannot implement background server start on this platform"
1154 +#endif
1155 +    return 0;
1156 +}
1157 +#endif
1158 +
1159 +/* Constructs a local name of form tcp:port.
1160 + * target_str points to the target string, it's content will be overwritten.
1161 + * target_size is the capacity of the target string.
1162 + * server_port is the port number to use for the local name.
1163 + */
1164 +void build_local_name(char* target_str, size_t target_size, int server_port)
1165 +{
1166 +  snprintf(target_str, target_size, "tcp:%d", server_port);
1167 +}
1168 +
1169 +#if !ADB_HOST
1170 +static int should_drop_privileges() {
1171 +#ifndef ALLOW_ADBD_ROOT
1172 +    return 1;
1173 +#else /* ALLOW_ADBD_ROOT */
1174 +    int secure = 0;
1175 +    char value[PROPERTY_VALUE_MAX];
1176 +
1177 +    return 0;
1178 +   /* run adbd in secure mode if ro.secure is set and
1179 +    ** we are not in the emulator
1180 +    */
1181 +//    property_get("ro.kernel.qemu", value, "");
1182 +    if (strcmp(value, "1") != 0) {
1183 +//        property_get("ro.secure", value, "1");
1184 +        if (strcmp(value, "1") == 0) {
1185 +            // don't run as root if ro.secure is set...
1186 +            secure = 1;
1187 +
1188 +            // ... except we allow running as root in userdebug builds if the
1189 +            // service.adb.root property has been set by the "adb root" command
1190 +//            property_get("ro.debuggable", value, "");
1191 +            if (strcmp(value, "1") == 0) {
1192 +//                property_get("service.adb.root", value, "");
1193 +                if (strcmp(value, "1") == 0) {
1194 +                    secure = 0;
1195 +                }
1196 +            }
1197 +        }
1198 +    }
1199 +    return secure;
1200 +#endif /* ALLOW_ADBD_ROOT */
1201 +}
1202 +#endif /* !ADB_HOST */
1203 +
1204 +int adb_main(int is_daemon, int server_port)
1205 +{
1206 +#if !ADB_HOST
1207 +    int port;
1208 +    char value[PROPERTY_VALUE_MAX];
1209 +
1210 +    umask(000);
1211 +#endif
1212 +
1213 +    atexit(adb_cleanup);
1214 +#ifdef HAVE_WIN32_PROC
1215 +    SetConsoleCtrlHandler( ctrlc_handler, TRUE );
1216 +#elif defined(HAVE_FORKEXEC)
1217 +    // No SIGCHLD. Let the service subproc handle its children.
1218 +    signal(SIGPIPE, SIG_IGN);
1219 +#endif
1220 +
1221 +    init_transport_registration();
1222 +
1223 +#if ADB_HOST
1224 +    HOST = 1;
1225 +    usb_vendors_init();
1226 +    usb_init();
1227 +    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
1228 +    adb_auth_init();
1229 +
1230 +    char local_name[30];
1231 +    build_local_name(local_name, sizeof(local_name), server_port);
1232 +    if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
1233 +        exit(1);
1234 +    }
1235 +#else
1236 +    //property_get("ro.adb.secure", value, "0");
1237 +    auth_enabled = 0;//!strcmp(value, "1");
1238 +    if (auth_enabled)
1239 +        adb_auth_init();
1240 +
1241 +    // Our external storage path may be different than apps, since
1242 +    // we aren't able to bind mount after dropping root.
1243 +    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
1244 +    if (NULL != adb_external_storage) {
1245 +        setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
1246 +    } else {
1247 +        D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"
1248 +          " unchanged.\n");
1249 +    }
1250 +
1251 +    /* don't listen on a port (default 5037) if running in secure mode */
1252 +    /* don't run as root if we are running in secure mode */
1253 +    if (should_drop_privileges()) {
1254 +        struct __user_cap_header_struct header;
1255 +        struct __user_cap_data_struct cap[2];
1256 +
1257 +        if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {
1258 +            exit(1);
1259 +        }
1260 +
1261 +        /* add extra groups:
1262 +        ** AID_ADB to access the USB driver
1263 +        ** AID_LOG to read system logs (adb logcat)
1264 +        ** AID_INPUT to diagnose input issues (getevent)
1265 +        ** AID_INET to diagnose network issues (netcfg, ping)
1266 +        ** AID_GRAPHICS to access the frame buffer
1267 +        ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
1268 +        ** AID_SDCARD_R to allow reading from the SD card
1269 +        ** AID_SDCARD_RW to allow writing to the SD card
1270 +        ** AID_MOUNT to allow unmounting the SD card before rebooting
1271 +        ** AID_NET_BW_STATS to read out qtaguid statistics
1272 +        */
1273 +        gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
1274 +                           AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,
1275 +                           AID_MOUNT, AID_NET_BW_STATS };
1276 +        if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
1277 +            exit(1);
1278 +        }
1279 +
1280 +        /* then switch user and group to "shell" */
1281 +        if (setgid(AID_SHELL) != 0) {
1282 +            exit(1);
1283 +        }
1284 +        if (setuid(AID_SHELL) != 0) {
1285 +            exit(1);
1286 +        }
1287 +
1288 +        memset(&header, 0, sizeof(header));
1289 +        memset(cap, 0, sizeof(cap));
1290 +
1291 +        /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
1292 +        header.version = _LINUX_CAPABILITY_VERSION_3;
1293 +        header.pid = 0;
1294 +        cap[CAP_TO_INDEX(CAP_SYS_BOOT)].effective |= CAP_TO_MASK(CAP_SYS_BOOT);
1295 +        cap[CAP_TO_INDEX(CAP_SYS_BOOT)].permitted |= CAP_TO_MASK(CAP_SYS_BOOT);
1296 +        capset(&header, cap);
1297 +
1298 +        D("Local port disabled\n");
1299 +    } else {
1300 +        char local_name[30];
1301 +        build_local_name(local_name, sizeof(local_name), server_port);
1302 +        if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
1303 +            exit(1);
1304 +        }
1305 +    }
1306 +
1307 +    int usb = 0;
1308 +    if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
1309 +        // listen on USB
1310 +        usb_init();
1311 +        usb = 1;
1312 +    }
1313 +
1314 +    // If one of these properties is set, also listen on that port
1315 +    // If one of the properties isn't set and we couldn't listen on usb,
1316 +    // listen on the default port.
1317 +    //property_get("service.adb.tcp.port", value, "");
1318 +    //if (!value[0]) {
1319 +        //property_get("persist.adb.tcp.port", value, "");
1320 +    //}
1321 +    //if (sscanf(value, "%d", &port) == 1 && port > 0) {
1322 +    //    printf("using port=%d\n", port);
1323 +        // listen on TCP port specified by service.adb.tcp.port property
1324 +    //    local_init(port);
1325 +    //} else 
1326 +    if (!usb) {
1327 +        printf("Using USB\n");
1328 +        // listen on default port
1329 +        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
1330 +    }
1331 +
1332 +    D("adb_main(): pre init_jdwp()\n");
1333 +    init_jdwp();
1334 +    D("adb_main(): post init_jdwp()\n");
1335 +#endif
1336 +
1337 +    if (is_daemon)
1338 +    {
1339 +        // inform our parent that we are up and running.
1340 +#ifdef HAVE_WIN32_PROC
1341 +        DWORD  count;
1342 +        WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );
1343 +#elif defined(HAVE_FORKEXEC)
1344 +        fprintf(stderr, "OK\n");
1345 +#endif
1346 +        start_logging();
1347 +    }
1348 +    D("Event loop starting\n");
1349 +
1350 +    fdevent_loop();
1351 +
1352 +    usb_cleanup();
1353 +
1354 +    return 0;
1355 +}
1356 +
1357 +#if ADB_HOST
1358 +void connect_device(char* host, char* buffer, int buffer_size)
1359 +{
1360 +    int port, fd;
1361 +    char* portstr = strchr(host, ':');
1362 +    char hostbuf[100];
1363 +    char serial[100];
1364 +
1365 +    strncpy(hostbuf, host, sizeof(hostbuf) - 1);
1366 +    if (portstr) {
1367 +        if (portstr - host >= (ptrdiff_t)sizeof(hostbuf)) {
1368 +            snprintf(buffer, buffer_size, "bad host name %s", host);
1369 +            return;
1370 +        }
1371 +        // zero terminate the host at the point we found the colon
1372 +        hostbuf[portstr - host] = 0;
1373 +        if (sscanf(portstr + 1, "%d", &port) == 0) {
1374 +            snprintf(buffer, buffer_size, "bad port number %s", portstr);
1375 +            return;
1376 +        }
1377 +    } else {
1378 +        port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
1379 +    }
1380 +
1381 +    snprintf(serial, sizeof(serial), "%s:%d", hostbuf, port);
1382 +    if (find_transport(serial)) {
1383 +        snprintf(buffer, buffer_size, "already connected to %s", serial);
1384 +        return;
1385 +    }
1386 +
1387 +    fd = socket_network_client(hostbuf, port, SOCK_STREAM);
1388 +    if (fd < 0) {
1389 +        snprintf(buffer, buffer_size, "unable to connect to %s:%d", host, port);
1390 +        return;
1391 +    }
1392 +
1393 +    D("client: connected on remote on fd %d\n", fd);
1394 +    close_on_exec(fd);
1395 +    disable_tcp_nagle(fd);
1396 +    register_socket_transport(fd, serial, port, 0);
1397 +    snprintf(buffer, buffer_size, "connected to %s", serial);
1398 +}
1399 +
1400 +void connect_emulator(char* port_spec, char* buffer, int buffer_size)
1401 +{
1402 +    char* port_separator = strchr(port_spec, ',');
1403 +    if (!port_separator) {
1404 +        snprintf(buffer, buffer_size,
1405 +                "unable to parse '%s' as <console port>,<adb port>",
1406 +                port_spec);
1407 +        return;
1408 +    }
1409 +
1410 +    // Zero-terminate console port and make port_separator point to 2nd port.
1411 +    *port_separator++ = 0;
1412 +    int console_port = strtol(port_spec, NULL, 0);
1413 +    int adb_port = strtol(port_separator, NULL, 0);
1414 +    if (!(console_port > 0 && adb_port > 0)) {
1415 +        *(port_separator - 1) = ',';
1416 +        snprintf(buffer, buffer_size,
1417 +                "Invalid port numbers: Expected positive numbers, got '%s'",
1418 +                port_spec);
1419 +        return;
1420 +    }
1421 +
1422 +    /* Check if the emulator is already known.
1423 +     * Note: There's a small but harmless race condition here: An emulator not
1424 +     * present just yet could be registered by another invocation right
1425 +     * after doing this check here. However, local_connect protects
1426 +     * against double-registration too. From here, a better error message
1427 +     * can be produced. In the case of the race condition, the very specific
1428 +     * error message won't be shown, but the data doesn't get corrupted. */
1429 +    atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port);
1430 +    if (known_emulator != NULL) {
1431 +        snprintf(buffer, buffer_size,
1432 +                "Emulator on port %d already registered.", adb_port);
1433 +        return;
1434 +    }
1435 +
1436 +    /* Check if more emulators can be registered. Similar unproblematic
1437 +     * race condition as above. */
1438 +    int candidate_slot = get_available_local_transport_index();
1439 +    if (candidate_slot < 0) {
1440 +        snprintf(buffer, buffer_size, "Cannot accept more emulators.");
1441 +        return;
1442 +    }
1443 +
1444 +    /* Preconditions met, try to connect to the emulator. */
1445 +    if (!local_connect_arbitrary_ports(console_port, adb_port)) {
1446 +        snprintf(buffer, buffer_size,
1447 +                "Connected to emulator on ports %d,%d", console_port, adb_port);
1448 +    } else {
1449 +        snprintf(buffer, buffer_size,
1450 +                "Could not connect to emulator on ports %d,%d",
1451 +                console_port, adb_port);
1452 +    }
1453 +}
1454 +#endif
1455 +
1456 +int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s)
1457 +{
1458 +    atransport *transport = NULL;
1459 +    char buf[4096];
1460 +
1461 +    if(!strcmp(service, "kill")) {
1462 +        fprintf(stderr,"adb server killed by remote request\n");
1463 +        fflush(stdout);
1464 +        adb_write(reply_fd, "OKAY", 4);
1465 +        usb_cleanup();
1466 +        exit(0);
1467 +    }
1468 +
1469 +#if ADB_HOST
1470 +    // "transport:" is used for switching transport with a specified serial number
1471 +    // "transport-usb:" is used for switching transport to the only USB transport
1472 +    // "transport-local:" is used for switching transport to the only local transport
1473 +    // "transport-any:" is used for switching transport to the only transport
1474 +    if (!strncmp(service, "transport", strlen("transport"))) {
1475 +        char* error_string = "unknown failure";
1476 +        transport_type type = kTransportAny;
1477 +
1478 +        if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
1479 +            type = kTransportUsb;
1480 +        } else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
1481 +            type = kTransportLocal;
1482 +        } else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
1483 +            type = kTransportAny;
1484 +        } else if (!strncmp(service, "transport:", strlen("transport:"))) {
1485 +            service += strlen("transport:");
1486 +            serial = service;
1487 +        }
1488 +
1489 +        transport = acquire_one_transport(CS_ANY, type, serial, &error_string);
1490 +
1491 +        if (transport) {
1492 +            s->transport = transport;
1493 +            adb_write(reply_fd, "OKAY", 4);
1494 +        } else {
1495 +            sendfailmsg(reply_fd, error_string);
1496 +        }
1497 +        return 1;
1498 +    }
1499 +
1500 +    // return a list of all connected devices
1501 +    if (!strncmp(service, "devices", 7)) {
1502 +        char buffer[4096];
1503 +        int use_long = !strcmp(service+7, "-l");
1504 +        if (use_long || service[7] == 0) {
1505 +            memset(buf, 0, sizeof(buf));
1506 +            memset(buffer, 0, sizeof(buffer));
1507 +            D("Getting device list \n");
1508 +            list_transports(buffer, sizeof(buffer), use_long);
1509 +            snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer),buffer);
1510 +            D("Wrote device list \n");
1511 +            writex(reply_fd, buf, strlen(buf));
1512 +            return 0;
1513 +        }
1514 +    }
1515 +
1516 +    // add a new TCP transport, device or emulator
1517 +    if (!strncmp(service, "connect:", 8)) {
1518 +        char buffer[4096];
1519 +        char* host = service + 8;
1520 +        if (!strncmp(host, "emu:", 4)) {
1521 +            connect_emulator(host + 4, buffer, sizeof(buffer));
1522 +        } else {
1523 +            connect_device(host, buffer, sizeof(buffer));
1524 +        }
1525 +        // Send response for emulator and device
1526 +        snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
1527 +        writex(reply_fd, buf, strlen(buf));
1528 +        return 0;
1529 +    }
1530 +
1531 +    // remove TCP transport
1532 +    if (!strncmp(service, "disconnect:", 11)) {
1533 +        char buffer[4096];
1534 +        memset(buffer, 0, sizeof(buffer));
1535 +        char* serial = service + 11;
1536 +        if (serial[0] == 0) {
1537 +            // disconnect from all TCP devices
1538 +            unregister_all_tcp_transports();
1539 +        } else {
1540 +            char hostbuf[100];
1541 +            // assume port 5555 if no port is specified
1542 +            if (!strchr(serial, ':')) {
1543 +                snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555", serial);
1544 +                serial = hostbuf;
1545 +            }
1546 +            atransport *t = find_transport(serial);
1547 +
1548 +            if (t) {
1549 +                unregister_transport(t);
1550 +            } else {
1551 +                snprintf(buffer, sizeof(buffer), "No such device %s", serial);
1552 +            }
1553 +        }
1554 +
1555 +        snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer);
1556 +        writex(reply_fd, buf, strlen(buf));
1557 +        return 0;
1558 +    }
1559 +
1560 +    // returns our value for ADB_SERVER_VERSION
1561 +    if (!strcmp(service, "version")) {
1562 +        char version[12];
1563 +        snprintf(version, sizeof version, "%04x", ADB_SERVER_VERSION);
1564 +        snprintf(buf, sizeof buf, "OKAY%04x%s", (unsigned)strlen(version), version);
1565 +        writex(reply_fd, buf, strlen(buf));
1566 +        return 0;
1567 +    }
1568 +
1569 +    if(!strncmp(service,"get-serialno",strlen("get-serialno"))) {
1570 +        char *out = "unknown";
1571 +         transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1572 +       if (transport && transport->serial) {
1573 +            out = transport->serial;
1574 +        }
1575 +        snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out);
1576 +        writex(reply_fd, buf, strlen(buf));
1577 +        return 0;
1578 +    }
1579 +    if(!strncmp(service,"get-devpath",strlen("get-devpath"))) {
1580 +        char *out = "unknown";
1581 +         transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1582 +       if (transport && transport->devpath) {
1583 +            out = transport->devpath;
1584 +        }
1585 +        snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out);
1586 +        writex(reply_fd, buf, strlen(buf));
1587 +        return 0;
1588 +    }
1589 +    // indicates a new emulator instance has started
1590 +    if (!strncmp(service,"emulator:",9)) {
1591 +        int  port = atoi(service+9);
1592 +        local_connect(port);
1593 +        /* we don't even need to send a reply */
1594 +        return 0;
1595 +    }
1596 +#endif // ADB_HOST
1597 +
1598 +    if(!strcmp(service,"list-forward")) {
1599 +        // Create the list of forward redirections.
1600 +        char header[9];
1601 +        int buffer_size = format_listeners(NULL, 0);
1602 +        // Add one byte for the trailing zero.
1603 +        char* buffer = malloc(buffer_size+1);
1604 +        (void) format_listeners(buffer, buffer_size+1);
1605 +        snprintf(header, sizeof header, "OKAY%04x", buffer_size);
1606 +        writex(reply_fd, header, 8);
1607 +        writex(reply_fd, buffer, buffer_size);
1608 +        free(buffer);
1609 +        return 0;
1610 +    }
1611 +
1612 +    if (!strcmp(service,"killforward-all")) {
1613 +        remove_all_listeners();
1614 +        adb_write(reply_fd, "OKAYOKAY", 8);
1615 +        return 0;
1616 +    }
1617 +
1618 +    if(!strncmp(service,"forward:",8) ||
1619 +       !strncmp(service,"killforward:",12)) {
1620 +        char *local, *remote, *err;
1621 +        int r;
1622 +        atransport *transport;
1623 +
1624 +        int createForward = strncmp(service,"kill",4);
1625 +        int no_rebind = 0;
1626 +
1627 +        local = strchr(service, ':') + 1;
1628 +
1629 +        // Handle forward:norebind:<local>... here
1630 +        if (createForward && !strncmp(local, "norebind:", 9)) {
1631 +            no_rebind = 1;
1632 +            local = strchr(local, ':') + 1;
1633 +        }
1634 +
1635 +        remote = strchr(local,';');
1636 +
1637 +        if (createForward) {
1638 +            // Check forward: parameter format: '<local>;<remote>'
1639 +            if(remote == 0) {
1640 +                sendfailmsg(reply_fd, "malformed forward spec");
1641 +                return 0;
1642 +            }
1643 +
1644 +            *remote++ = 0;
1645 +            if((local[0] == 0) || (remote[0] == 0) || (remote[0] == '*')){
1646 +                sendfailmsg(reply_fd, "malformed forward spec");
1647 +                return 0;
1648 +            }
1649 +        } else {
1650 +            // Check killforward: parameter format: '<local>'
1651 +            if (local[0] == 0) {
1652 +                sendfailmsg(reply_fd, "malformed forward spec");
1653 +                return 0;
1654 +            }
1655 +        }
1656 +
1657 +        transport = acquire_one_transport(CS_ANY, ttype, serial, &err);
1658 +        if (!transport) {
1659 +            sendfailmsg(reply_fd, err);
1660 +            return 0;
1661 +        }
1662 +
1663 +        if (createForward) {
1664 +            r = install_listener(local, remote, transport, no_rebind);
1665 +        } else {
1666 +            r = remove_listener(local, transport);
1667 +        }
1668 +        if(r == 0) {
1669 +                /* 1st OKAY is connect, 2nd OKAY is status */
1670 +            writex(reply_fd, "OKAYOKAY", 8);
1671 +            return 0;
1672 +        }
1673 +
1674 +        if (createForward) {
1675 +            const char* message;
1676 +            switch (r) {
1677 +              case INSTALL_STATUS_CANNOT_BIND:
1678 +                message = "cannot bind to socket";
1679 +                break;
1680 +              case INSTALL_STATUS_CANNOT_REBIND:
1681 +                message = "cannot rebind existing socket";
1682 +                break;
1683 +              default:
1684 +                message = "internal error";
1685 +            }
1686 +            sendfailmsg(reply_fd, message);
1687 +        } else {
1688 +            sendfailmsg(reply_fd, "cannot remove listener");
1689 +        }
1690 +        return 0;
1691 +    }
1692 +
1693 +    if(!strncmp(service,"get-state",strlen("get-state"))) {
1694 +        transport = acquire_one_transport(CS_ANY, ttype, serial, NULL);
1695 +        char *state = connection_state_name(transport);
1696 +        snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(state),state);
1697 +        writex(reply_fd, buf, strlen(buf));
1698 +        return 0;
1699 +    }
1700 +    return -1;
1701 +}
1702 +
1703 +#if !ADB_HOST
1704 +int recovery_mode = 0;
1705 +#endif
1706 +
1707 +int main(int argc, char **argv)
1708 +{
1709 +#if ADB_HOST
1710 +    adb_sysdeps_init();
1711 +    adb_trace_init();
1712 +    D("Handling commandline()\n");
1713 +    return adb_commandline(argc - 1, argv + 1);
1714 +#else
1715 +    /* If adbd runs inside the emulator this will enable adb tracing via
1716 +     * adb-debug qemud service in the emulator. */
1717 +    adb_qemu_trace_init();
1718 +    if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
1719 +        adb_device_banner = "recovery";
1720 +        recovery_mode = 1;
1721 +    }
1722 +
1723 +    start_device_log();
1724 +    D("Handling main()\n");
1725 +    return adb_main(0, DEFAULT_ADB_PORT);
1726 +#endif
1727 +}
1728 Index: android-tools-4.2.2+git20130218/core/adbd/adb.h
1729 ===================================================================
1730 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1731 +++ android-tools-4.2.2+git20130218/core/adbd/adb.h     2013-06-18 17:12:17.000000000 -0300
1732 @@ -0,0 +1,491 @@
1733 +/*
1734 + * Copyright (C) 2007 The Android Open Source Project
1735 + *
1736 + * Licensed under the Apache License, Version 2.0 (the "License");
1737 + * you may not use this file except in compliance with the License.
1738 + * You may obtain a copy of the License at
1739 + *
1740 + *      http://www.apache.org/licenses/LICENSE-2.0
1741 + *
1742 + * Unless required by applicable law or agreed to in writing, software
1743 + * distributed under the License is distributed on an "AS IS" BASIS,
1744 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1745 + * See the License for the specific language governing permissions and
1746 + * limitations under the License.
1747 + */
1748 +
1749 +#ifndef __ADB_H
1750 +#define __ADB_H
1751 +
1752 +#include <limits.h>
1753 +
1754 +#include "transport.h"  /* readx(), writex() */
1755 +
1756 +#define MAX_PAYLOAD 4096
1757 +
1758 +#define A_SYNC 0x434e5953
1759 +#define A_CNXN 0x4e584e43
1760 +#define A_OPEN 0x4e45504f
1761 +#define A_OKAY 0x59414b4f
1762 +#define A_CLSE 0x45534c43
1763 +#define A_WRTE 0x45545257
1764 +#define A_AUTH 0x48545541
1765 +
1766 +#define A_VERSION 0x01000000        // ADB protocol version
1767 +
1768 +#define ADB_VERSION_MAJOR 1         // Used for help/version information
1769 +#define ADB_VERSION_MINOR 0         // Used for help/version information
1770 +
1771 +#define ADB_SERVER_VERSION    31    // Increment this when we want to force users to start a new adb server
1772 +
1773 +typedef struct amessage amessage;
1774 +typedef struct apacket apacket;
1775 +typedef struct asocket asocket;
1776 +typedef struct alistener alistener;
1777 +typedef struct aservice aservice;
1778 +typedef struct atransport atransport;
1779 +typedef struct adisconnect  adisconnect;
1780 +typedef struct usb_handle usb_handle;
1781 +
1782 +struct amessage {
1783 +    unsigned command;       /* command identifier constant      */
1784 +    unsigned arg0;          /* first argument                   */
1785 +    unsigned arg1;          /* second argument                  */
1786 +    unsigned data_length;   /* length of payload (0 is allowed) */
1787 +    unsigned data_check;    /* checksum of data payload         */
1788 +    unsigned magic;         /* command ^ 0xffffffff             */
1789 +};
1790 +
1791 +struct apacket
1792 +{
1793 +    apacket *next;
1794 +
1795 +    unsigned len;
1796 +    unsigned char *ptr;
1797 +
1798 +    amessage msg;
1799 +    unsigned char data[MAX_PAYLOAD];
1800 +};
1801 +
1802 +/* An asocket represents one half of a connection between a local and
1803 +** remote entity.  A local asocket is bound to a file descriptor.  A
1804 +** remote asocket is bound to the protocol engine.
1805 +*/
1806 +struct asocket {
1807 +        /* chain pointers for the local/remote list of
1808 +        ** asockets that this asocket lives in
1809 +        */
1810 +    asocket *next;
1811 +    asocket *prev;
1812 +
1813 +        /* the unique identifier for this asocket
1814 +        */
1815 +    unsigned id;
1816 +
1817 +        /* flag: set when the socket's peer has closed
1818 +        ** but packets are still queued for delivery
1819 +        */
1820 +    int    closing;
1821 +
1822 +        /* flag: quit adbd when both ends close the
1823 +        ** local service socket
1824 +        */
1825 +    int    exit_on_close;
1826 +
1827 +        /* the asocket we are connected to
1828 +        */
1829 +
1830 +    asocket *peer;
1831 +
1832 +        /* For local asockets, the fde is used to bind
1833 +        ** us to our fd event system.  For remote asockets
1834 +        ** these fields are not used.
1835 +        */
1836 +    fdevent fde;
1837 +    int fd;
1838 +
1839 +        /* queue of apackets waiting to be written
1840 +        */
1841 +    apacket *pkt_first;
1842 +    apacket *pkt_last;
1843 +
1844 +        /* enqueue is called by our peer when it has data
1845 +        ** for us.  It should return 0 if we can accept more
1846 +        ** data or 1 if not.  If we return 1, we must call
1847 +        ** peer->ready() when we once again are ready to
1848 +        ** receive data.
1849 +        */
1850 +    int (*enqueue)(asocket *s, apacket *pkt);
1851 +
1852 +        /* ready is called by the peer when it is ready for
1853 +        ** us to send data via enqueue again
1854 +        */
1855 +    void (*ready)(asocket *s);
1856 +
1857 +        /* close is called by the peer when it has gone away.
1858 +        ** we are not allowed to make any further calls on the
1859 +        ** peer once our close method is called.
1860 +        */
1861 +    void (*close)(asocket *s);
1862 +
1863 +        /* socket-type-specific extradata */
1864 +    void *extra;
1865 +
1866 +       /* A socket is bound to atransport */
1867 +    atransport *transport;
1868 +};
1869 +
1870 +
1871 +/* the adisconnect structure is used to record a callback that
1872 +** will be called whenever a transport is disconnected (e.g. by the user)
1873 +** this should be used to cleanup objects that depend on the
1874 +** transport (e.g. remote sockets, listeners, etc...)
1875 +*/
1876 +struct  adisconnect
1877 +{
1878 +    void        (*func)(void*  opaque, atransport*  t);
1879 +    void*         opaque;
1880 +    adisconnect*  next;
1881 +    adisconnect*  prev;
1882 +};
1883 +
1884 +
1885 +/* a transport object models the connection to a remote device or emulator
1886 +** there is one transport per connected device/emulator. a "local transport"
1887 +** connects through TCP (for the emulator), while a "usb transport" through
1888 +** USB (for real devices)
1889 +**
1890 +** note that kTransportHost doesn't really correspond to a real transport
1891 +** object, it's a special value used to indicate that a client wants to
1892 +** connect to a service implemented within the ADB server itself.
1893 +*/
1894 +typedef enum transport_type {
1895 +        kTransportUsb,
1896 +        kTransportLocal,
1897 +        kTransportAny,
1898 +        kTransportHost,
1899 +} transport_type;
1900 +
1901 +#define TOKEN_SIZE 20
1902 +
1903 +struct atransport
1904 +{
1905 +    atransport *next;
1906 +    atransport *prev;
1907 +
1908 +    int (*read_from_remote)(apacket *p, atransport *t);
1909 +    int (*write_to_remote)(apacket *p, atransport *t);
1910 +    void (*close)(atransport *t);
1911 +    void (*kick)(atransport *t);
1912 +
1913 +    int fd;
1914 +    int transport_socket;
1915 +    fdevent transport_fde;
1916 +    int ref_count;
1917 +    unsigned sync_token;
1918 +    int connection_state;
1919 +    int online;
1920 +    transport_type type;
1921 +
1922 +        /* usb handle or socket fd as needed */
1923 +    usb_handle *usb;
1924 +    int sfd;
1925 +
1926 +        /* used to identify transports for clients */
1927 +    char *serial;
1928 +    char *product;
1929 +    char *model;
1930 +    char *device;
1931 +    char *devpath;
1932 +    int adb_port; // Use for emulators (local transport)
1933 +
1934 +        /* a list of adisconnect callbacks called when the transport is kicked */
1935 +    int          kicked;
1936 +    adisconnect  disconnects;
1937 +
1938 +    void *key;
1939 +    unsigned char token[TOKEN_SIZE];
1940 +    fdevent auth_fde;
1941 +    unsigned failed_auth_attempts;
1942 +};
1943 +
1944 +
1945 +/* A listener is an entity which binds to a local port
1946 +** and, upon receiving a connection on that port, creates
1947 +** an asocket to connect the new local connection to a
1948 +** specific remote service.
1949 +**
1950 +** TODO: some listeners read from the new connection to
1951 +** determine what exact service to connect to on the far
1952 +** side.
1953 +*/
1954 +struct alistener
1955 +{
1956 +    alistener *next;
1957 +    alistener *prev;
1958 +
1959 +    fdevent fde;
1960 +    int fd;
1961 +
1962 +    const char *local_name;
1963 +    const char *connect_to;
1964 +    atransport *transport;
1965 +    adisconnect  disconnect;
1966 +};
1967 +
1968 +
1969 +void print_packet(const char *label, apacket *p);
1970 +
1971 +asocket *find_local_socket(unsigned id);
1972 +void install_local_socket(asocket *s);
1973 +void remove_socket(asocket *s);
1974 +void close_all_sockets(atransport *t);
1975 +
1976 +#define  LOCAL_CLIENT_PREFIX  "emulator-"
1977 +
1978 +asocket *create_local_socket(int fd);
1979 +asocket *create_local_service_socket(const char *destination);
1980 +
1981 +asocket *create_remote_socket(unsigned id, atransport *t);
1982 +void connect_to_remote(asocket *s, const char *destination);
1983 +void connect_to_smartsocket(asocket *s);
1984 +
1985 +void fatal(const char *fmt, ...);
1986 +void fatal_errno(const char *fmt, ...);
1987 +
1988 +void handle_packet(apacket *p, atransport *t);
1989 +void send_packet(apacket *p, atransport *t);
1990 +
1991 +void get_my_path(char *s, size_t maxLen);
1992 +int launch_server(int server_port);
1993 +int adb_main(int is_daemon, int server_port);
1994 +
1995 +
1996 +/* transports are ref-counted
1997 +** get_device_transport does an acquire on your behalf before returning
1998 +*/
1999 +void init_transport_registration(void);
2000 +int  list_transports(char *buf, size_t  bufsize, int long_listing);
2001 +void update_transports(void);
2002 +
2003 +asocket*  create_device_tracker(void);
2004 +
2005 +/* Obtain a transport from the available transports.
2006 +** If state is != CS_ANY, only transports in that state are considered.
2007 +** If serial is non-NULL then only the device with that serial will be chosen.
2008 +** If no suitable transport is found, error is set.
2009 +*/
2010 +atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char **error_out);
2011 +void   add_transport_disconnect( atransport*  t, adisconnect*  dis );
2012 +void   remove_transport_disconnect( atransport*  t, adisconnect*  dis );
2013 +void   run_transport_disconnects( atransport*  t );
2014 +void   kick_transport( atransport*  t );
2015 +
2016 +/* initialize a transport object's func pointers and state */
2017 +#if ADB_HOST
2018 +int get_available_local_transport_index();
2019 +#endif
2020 +int  init_socket_transport(atransport *t, int s, int port, int local);
2021 +void init_usb_transport(atransport *t, usb_handle *usb, int state);
2022 +
2023 +/* for MacOS X cleanup */
2024 +void close_usb_devices();
2025 +
2026 +/* cause new transports to be init'd and added to the list */
2027 +void register_socket_transport(int s, const char *serial, int port, int local);
2028 +
2029 +/* these should only be used for the "adb disconnect" command */
2030 +void unregister_transport(atransport *t);
2031 +void unregister_all_tcp_transports();
2032 +
2033 +void register_usb_transport(usb_handle *h, const char *serial, const char *devpath, unsigned writeable);
2034 +
2035 +/* this should only be used for transports with connection_state == CS_NOPERM */
2036 +void unregister_usb_transport(usb_handle *usb);
2037 +
2038 +atransport *find_transport(const char *serial);
2039 +#if ADB_HOST
2040 +atransport* find_emulator_transport_by_adb_port(int adb_port);
2041 +#endif
2042 +
2043 +int service_to_fd(const char *name);
2044 +#if ADB_HOST
2045 +asocket *host_service_to_socket(const char*  name, const char *serial);
2046 +#endif
2047 +
2048 +#if !ADB_HOST
2049 +int       init_jdwp(void);
2050 +asocket*  create_jdwp_service_socket();
2051 +asocket*  create_jdwp_tracker_service_socket();
2052 +int       create_jdwp_connection_fd(int  jdwp_pid);
2053 +#endif
2054 +
2055 +#if !ADB_HOST
2056 +typedef enum {
2057 +    BACKUP,
2058 +    RESTORE
2059 +} BackupOperation;
2060 +int backup_service(BackupOperation operation, char* args);
2061 +void framebuffer_service(int fd, void *cookie);
2062 +void log_service(int fd, void *cookie);
2063 +void remount_service(int fd, void *cookie);
2064 +char * get_log_file_path(const char * log_name);
2065 +#endif
2066 +
2067 +/* packet allocator */
2068 +apacket *get_apacket(void);
2069 +void put_apacket(apacket *p);
2070 +
2071 +int check_header(apacket *p);
2072 +int check_data(apacket *p);
2073 +
2074 +/* define ADB_TRACE to 1 to enable tracing support, or 0 to disable it */
2075 +
2076 +#define  ADB_TRACE    1
2077 +
2078 +/* IMPORTANT: if you change the following list, don't
2079 + * forget to update the corresponding 'tags' table in
2080 + * the adb_trace_init() function implemented in adb.c
2081 + */
2082 +typedef enum {
2083 +    TRACE_ADB = 0,   /* 0x001 */
2084 +    TRACE_SOCKETS,
2085 +    TRACE_PACKETS,
2086 +    TRACE_TRANSPORT,
2087 +    TRACE_RWX,       /* 0x010 */
2088 +    TRACE_USB,
2089 +    TRACE_SYNC,
2090 +    TRACE_SYSDEPS,
2091 +    TRACE_JDWP,      /* 0x100 */
2092 +    TRACE_SERVICES,
2093 +    TRACE_AUTH,
2094 +} AdbTrace;
2095 +
2096 +#if ADB_TRACE
2097 +
2098 +#if !ADB_HOST
2099 +/*
2100 + * When running inside the emulator, guest's adbd can connect to 'adb-debug'
2101 + * qemud service that can display adb trace messages (on condition that emulator
2102 + * has been started with '-debug adb' option).
2103 + */
2104 +
2105 +/* Delivers a trace message to the emulator via QEMU pipe. */
2106 +void adb_qemu_trace(const char* fmt, ...);
2107 +/* Macro to use to send ADB trace messages to the emulator. */
2108 +#define DQ(...)    adb_qemu_trace(__VA_ARGS__)
2109 +#else
2110 +#define DQ(...) ((void)0)
2111 +#endif  /* !ADB_HOST */
2112 +
2113 +  extern int     adb_trace_mask;
2114 +  extern unsigned char    adb_trace_output_count;
2115 +  void    adb_trace_init(void);
2116 +
2117 +#  define ADB_TRACING  ((adb_trace_mask & (1 << TRACE_TAG)) != 0)
2118 +
2119 +  /* you must define TRACE_TAG before using this macro */
2120 +#  define  D(...)                                      \
2121 +        do {                                           \
2122 +            if (ADB_TRACING) {                         \
2123 +                int save_errno = errno;                \
2124 +                adb_mutex_lock(&D_lock);               \
2125 +                fprintf(stderr, "%s::%s():",           \
2126 +                        __FILE__, __FUNCTION__);       \
2127 +                errno = save_errno;                    \
2128 +                fprintf(stderr, __VA_ARGS__ );         \
2129 +                fflush(stderr);                        \
2130 +                adb_mutex_unlock(&D_lock);             \
2131 +                errno = save_errno;                    \
2132 +           }                                           \
2133 +        } while (0)
2134 +#  define  DR(...)                                     \
2135 +        do {                                           \
2136 +            if (ADB_TRACING) {                         \
2137 +                int save_errno = errno;                \
2138 +                adb_mutex_lock(&D_lock);               \
2139 +                errno = save_errno;                    \
2140 +                fprintf(stderr, __VA_ARGS__ );         \
2141 +                fflush(stderr);                        \
2142 +                adb_mutex_unlock(&D_lock);             \
2143 +                errno = save_errno;                    \
2144 +           }                                           \
2145 +        } while (0)
2146 +#else
2147 +#  define  D(...)          ((void)0)
2148 +#  define  DR(...)         ((void)0)
2149 +#  define  ADB_TRACING     0
2150 +#endif
2151 +
2152 +
2153 +#if !DEBUG_PACKETS
2154 +#define print_packet(tag,p) do {} while (0)
2155 +#endif
2156 +
2157 +#if ADB_HOST_ON_TARGET
2158 +/* adb and adbd are coexisting on the target, so use 5038 for adb
2159 + * to avoid conflicting with adbd's usage of 5037
2160 + */
2161 +#  define DEFAULT_ADB_PORT 5038
2162 +#else
2163 +#  define DEFAULT_ADB_PORT 5037
2164 +#endif
2165 +
2166 +#define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555
2167 +
2168 +#define ADB_CLASS              0xff
2169 +#define ADB_SUBCLASS           0x42
2170 +#define ADB_PROTOCOL           0x1
2171 +
2172 +
2173 +void local_init(int port);
2174 +int  local_connect(int  port);
2175 +int  local_connect_arbitrary_ports(int console_port, int adb_port);
2176 +
2177 +/* usb host/client interface */
2178 +void usb_init();
2179 +void usb_cleanup();
2180 +int usb_write(usb_handle *h, const void *data, int len);
2181 +int usb_read(usb_handle *h, void *data, int len);
2182 +int usb_close(usb_handle *h);
2183 +void usb_kick(usb_handle *h);
2184 +
2185 +/* used for USB device detection */
2186 +#if ADB_HOST
2187 +int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol);
2188 +#endif
2189 +
2190 +unsigned host_to_le32(unsigned n);
2191 +int adb_commandline(int argc, char **argv);
2192 +
2193 +int connection_state(atransport *t);
2194 +
2195 +#define CS_ANY       -1
2196 +#define CS_OFFLINE    0
2197 +#define CS_BOOTLOADER 1
2198 +#define CS_DEVICE     2
2199 +#define CS_HOST       3
2200 +#define CS_RECOVERY   4
2201 +#define CS_NOPERM     5 /* Insufficient permissions to communicate with the device */
2202 +#define CS_SIDELOAD   6
2203 +
2204 +extern int HOST;
2205 +extern int SHELL_EXIT_NOTIFY_FD;
2206 +
2207 +#define CHUNK_SIZE (64*1024)
2208 +
2209 +#if !ADB_HOST
2210 +#define USB_ADB_PATH     "/dev/android_adb"
2211 +
2212 +#define USB_FFS_ADB_PATH  "/dev/usb-ffs/adb/"
2213 +#define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x
2214 +
2215 +#define USB_FFS_ADB_EP0   USB_FFS_ADB_EP(ep0)
2216 +#define USB_FFS_ADB_OUT   USB_FFS_ADB_EP(ep1)
2217 +#define USB_FFS_ADB_IN    USB_FFS_ADB_EP(ep2)
2218 +#endif
2219 +
2220 +int sendfailmsg(int fd, const char *reason);
2221 +int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s);
2222 +
2223 +#endif
2224 Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth.h
2225 ===================================================================
2226 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2227 +++ android-tools-4.2.2+git20130218/core/adbd/adb_auth.h        2013-06-18 17:12:17.000000000 -0300
2228 @@ -0,0 +1,54 @@
2229 +/*
2230 + * Copyright (C) 2012 The Android Open Source Project
2231 + *
2232 + * Licensed under the Apache License, Version 2.0 (the "License");
2233 + * you may not use this file except in compliance with the License.
2234 + * You may obtain a copy of the License at
2235 + *
2236 + *      http://www.apache.org/licenses/LICENSE-2.0
2237 + *
2238 + * Unless required by applicable law or agreed to in writing, software
2239 + * distributed under the License is distributed on an "AS IS" BASIS,
2240 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2241 + * See the License for the specific language governing permissions and
2242 + * limitations under the License.
2243 + */
2244 +
2245 +#ifndef __ADB_AUTH_H
2246 +#define __ADB_AUTH_H
2247 +
2248 +void adb_auth_init(void);
2249 +void adb_auth_verified(atransport *t);
2250 +
2251 +/* AUTH packets first argument */
2252 +/* Request */
2253 +#define ADB_AUTH_TOKEN         1
2254 +/* Response */
2255 +#define ADB_AUTH_SIGNATURE     2
2256 +#define ADB_AUTH_RSAPUBLICKEY  3
2257 +
2258 +#if ADB_HOST
2259 +
2260 +int adb_auth_sign(void *key, void *token, size_t token_size, void *sig);
2261 +void *adb_auth_nextkey(void *current);
2262 +int adb_auth_get_userkey(unsigned char *data, size_t len);
2263 +
2264 +static inline int adb_auth_generate_token(void *token, size_t token_size) { return 0; }
2265 +static inline int adb_auth_verify(void *token, void *sig, int siglen) { return 0; }
2266 +static inline void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t) { }
2267 +static inline void adb_auth_reload_keys(void) { }
2268 +
2269 +#else // !ADB_HOST
2270 +
2271 +static inline int adb_auth_sign(void* key, void *token, size_t token_size, void *sig) { return 0; }
2272 +static inline void *adb_auth_nextkey(void *current) { return NULL; }
2273 +static inline int adb_auth_get_userkey(unsigned char *data, size_t len) { return 0; }
2274 +
2275 +int adb_auth_generate_token(void *token, size_t token_size);
2276 +int adb_auth_verify(void *token, void *sig, int siglen);
2277 +void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t);
2278 +void adb_auth_reload_keys(void);
2279 +
2280 +#endif // ADB_HOST
2281 +
2282 +#endif // __ADB_AUTH_H
2283 Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth_client.c
2284 ===================================================================
2285 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2286 +++ android-tools-4.2.2+git20130218/core/adbd/adb_auth_client.c 2013-06-18 17:12:17.000000000 -0300
2287 @@ -0,0 +1,245 @@
2288 +/*
2289 + * Copyright (C) 2012 The Android Open Source Project
2290 + *
2291 + * Licensed under the Apache License, Version 2.0 (the "License");
2292 + * you may not use this file except in compliance with the License.
2293 + * You may obtain a copy of the License at
2294 + *
2295 + *      http://www.apache.org/licenses/LICENSE-2.0
2296 + *
2297 + * Unless required by applicable law or agreed to in writing, software
2298 + * distributed under the License is distributed on an "AS IS" BASIS,
2299 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2300 + * See the License for the specific language governing permissions and
2301 + * limitations under the License.
2302 + */
2303 +
2304 +#include <stdio.h>
2305 +#include <string.h>
2306 +#include <resolv.h>
2307 +#include <cutils/list.h>
2308 +#include <cutils/sockets.h>
2309 +
2310 +#include "sysdeps.h"
2311 +#include "adb.h"
2312 +#include "adb_auth.h"
2313 +#include "fdevent.h"
2314 +#include "mincrypt/rsa.h"
2315 +
2316 +#define TRACE_TAG TRACE_AUTH
2317 +
2318 +
2319 +struct adb_public_key {
2320 +    struct listnode node;
2321 +    RSAPublicKey key;
2322 +};
2323 +
2324 +static struct listnode key_list;
2325 +
2326 +static char *key_paths[] = {
2327 +    "/adb_keys",
2328 +    "/data/misc/adb/adb_keys",
2329 +    NULL
2330 +};
2331 +
2332 +static fdevent listener_fde;
2333 +static int framework_fd = -1;
2334 +
2335 +
2336 +static void read_keys(const char *file, struct listnode *list)
2337 +{
2338 +    struct adb_public_key *key;
2339 +    FILE *f;
2340 +    char buf[MAX_PAYLOAD];
2341 +    char *sep;
2342 +    int ret;
2343 +
2344 +    f = fopen(file, "r");
2345 +    if (!f) {
2346 +        D("Can't open '%s'\n", file);
2347 +        return;
2348 +    }
2349 +
2350 +    while (fgets(buf, sizeof(buf), f)) {
2351 +        /* Allocate 4 extra bytes to decode the base64 data in-place */
2352 +        key = calloc(1, sizeof(*key) + 4);
2353 +        if (!key) {
2354 +            D("Can't malloc key\n");
2355 +            break;
2356 +        }
2357 +
2358 +        sep = strpbrk(buf, " \t");
2359 +        if (sep)
2360 +            *sep = '\0';
2361 +
2362 +        ret = __b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4);
2363 +        if (ret != sizeof(key->key)) {
2364 +            D("%s: Invalid base64 data ret=%d\n", file, ret);
2365 +            free(key);
2366 +            continue;
2367 +        }
2368 +
2369 +        if (key->key.len != RSANUMWORDS) {
2370 +            D("%s: Invalid key len %d\n", file, key->key.len);
2371 +            free(key);
2372 +            continue;
2373 +        }
2374 +
2375 +        list_add_tail(list, &key->node);
2376 +    }
2377 +
2378 +    fclose(f);
2379 +}
2380 +
2381 +static void free_keys(struct listnode *list)
2382 +{
2383 +    struct listnode *item;
2384 +
2385 +    while (!list_empty(list)) {
2386 +        item = list_head(list);
2387 +        list_remove(item);
2388 +        free(node_to_item(item, struct adb_public_key, node));
2389 +    }
2390 +}
2391 +
2392 +void adb_auth_reload_keys(void)
2393 +{
2394 +    char *path;
2395 +    char **paths = key_paths;
2396 +    struct stat buf;
2397 +
2398 +    free_keys(&key_list);
2399 +
2400 +    while ((path = *paths++)) {
2401 +        if (!stat(path, &buf)) {
2402 +            D("Loading keys from '%s'\n", path);
2403 +            read_keys(path, &key_list);
2404 +        }
2405 +    }
2406 +}
2407 +
2408 +int adb_auth_generate_token(void *token, size_t token_size)
2409 +{
2410 +    FILE *f;
2411 +    int ret;
2412 +
2413 +    f = fopen("/dev/urandom", "r");
2414 +    if (!f)
2415 +        return 0;
2416 +
2417 +    ret = fread(token, token_size, 1, f);
2418 +
2419 +    fclose(f);
2420 +    return ret * token_size;
2421 +}
2422 +
2423 +int adb_auth_verify(void *token, void *sig, int siglen)
2424 +{
2425 +    struct listnode *item;
2426 +    struct adb_public_key *key;
2427 +    int ret;
2428 +
2429 +    if (siglen != RSANUMBYTES)
2430 +        return 0;
2431 +
2432 +    list_for_each(item, &key_list) {
2433 +        key = node_to_item(item, struct adb_public_key, node);
2434 +        ret = RSA_verify(&key->key, sig, siglen, token);
2435 +        if (ret)
2436 +            return 1;
2437 +    }
2438 +
2439 +    return 0;
2440 +}
2441 +
2442 +static void adb_auth_event(int fd, unsigned events, void *data)
2443 +{
2444 +    atransport *t = data;
2445 +    char response[2];
2446 +    int ret;
2447 +
2448 +    if (events & FDE_READ) {
2449 +        ret = unix_read(fd, response, sizeof(response));
2450 +        if (ret < 0) {
2451 +            D("Disconnect");
2452 +            fdevent_remove(&t->auth_fde);
2453 +            framework_fd = -1;
2454 +        }
2455 +        else if (ret == 2 && response[0] == 'O' && response[1] == 'K') {
2456 +            adb_auth_reload_keys();
2457 +            adb_auth_verified(t);
2458 +        }
2459 +    }
2460 +}
2461 +
2462 +void adb_auth_confirm_key(unsigned char *key, size_t len, atransport *t)
2463 +{
2464 +    char msg[MAX_PAYLOAD];
2465 +    int ret;
2466 +
2467 +    if (framework_fd < 0) {
2468 +        D("Client not connected\n");
2469 +        return;
2470 +    }
2471 +
2472 +    if (key[len - 1] != '\0') {
2473 +        D("Key must be a null-terminated string\n");
2474 +        return;
2475 +    }
2476 +
2477 +    ret = snprintf(msg, sizeof(msg), "PK%s", key);
2478 +    if (ret >= (signed)sizeof(msg)) {
2479 +        D("Key too long. ret=%d", ret);
2480 +        return;
2481 +    }
2482 +    D("Sending '%s'\n", msg);
2483 +
2484 +    ret = unix_write(framework_fd, msg, ret);
2485 +    if (ret < 0) {
2486 +        D("Failed to write PK, errno=%d\n", errno);
2487 +        return;
2488 +    }
2489 +
2490 +    fdevent_install(&t->auth_fde, framework_fd, adb_auth_event, t);
2491 +    fdevent_add(&t->auth_fde, FDE_READ);
2492 +}
2493 +
2494 +static void adb_auth_listener(int fd, unsigned events, void *data)
2495 +{
2496 +    struct sockaddr addr;
2497 +    socklen_t alen;
2498 +    int s;
2499 +
2500 +    alen = sizeof(addr);
2501 +
2502 +    s = adb_socket_accept(fd, &addr, &alen);
2503 +    if (s < 0) {
2504 +        D("Failed to accept: errno=%d\n", errno);
2505 +        return;
2506 +    }
2507 +
2508 +    framework_fd = s;
2509 +}
2510 +
2511 +void adb_auth_init(void)
2512 +{
2513 +    int fd, ret;
2514 +
2515 +    list_init(&key_list);
2516 +    adb_auth_reload_keys();
2517 +
2518 +    fd = android_get_control_socket("adbd");
2519 +    if (fd < 0) {
2520 +        D("Failed to get adbd socket\n");
2521 +        return;
2522 +    }
2523 +
2524 +    ret = listen(fd, 4);
2525 +    if (ret < 0) {
2526 +        D("Failed to listen on '%d'\n", fd);
2527 +        return;
2528 +    }
2529 +
2530 +    fdevent_install(&listener_fde, fd, adb_auth_listener, NULL);
2531 +    fdevent_add(&listener_fde, FDE_READ);
2532 +}
2533 Index: android-tools-4.2.2+git20130218/core/adbd/adb_auth_host.c
2534 ===================================================================
2535 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2536 +++ android-tools-4.2.2+git20130218/core/adbd/adb_auth_host.c   2013-06-18 17:12:17.000000000 -0300
2537 @@ -0,0 +1,426 @@
2538 +/*
2539 + * Copyright (C) 2012 The Android Open Source Project
2540 + *
2541 + * Licensed under the Apache License, Version 2.0 (the "License");
2542 + * you may not use this file except in compliance with the License.
2543 + * You may obtain a copy of the License at
2544 + *
2545 + *      http://www.apache.org/licenses/LICENSE-2.0
2546 + *
2547 + * Unless required by applicable law or agreed to in writing, software
2548 + * distributed under the License is distributed on an "AS IS" BASIS,
2549 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2550 + * See the License for the specific language governing permissions and
2551 + * limitations under the License.
2552 + */
2553 +
2554 +#include <stdio.h>
2555 +
2556 +#ifdef _WIN32
2557 +#  define WIN32_LEAN_AND_MEAN
2558 +#  include "windows.h"
2559 +#  include "shlobj.h"
2560 +#else
2561 +#  include <sys/types.h>
2562 +#  include <sys/stat.h>
2563 +#  include <unistd.h>
2564 +#endif
2565 +#include <string.h>
2566 +
2567 +#include "sysdeps.h"
2568 +#include "adb.h"
2569 +#include "adb_auth.h"
2570 +
2571 +/* HACK: we need the RSAPublicKey struct
2572 + * but RSA_verify conflits with openssl */
2573 +#define RSA_verify RSA_verify_mincrypt
2574 +#include "mincrypt/rsa.h"
2575 +#undef RSA_verify
2576 +
2577 +#include <cutils/list.h>
2578 +
2579 +#include <openssl/evp.h>
2580 +#include <openssl/objects.h>
2581 +#include <openssl/pem.h>
2582 +#include <openssl/rsa.h>
2583 +#include <openssl/sha.h>
2584 +
2585 +#define TRACE_TAG TRACE_AUTH
2586 +
2587 +#define ANDROID_PATH   ".android"
2588 +#define ADB_KEY_FILE   "adbkey"
2589 +
2590 +
2591 +struct adb_private_key {
2592 +    struct listnode node;
2593 +    RSA *rsa;
2594 +};
2595 +
2596 +static struct listnode key_list;
2597 +
2598 +
2599 +/* Convert OpenSSL RSA private key to android pre-computed RSAPublicKey format */
2600 +static int RSA_to_RSAPublicKey(RSA *rsa, RSAPublicKey *pkey)
2601 +{
2602 +    int ret = 1;
2603 +    unsigned int i;
2604 +
2605 +    BN_CTX* ctx = BN_CTX_new();
2606 +    BIGNUM* r32 = BN_new();
2607 +    BIGNUM* rr = BN_new();
2608 +    BIGNUM* r = BN_new();
2609 +    BIGNUM* rem = BN_new();
2610 +    BIGNUM* n = BN_new();
2611 +    BIGNUM* n0inv = BN_new();
2612 +
2613 +    if (RSA_size(rsa) != RSANUMBYTES) {
2614 +        ret = 0;
2615 +        goto out;
2616 +    }
2617 +
2618 +    BN_set_bit(r32, 32);
2619 +    BN_copy(n, rsa->n);
2620 +    BN_set_bit(r, RSANUMWORDS * 32);
2621 +    BN_mod_sqr(rr, r, n, ctx);
2622 +    BN_div(NULL, rem, n, r32, ctx);
2623 +    BN_mod_inverse(n0inv, rem, r32, ctx);
2624 +
2625 +    pkey->len = RSANUMWORDS;
2626 +    pkey->n0inv = 0 - BN_get_word(n0inv);
2627 +    for (i = 0; i < RSANUMWORDS; i++) {
2628 +        BN_div(rr, rem, rr, r32, ctx);
2629 +        pkey->rr[i] = BN_get_word(rem);
2630 +        BN_div(n, rem, n, r32, ctx);
2631 +        pkey->n[i] = BN_get_word(rem);
2632 +    }
2633 +    pkey->exponent = BN_get_word(rsa->e);
2634 +
2635 +out:
2636 +    BN_free(n0inv);
2637 +    BN_free(n);
2638 +    BN_free(rem);
2639 +    BN_free(r);
2640 +    BN_free(rr);
2641 +    BN_free(r32);
2642 +    BN_CTX_free(ctx);
2643 +
2644 +    return ret;
2645 +}
2646 +
2647 +static void get_user_info(char *buf, size_t len)
2648 +{
2649 +    char hostname[1024], username[1024];
2650 +    int ret;
2651 +
2652 +#ifndef _WIN32
2653 +    ret = gethostname(hostname, sizeof(hostname));
2654 +    if (ret < 0)
2655 +#endif
2656 +        strcpy(hostname, "unknown");
2657 +
2658 +#if !defined _WIN32 && !defined ADB_HOST_ON_TARGET
2659 +    ret = getlogin_r(username, sizeof(username));
2660 +    if (ret < 0)
2661 +#endif
2662 +        strcpy(username, "unknown");
2663 +
2664 +    ret = snprintf(buf, len, " %s@%s", username, hostname);
2665 +    if (ret >= (signed)len)
2666 +        buf[len - 1] = '\0';
2667 +}
2668 +
2669 +static int write_public_keyfile(RSA *private_key, const char *private_key_path)
2670 +{
2671 +    RSAPublicKey pkey;
2672 +    BIO *bio, *b64, *bfile;
2673 +    char path[PATH_MAX], info[MAX_PAYLOAD];
2674 +    int ret;
2675 +
2676 +    ret = snprintf(path, sizeof(path), "%s.pub", private_key_path);
2677 +    if (ret >= (signed)sizeof(path))
2678 +        return 0;
2679 +
2680 +    ret = RSA_to_RSAPublicKey(private_key, &pkey);
2681 +    if (!ret) {
2682 +        D("Failed to convert to publickey\n");
2683 +        return 0;
2684 +    }
2685 +
2686 +    bfile = BIO_new_file(path, "w");
2687 +    if (!bfile) {
2688 +        D("Failed to open '%s'\n", path);
2689 +        return 0;
2690 +    }
2691 +
2692 +    D("Writing public key to '%s'\n", path);
2693 +
2694 +    b64 = BIO_new(BIO_f_base64());
2695 +    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
2696 +
2697 +    bio = BIO_push(b64, bfile);
2698 +    BIO_write(bio, &pkey, sizeof(pkey));
2699 +    BIO_flush(bio);
2700 +    BIO_pop(b64);
2701 +    BIO_free(b64);
2702 +
2703 +    get_user_info(info, sizeof(info));
2704 +    BIO_write(bfile, info, strlen(info));
2705 +    BIO_flush(bfile);
2706 +    BIO_free_all(bfile);
2707 +
2708 +    return 1;
2709 +}
2710 +
2711 +static int generate_key(const char *file)
2712 +{
2713 +    EVP_PKEY* pkey = EVP_PKEY_new();
2714 +    BIGNUM* exponent = BN_new();
2715 +    RSA* rsa = RSA_new();
2716 +    mode_t old_mask;
2717 +    FILE *f = NULL;
2718 +    int ret = 0;
2719 +
2720 +    D("generate_key '%s'\n", file);
2721 +
2722 +    if (!pkey || !exponent || !rsa) {
2723 +        D("Failed to allocate key\n");
2724 +        goto out;
2725 +    }
2726 +
2727 +    BN_set_word(exponent, RSA_F4);
2728 +    RSA_generate_key_ex(rsa, 2048, exponent, NULL);
2729 +    EVP_PKEY_set1_RSA(pkey, rsa);
2730 +
2731 +    old_mask = umask(077);
2732 +
2733 +    f = fopen(file, "w");
2734 +    if (!f) {
2735 +        D("Failed to open '%s'\n", file);
2736 +        umask(old_mask);
2737 +        goto out;
2738 +    }
2739 +
2740 +    umask(old_mask);
2741 +
2742 +    if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {
2743 +        D("Failed to write key\n");
2744 +        goto out;
2745 +    }
2746 +
2747 +    if (!write_public_keyfile(rsa, file)) {
2748 +        D("Failed to write public key\n");
2749 +        goto out;
2750 +    }
2751 +
2752 +    ret = 1;
2753 +
2754 +out:
2755 +    if (f)
2756 +        fclose(f);
2757 +    EVP_PKEY_free(pkey);
2758 +    RSA_free(rsa);
2759 +    BN_free(exponent);
2760 +    return ret;
2761 +}
2762 +
2763 +static int read_key(const char *file, struct listnode *list)
2764 +{
2765 +    struct adb_private_key *key;
2766 +    FILE *f;
2767 +
2768 +    D("read_key '%s'\n", file);
2769 +
2770 +    f = fopen(file, "r");
2771 +    if (!f) {
2772 +        D("Failed to open '%s'\n", file);
2773 +        return 0;
2774 +    }
2775 +
2776 +    key = malloc(sizeof(*key));
2777 +    if (!key) {
2778 +        D("Failed to alloc key\n");
2779 +        fclose(f);
2780 +        return 0;
2781 +    }
2782 +    key->rsa = RSA_new();
2783 +
2784 +    if (!PEM_read_RSAPrivateKey(f, &key->rsa, NULL, NULL)) {
2785 +        D("Failed to read key\n");
2786 +        fclose(f);
2787 +        RSA_free(key->rsa);
2788 +        free(key);
2789 +        return 0;
2790 +    }
2791 +
2792 +    fclose(f);
2793 +    list_add_tail(list, &key->node);
2794 +    return 1;
2795 +}
2796 +
2797 +static int get_user_keyfilepath(char *filename, size_t len)
2798 +{
2799 +    const char *format, *home;
2800 +    char android_dir[PATH_MAX];
2801 +    struct stat buf;
2802 +#ifdef _WIN32
2803 +    char path[PATH_MAX];
2804 +    home = getenv("ANDROID_SDK_HOME");
2805 +    if (!home) {
2806 +        SHGetFolderPath(NULL, CSIDL_PROFILE, NULL, 0, path);
2807 +        home = path;
2808 +    }
2809 +    format = "%s\\%s";
2810 +#else
2811 +    home = getenv("HOME");
2812 +    if (!home)
2813 +        return -1;
2814 +    format = "%s/%s";
2815 +#endif
2816 +
2817 +    D("home '%s'\n", home);
2818 +
2819 +    if (snprintf(android_dir, sizeof(android_dir), format, home,
2820 +                        ANDROID_PATH) >= (int)sizeof(android_dir))
2821 +        return -1;
2822 +
2823 +    if (stat(android_dir, &buf)) {
2824 +        if (adb_mkdir(android_dir, 0750) < 0) {
2825 +            D("Cannot mkdir '%s'", android_dir);
2826 +            return -1;
2827 +        }
2828 +    }
2829 +
2830 +    return snprintf(filename, len, format, android_dir, ADB_KEY_FILE);
2831 +}
2832 +
2833 +static int get_user_key(struct listnode *list)
2834 +{
2835 +    struct stat buf;
2836 +    char path[PATH_MAX];
2837 +    int ret;
2838 +
2839 +    ret = get_user_keyfilepath(path, sizeof(path));
2840 +    if (ret < 0 || ret >= (signed)sizeof(path)) {
2841 +        D("Error getting user key filename");
2842 +        return 0;
2843 +    }
2844 +
2845 +    D("user key '%s'\n", path);
2846 +
2847 +    if (stat(path, &buf) == -1) {
2848 +        if (!generate_key(path)) {
2849 +            D("Failed to generate new key\n");
2850 +            return 0;
2851 +        }
2852 +    }
2853 +
2854 +    return read_key(path, list);
2855 +}
2856 +
2857 +static void get_vendor_keys(struct listnode *list)
2858 +{
2859 +    const char *adb_keys_path;
2860 +    char keys_path[MAX_PAYLOAD];
2861 +    char *path;
2862 +    char *save;
2863 +    struct stat buf;
2864 +
2865 +    adb_keys_path = getenv("ADB_VENDOR_KEYS");
2866 +    if (!adb_keys_path)
2867 +        return;
2868 +    strncpy(keys_path, adb_keys_path, sizeof(keys_path));
2869 +
2870 +    path = adb_strtok_r(keys_path, ENV_PATH_SEPARATOR_STR, &save);
2871 +    while (path) {
2872 +        D("Reading: '%s'\n", path);
2873 +
2874 +        if (stat(path, &buf))
2875 +            D("Can't read '%s'\n", path);
2876 +        else if (!read_key(path, list))
2877 +            D("Failed to read '%s'\n", path);
2878 +
2879 +        path = adb_strtok_r(NULL, ENV_PATH_SEPARATOR_STR, &save);
2880 +    }
2881 +}
2882 +
2883 +int adb_auth_sign(void *node, void *token, size_t token_size, void *sig)
2884 +{
2885 +    unsigned int len;
2886 +    struct adb_private_key *key = node_to_item(node, struct adb_private_key, node);
2887 +
2888 +    if (!RSA_sign(NID_sha1, token, token_size, sig, &len, key->rsa)) {
2889 +        return 0;
2890 +    }
2891 +
2892 +    D("adb_auth_sign len=%d\n", len);
2893 +    return (int)len;
2894 +}
2895 +
2896 +void *adb_auth_nextkey(void *current)
2897 +{
2898 +    struct listnode *item;
2899 +
2900 +    if (list_empty(&key_list))
2901 +        return NULL;
2902 +
2903 +    if (!current)
2904 +        return list_head(&key_list);
2905 +
2906 +    list_for_each(item, &key_list) {
2907 +        if (item == current) {
2908 +            /* current is the last item, we tried all the keys */
2909 +            if (item->next == &key_list)
2910 +                return NULL;
2911 +            return item->next;
2912 +        }
2913 +    }
2914 +
2915 +    return NULL;
2916 +}
2917 +
2918 +int adb_auth_get_userkey(unsigned char *data, size_t len)
2919 +{
2920 +    char path[PATH_MAX];
2921 +    char *file;
2922 +    int ret;
2923 +
2924 +    ret = get_user_keyfilepath(path, sizeof(path) - 4);
2925 +    if (ret < 0 || ret >= (signed)(sizeof(path) - 4)) {
2926 +        D("Error getting user key filename");
2927 +        return 0;
2928 +    }
2929 +    strcat(path, ".pub");
2930 +
2931 +    file = load_file(path, (unsigned*)&ret);
2932 +    if (!file) {
2933 +        D("Can't load '%s'\n", path);
2934 +        return 0;
2935 +    }
2936 +
2937 +    if (len < (size_t)(ret + 1)) {
2938 +        D("%s: Content too large ret=%d\n", path, ret);
2939 +        return 0;
2940 +    }
2941 +
2942 +    memcpy(data, file, ret);
2943 +    data[ret] = '\0';
2944 +
2945 +    return ret + 1;
2946 +}
2947 +
2948 +void adb_auth_init(void)
2949 +{
2950 +    int ret;
2951 +
2952 +    D("adb_auth_init\n");
2953 +
2954 +    list_init(&key_list);
2955 +
2956 +    ret = get_user_key(&key_list);
2957 +    if (!ret) {
2958 +        D("Failed to get user key\n");
2959 +        return;
2960 +    }
2961 +
2962 +    get_vendor_keys(&key_list);
2963 +}
2964 Index: android-tools-4.2.2+git20130218/core/adbd/adb_client.c
2965 ===================================================================
2966 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2967 +++ android-tools-4.2.2+git20130218/core/adbd/adb_client.c      2013-06-18 17:12:17.000000000 -0300
2968 @@ -0,0 +1,340 @@
2969 +#include <stdio.h>
2970 +#include <stdlib.h>
2971 +#include <string.h>
2972 +#include <errno.h>
2973 +#include <limits.h>
2974 +#include <stdarg.h>
2975 +#include <zipfile/zipfile.h>
2976 +#include <sys/types.h>
2977 +#include <sys/stat.h>
2978 +
2979 +#include "sysdeps.h"
2980 +
2981 +#define  TRACE_TAG  TRACE_ADB
2982 +#include "adb_client.h"
2983 +
2984 +static transport_type __adb_transport = kTransportAny;
2985 +static const char* __adb_serial = NULL;
2986 +
2987 +static int __adb_server_port = DEFAULT_ADB_PORT;
2988 +static const char* __adb_server_name = NULL;
2989 +
2990 +void adb_set_transport(transport_type type, const char* serial)
2991 +{
2992 +    __adb_transport = type;
2993 +    __adb_serial = serial;
2994 +}
2995 +
2996 +void adb_set_tcp_specifics(int server_port)
2997 +{
2998 +    __adb_server_port = server_port;
2999 +}
3000 +
3001 +void adb_set_tcp_name(const char* hostname)
3002 +{
3003 +    __adb_server_name = hostname;
3004 +}
3005 +
3006 +int  adb_get_emulator_console_port(void)
3007 +{
3008 +    const char*   serial = __adb_serial;
3009 +    int           port;
3010 +
3011 +    if (serial == NULL) {
3012 +        /* if no specific device was specified, we need to look at */
3013 +        /* the list of connected devices, and extract an emulator  */
3014 +        /* name from it. two emulators is an error                 */
3015 +        char*  tmp = adb_query("host:devices");
3016 +        char*  p   = tmp;
3017 +        if(!tmp) {
3018 +            printf("no emulator connected\n");
3019 +            return -1;
3020 +        }
3021 +        while (*p) {
3022 +            char*  q = strchr(p, '\n');
3023 +            if (q != NULL)
3024 +                *q++ = 0;
3025 +            else
3026 +                q = p + strlen(p);
3027 +
3028 +            if (!memcmp(p, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1)) {
3029 +                if (serial != NULL) {  /* more than one emulator listed */
3030 +                    free(tmp);
3031 +                    return -2;
3032 +                }
3033 +                serial = p;
3034 +            }
3035 +
3036 +            p = q;
3037 +        }
3038 +        free(tmp);
3039 +
3040 +        if (serial == NULL)
3041 +            return -1;  /* no emulator found */
3042 +    }
3043 +    else {
3044 +        if (memcmp(serial, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1) != 0)
3045 +            return -1;  /* not an emulator */
3046 +    }
3047 +
3048 +    serial += sizeof(LOCAL_CLIENT_PREFIX)-1;
3049 +    port    = strtol(serial, NULL, 10);
3050 +    return port;
3051 +}
3052 +
3053 +static char __adb_error[256] = { 0 };
3054 +
3055 +const char *adb_error(void)
3056 +{
3057 +    return __adb_error;
3058 +}
3059 +
3060 +static int switch_socket_transport(int fd)
3061 +{
3062 +    char service[64];
3063 +    char tmp[5];
3064 +    int len;
3065 +
3066 +    if (__adb_serial)
3067 +        snprintf(service, sizeof service, "host:transport:%s", __adb_serial);
3068 +    else {
3069 +        char* transport_type = "???";
3070 +
3071 +         switch (__adb_transport) {
3072 +            case kTransportUsb:
3073 +                transport_type = "transport-usb";
3074 +                break;
3075 +            case kTransportLocal:
3076 +                transport_type = "transport-local";
3077 +                break;
3078 +            case kTransportAny:
3079 +                transport_type = "transport-any";
3080 +                break;
3081 +            case kTransportHost:
3082 +                // no switch necessary
3083 +                return 0;
3084 +                break;
3085 +        }
3086 +
3087 +        snprintf(service, sizeof service, "host:%s", transport_type);
3088 +    }
3089 +    len = strlen(service);
3090 +    snprintf(tmp, sizeof tmp, "%04x", len);
3091 +
3092 +    if(writex(fd, tmp, 4) || writex(fd, service, len)) {
3093 +        strcpy(__adb_error, "write failure during connection");
3094 +        adb_close(fd);
3095 +        return -1;
3096 +    }
3097 +    D("Switch transport in progress\n");
3098 +
3099 +    if(adb_status(fd)) {
3100 +        adb_close(fd);
3101 +        D("Switch transport failed\n");
3102 +        return -1;
3103 +    }
3104 +    D("Switch transport success\n");
3105 +    return 0;
3106 +}
3107 +
3108 +int adb_status(int fd)
3109 +{
3110 +    unsigned char buf[5];
3111 +    unsigned len;
3112 +
3113 +    if(readx(fd, buf, 4)) {
3114 +        strcpy(__adb_error, "protocol fault (no status)");
3115 +        return -1;
3116 +    }
3117 +
3118 +    if(!memcmp(buf, "OKAY", 4)) {
3119 +        return 0;
3120 +    }
3121 +
3122 +    if(memcmp(buf, "FAIL", 4)) {
3123 +        sprintf(__adb_error,
3124 +                "protocol fault (status %02x %02x %02x %02x?!)",
3125 +                buf[0], buf[1], buf[2], buf[3]);
3126 +        return -1;
3127 +    }
3128 +
3129 +    if(readx(fd, buf, 4)) {
3130 +        strcpy(__adb_error, "protocol fault (status len)");
3131 +        return -1;
3132 +    }
3133 +    buf[4] = 0;
3134 +    len = strtoul((char*)buf, 0, 16);
3135 +    if(len > 255) len = 255;
3136 +    if(readx(fd, __adb_error, len)) {
3137 +        strcpy(__adb_error, "protocol fault (status read)");
3138 +        return -1;
3139 +    }
3140 +    __adb_error[len] = 0;
3141 +    return -1;
3142 +}
3143 +
3144 +int _adb_connect(const char *service)
3145 +{
3146 +    char tmp[5];
3147 +    int len;
3148 +    int fd;
3149 +
3150 +    D("_adb_connect: %s\n", service);
3151 +    len = strlen(service);
3152 +    if((len < 1) || (len > 1024)) {
3153 +        strcpy(__adb_error, "service name too long");
3154 +        return -1;
3155 +    }
3156 +    snprintf(tmp, sizeof tmp, "%04x", len);
3157 +
3158 +    if (__adb_server_name)
3159 +        fd = socket_network_client(__adb_server_name, __adb_server_port, SOCK_STREAM);
3160 +    else
3161 +        fd = socket_loopback_client(__adb_server_port, SOCK_STREAM);
3162 +
3163 +    if(fd < 0) {
3164 +        strcpy(__adb_error, "cannot connect to daemon");
3165 +        return -2;
3166 +    }
3167 +
3168 +    if (memcmp(service,"host",4) != 0 && switch_socket_transport(fd)) {
3169 +        return -1;
3170 +    }
3171 +
3172 +    if(writex(fd, tmp, 4) || writex(fd, service, len)) {
3173 +        strcpy(__adb_error, "write failure during connection");
3174 +        adb_close(fd);
3175 +        return -1;
3176 +    }
3177 +
3178 +    if(adb_status(fd)) {
3179 +        adb_close(fd);
3180 +        return -1;
3181 +    }
3182 +
3183 +    D("_adb_connect: return fd %d\n", fd);
3184 +    return fd;
3185 +}
3186 +
3187 +int adb_connect(const char *service)
3188 +{
3189 +    // first query the adb server's version
3190 +    int fd = _adb_connect("host:version");
3191 +
3192 +    D("adb_connect: service %s\n", service);
3193 +    if(fd == -2 && __adb_server_name) {
3194 +        fprintf(stderr,"** Cannot start server on remote host\n");