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