transport.c revision 76e47e0ec84eaf7faf6f77b853ba74345875a8e3 
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#include <stdio.h>
18#include <stdlib.h>
19#include <unistd.h>
20#include <string.h>
21#include <errno.h>
22
23#include "sysdeps.h"
24
25#define   TRACE_TAG  TRACE_TRANSPORT
26#include "adb.h"
27
28static void transport_unref(atransport *t);
29
30static atransport transport_list = {
31    .next = &transport_list,
32    .prev = &transport_list,
33};
34
35ADB_MUTEX_DEFINE( transport_lock );
36
37#if ADB_TRACE
38#define MAX_DUMP_HEX_LEN 16
39static void  dump_hex( const unsigned char*  ptr, size_t  len )
40{
41    int  nn, len2 = len;
42    // Build a string instead of logging each character.
43    // MAX chars in 2 digit hex, one space, MAX chars, one '\0'.
44    char buffer[MAX_DUMP_HEX_LEN *2 + 1 + MAX_DUMP_HEX_LEN + 1 ], *pb = buffer;
45
46    if (len2 > MAX_DUMP_HEX_LEN) len2 = MAX_DUMP_HEX_LEN;
47
48    for (nn = 0; nn < len2; nn++) {
49        sprintf(pb, "%02x", ptr[nn]);
50        pb += 2;
51    }
52    sprintf(pb++, " ");
53
54    for (nn = 0; nn < len2; nn++) {
55        int  c = ptr[nn];
56        if (c < 32 || c > 127)
57            c = '.';
58        *pb++ =  c;
59    }
60    *pb++ = '\0';
61    DR("%s\n", buffer);
62}
63#endif
64
65void
66kick_transport(atransport*  t)
67{
68    if (t && !t->kicked)
69    {
70        int  kicked;
71
72        adb_mutex_lock(&transport_lock);
73        kicked = t->kicked;
74        if (!kicked)
75            t->kicked = 1;
76        adb_mutex_unlock(&transport_lock);
77
78        if (!kicked)
79            t->kick(t);
80    }
81}
82
83void
84run_transport_disconnects(atransport*  t)
85{
86    adisconnect*  dis = t->disconnects.next;
87
88    D("%s: run_transport_disconnects\n", t->serial);
89    while (dis != &t->disconnects) {
90        adisconnect*  next = dis->next;
91        dis->func( dis->opaque, t );
92        dis = next;
93    }
94}
95
96#if ADB_TRACE
97static void
98dump_packet(const char* name, const char* func, apacket* p)
99{
100    unsigned  command = p->msg.command;
101    int       len     = p->msg.data_length;
102    char      cmd[9];
103    char      arg0[12], arg1[12];
104    int       n;
105
106    for (n = 0; n < 4; n++) {
107        int  b = (command >> (n*8)) & 255;
108        if (b < 32 || b >= 127)
109            break;
110        cmd[n] = (char)b;
111    }
112    if (n == 4) {
113        cmd[4] = 0;
114    } else {
115        /* There is some non-ASCII name in the command, so dump
116            * the hexadecimal value instead */
117        snprintf(cmd, sizeof cmd, "%08x", command);
118    }
119
120    if (p->msg.arg0 < 256U)
121        snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
122    else
123        snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
124
125    if (p->msg.arg1 < 256U)
126        snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
127    else
128        snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
129
130    D("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
131        name, func, cmd, arg0, arg1, len);
132    dump_hex(p->data, len);
133}
134#endif /* ADB_TRACE */
135
136static int
137read_packet(int  fd, const char* name, apacket** ppacket)
138{
139    char *p = (char*)ppacket;  /* really read a packet address */
140    int   r;
141    int   len = sizeof(*ppacket);
142    char  buff[8];
143    if (!name) {
144        snprintf(buff, sizeof buff, "fd=%d", fd);
145        name = buff;
146    }
147    while(len > 0) {
148        r = adb_read(fd, p, len);
149        if(r > 0) {
150            len -= r;
151            p   += r;
152        } else {
153            D("%s: read_packet (fd=%d), error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
154            if((r < 0) && (errno == EINTR)) continue;
155            return -1;
156        }
157    }
158
159#if ADB_TRACE
160    if (ADB_TRACING) {
161        dump_packet(name, "from remote", *ppacket);
162    }
163#endif
164    return 0;
165}
166
167static int
168write_packet(int  fd, const char* name, apacket** ppacket)
169{
170    char *p = (char*) ppacket;  /* we really write the packet address */
171    int r, len = sizeof(ppacket);
172    char buff[8];
173    if (!name) {
174        snprintf(buff, sizeof buff, "fd=%d", fd);
175        name = buff;
176    }
177
178#if ADB_TRACE
179    if (ADB_TRACING) {
180        dump_packet(name, "to remote", *ppacket);
181    }
182#endif
183    len = sizeof(ppacket);
184    while(len > 0) {
185        r = adb_write(fd, p, len);
186        if(r > 0) {
187            len -= r;
188            p += r;
189        } else {
190            D("%s: write_packet (fd=%d) error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
191            if((r < 0) && (errno == EINTR)) continue;
192            return -1;
193        }
194    }
195    return 0;
196}
197
198static void transport_socket_events(int fd, unsigned events, void *_t)
199{
200    atransport *t = _t;
201    D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
202    if(events & FDE_READ){
203        apacket *p = 0;
204        if(read_packet(fd, t->serial, &p)){
205            D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
206        } else {
207            handle_packet(p, (atransport *) _t);
208        }
209    }
210}
211
212void send_packet(apacket *p, atransport *t)
213{
214    unsigned char *x;
215    unsigned sum;
216    unsigned count;
217
218    p->msg.magic = p->msg.command ^ 0xffffffff;
219
220    count = p->msg.data_length;
221    x = (unsigned char *) p->data;
222    sum = 0;
223    while(count-- > 0){
224        sum += *x++;
225    }
226    p->msg.data_check = sum;
227
228    print_packet("send", p);
229
230    if (t == NULL) {
231        D("Transport is null \n");
232        // Zap errno because print_packet() and other stuff have errno effect.
233        errno = 0;
234        fatal_errno("Transport is null");
235    }
236
237    if(write_packet(t->transport_socket, t->serial, &p)){
238        fatal_errno("cannot enqueue packet on transport socket");
239    }
240}
241
242/* The transport is opened by transport_register_func before
243** the input and output threads are started.
244**
245** The output thread issues a SYNC(1, token) message to let
246** the input thread know to start things up.  In the event
247** of transport IO failure, the output thread will post a
248** SYNC(0,0) message to ensure shutdown.
249**
250** The transport will not actually be closed until both
251** threads exit, but the input thread will kick the transport
252** on its way out to disconnect the underlying device.
253*/
254
255static void *output_thread(void *_t)
256{
257    atransport *t = _t;
258    apacket *p;
259
260    D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
261       t->serial, t->fd, t->sync_token + 1);
262    p = get_apacket();
263    p->msg.command = A_SYNC;
264    p->msg.arg0 = 1;
265    p->msg.arg1 = ++(t->sync_token);
266    p->msg.magic = A_SYNC ^ 0xffffffff;
267    if(write_packet(t->fd, t->serial, &p)) {
268        put_apacket(p);
269        D("%s: failed to write SYNC packet\n", t->serial);
270        goto oops;
271    }
272
273    D("%s: data pump started\n", t->serial);
274    for(;;) {
275        p = get_apacket();
276
277        if(t->read_from_remote(p, t) == 0){
278            D("%s: received remote packet, sending to transport\n",
279              t->serial);
280            if(write_packet(t->fd, t->serial, &p)){
281                put_apacket(p);
282                D("%s: failed to write apacket to transport\n", t->serial);
283                goto oops;
284            }
285        } else {
286            D("%s: remote read failed for transport\n", t->serial);
287            put_apacket(p);
288            break;
289        }
290    }
291
292    D("%s: SYNC offline for transport\n", t->serial);
293    p = get_apacket();
294    p->msg.command = A_SYNC;
295    p->msg.arg0 = 0;
296    p->msg.arg1 = 0;
297    p->msg.magic = A_SYNC ^ 0xffffffff;
298    if(write_packet(t->fd, t->serial, &p)) {
299        put_apacket(p);
300        D("%s: failed to write SYNC apacket to transport", t->serial);
301    }
302
303oops:
304    D("%s: transport output thread is exiting\n", t->serial);
305    kick_transport(t);
306    transport_unref(t);
307    return 0;
308}
309
310static void *input_thread(void *_t)
311{
312    atransport *t = _t;
313    apacket *p;
314    int active = 0;
315
316    D("%s: starting transport input thread, reading from fd %d\n",
317       t->serial, t->fd);
318
319    for(;;){
320        if(read_packet(t->fd, t->serial, &p)) {
321            D("%s: failed to read apacket from transport on fd %d\n",
322               t->serial, t->fd );
323            break;
324        }
325        if(p->msg.command == A_SYNC){
326            if(p->msg.arg0 == 0) {
327                D("%s: transport SYNC offline\n", t->serial);
328                put_apacket(p);
329                break;
330            } else {
331                if(p->msg.arg1 == t->sync_token) {
332                    D("%s: transport SYNC online\n", t->serial);
333                    active = 1;
334                } else {
335                    D("%s: transport ignoring SYNC %d != %d\n",
336                      t->serial, p->msg.arg1, t->sync_token);
337                }
338            }
339        } else {
340            if(active) {
341                D("%s: transport got packet, sending to remote\n", t->serial);
342                t->write_to_remote(p, t);
343            } else {
344                D("%s: transport ignoring packet while offline\n", t->serial);
345            }
346        }
347
348        put_apacket(p);
349    }
350
351    // this is necessary to avoid a race condition that occured when a transport closes
352    // while a client socket is still active.
353    close_all_sockets(t);
354
355    D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
356    kick_transport(t);
357    transport_unref(t);
358    return 0;
359}
360
361
362static int transport_registration_send = -1;
363static int transport_registration_recv = -1;
364static fdevent transport_registration_fde;
365
366
367#if ADB_HOST
368static int list_transports_msg(char*  buffer, size_t  bufferlen)
369{
370    char  head[5];
371    int   len;
372
373    len = list_transports(buffer+4, bufferlen-4, 0);
374    snprintf(head, sizeof(head), "%04x", len);
375    memcpy(buffer, head, 4);
376    len += 4;
377    return len;
378}
379
380/* this adds support required by the 'track-devices' service.
381 * this is used to send the content of "list_transport" to any
382 * number of client connections that want it through a single
383 * live TCP connection
384 */
385typedef struct device_tracker  device_tracker;
386struct device_tracker {
387    asocket          socket;
388    int              update_needed;
389    device_tracker*  next;
390};
391
392/* linked list of all device trackers */
393static device_tracker*   device_tracker_list;
394
395static void
396device_tracker_remove( device_tracker*  tracker )
397{
398    device_tracker**  pnode = &device_tracker_list;
399    device_tracker*   node  = *pnode;
400
401    adb_mutex_lock( &transport_lock );
402    while (node) {
403        if (node == tracker) {
404            *pnode = node->next;
405            break;
406        }
407        pnode = &node->next;
408        node  = *pnode;
409    }
410    adb_mutex_unlock( &transport_lock );
411}
412
413static void
414device_tracker_close( asocket*  socket )
415{
416    device_tracker*  tracker = (device_tracker*) socket;
417    asocket*         peer    = socket->peer;
418
419    D( "device tracker %p removed\n", tracker);
420    if (peer) {
421        peer->peer = NULL;
422        peer->close(peer);
423    }
424    device_tracker_remove(tracker);
425    free(tracker);
426}
427
428static int
429device_tracker_enqueue( asocket*  socket, apacket*  p )
430{
431    /* you can't read from a device tracker, close immediately */
432    put_apacket(p);
433    device_tracker_close(socket);
434    return -1;
435}
436
437static int
438device_tracker_send( device_tracker*  tracker,
439                     const char*      buffer,
440                     int              len )
441{
442    apacket*  p = get_apacket();
443    asocket*  peer = tracker->socket.peer;
444
445    memcpy(p->data, buffer, len);
446    p->len = len;
447    return peer->enqueue( peer, p );
448}
449
450
451static void
452device_tracker_ready( asocket*  socket )
453{
454    device_tracker*  tracker = (device_tracker*) socket;
455
456    /* we want to send the device list when the tracker connects
457    * for the first time, even if no update occured */
458    if (tracker->update_needed > 0) {
459        char  buffer[1024];
460        int   len;
461
462        tracker->update_needed = 0;
463
464        len = list_transports_msg(buffer, sizeof(buffer));
465        device_tracker_send(tracker, buffer, len);
466    }
467}
468
469
470asocket*
471create_device_tracker(void)
472{
473    device_tracker*  tracker = calloc(1,sizeof(*tracker));
474
475    if(tracker == 0) fatal("cannot allocate device tracker");
476
477    D( "device tracker %p created\n", tracker);
478
479    tracker->socket.enqueue = device_tracker_enqueue;
480    tracker->socket.ready   = device_tracker_ready;
481    tracker->socket.close   = device_tracker_close;
482    tracker->update_needed  = 1;
483
484    tracker->next       = device_tracker_list;
485    device_tracker_list = tracker;
486
487    return &tracker->socket;
488}
489
490
491/* call this function each time the transport list has changed */
492void  update_transports(void)
493{
494    char             buffer[1024];
495    int              len;
496    device_tracker*  tracker;
497
498    len = list_transports_msg(buffer, sizeof(buffer));
499
500    tracker = device_tracker_list;
501    while (tracker != NULL) {
502        device_tracker*  next = tracker->next;
503        /* note: this may destroy the tracker if the connection is closed */
504        device_tracker_send(tracker, buffer, len);
505        tracker = next;
506    }
507}
508#else
509void  update_transports(void)
510{
511    // nothing to do on the device side
512}
513#endif // ADB_HOST
514
515typedef struct tmsg tmsg;
516struct tmsg
517{
518    atransport *transport;
519    int         action;
520};
521
522static int
523transport_read_action(int  fd, struct tmsg*  m)
524{
525    char *p   = (char*)m;
526    int   len = sizeof(*m);
527    int   r;
528
529    while(len > 0) {
530        r = adb_read(fd, p, len);
531        if(r > 0) {
532            len -= r;
533            p   += r;
534        } else {
535            if((r < 0) && (errno == EINTR)) continue;
536            D("transport_read_action: on fd %d, error %d: %s\n",
537              fd, errno, strerror(errno));
538            return -1;
539        }
540    }
541    return 0;
542}
543
544static int
545transport_write_action(int  fd, struct tmsg*  m)
546{
547    char *p   = (char*)m;
548    int   len = sizeof(*m);
549    int   r;
550
551    while(len > 0) {
552        r = adb_write(fd, p, len);
553        if(r > 0) {
554            len -= r;
555            p   += r;
556        } else {
557            if((r < 0) && (errno == EINTR)) continue;
558            D("transport_write_action: on fd %d, error %d: %s\n",
559              fd, errno, strerror(errno));
560            return -1;
561        }
562    }
563    return 0;
564}
565
566static void transport_registration_func(int _fd, unsigned ev, void *data)
567{
568    tmsg m;
569    adb_thread_t output_thread_ptr;
570    adb_thread_t input_thread_ptr;
571    int s[2];
572    atransport *t;
573
574    if(!(ev & FDE_READ)) {
575        return;
576    }
577
578    if(transport_read_action(_fd, &m)) {
579        fatal_errno("cannot read transport registration socket");
580    }
581
582    t = m.transport;
583
584    if(m.action == 0){
585        D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
586
587            /* IMPORTANT: the remove closes one half of the
588            ** socket pair.  The close closes the other half.
589            */
590        fdevent_remove(&(t->transport_fde));
591        adb_close(t->fd);
592
593        adb_mutex_lock(&transport_lock);
594        t->next->prev = t->prev;
595        t->prev->next = t->next;
596        adb_mutex_unlock(&transport_lock);
597
598        run_transport_disconnects(t);
599
600        if (t->product)
601            free(t->product);
602        if (t->serial)
603            free(t->serial);
604        if (t->devpath)
605            free(t->devpath);
606
607        memset(t,0xee,sizeof(atransport));
608        free(t);
609
610        update_transports();
611        return;
612    }
613
614    /* don't create transport threads for inaccessible devices */
615    if (t->connection_state != CS_NOPERM) {
616        /* initial references are the two threads */
617        t->ref_count = 2;
618
619        if(adb_socketpair(s)) {
620            fatal_errno("cannot open transport socketpair");
621        }
622
623        D("transport: %s (%d,%d) starting\n", t->serial, s[0], s[1]);
624
625        t->transport_socket = s[0];
626        t->fd = s[1];
627
628        fdevent_install(&(t->transport_fde),
629                        t->transport_socket,
630                        transport_socket_events,
631                        t);
632
633        fdevent_set(&(t->transport_fde), FDE_READ);
634
635        if(adb_thread_create(&input_thread_ptr, input_thread, t)){
636            fatal_errno("cannot create input thread");
637        }
638
639        if(adb_thread_create(&output_thread_ptr, output_thread, t)){
640            fatal_errno("cannot create output thread");
641        }
642    }
643
644        /* put us on the master device list */
645    adb_mutex_lock(&transport_lock);
646    t->next = &transport_list;
647    t->prev = transport_list.prev;
648    t->next->prev = t;
649    t->prev->next = t;
650    adb_mutex_unlock(&transport_lock);
651
652    t->disconnects.next = t->disconnects.prev = &t->disconnects;
653
654    update_transports();
655}
656
657void init_transport_registration(void)
658{
659    int s[2];
660
661    if(adb_socketpair(s)){
662        fatal_errno("cannot open transport registration socketpair");
663    }
664
665    transport_registration_send = s[0];
666    transport_registration_recv = s[1];
667
668    fdevent_install(&transport_registration_fde,
669                    transport_registration_recv,
670                    transport_registration_func,
671                    0);
672
673    fdevent_set(&transport_registration_fde, FDE_READ);
674}
675
676/* the fdevent select pump is single threaded */
677static void register_transport(atransport *transport)
678{
679    tmsg m;
680    m.transport = transport;
681    m.action = 1;
682    D("transport: %s registered\n", transport->serial);
683    if(transport_write_action(transport_registration_send, &m)) {
684        fatal_errno("cannot write transport registration socket\n");
685    }
686}
687
688static void remove_transport(atransport *transport)
689{
690    tmsg m;
691    m.transport = transport;
692    m.action = 0;
693    D("transport: %s removed\n", transport->serial);
694    if(transport_write_action(transport_registration_send, &m)) {
695        fatal_errno("cannot write transport registration socket\n");
696    }
697}
698
699
700static void transport_unref_locked(atransport *t)
701{
702    t->ref_count--;
703    if (t->ref_count == 0) {
704        D("transport: %s unref (kicking and closing)\n", t->serial);
705        if (!t->kicked) {
706            t->kicked = 1;
707            t->kick(t);
708        }
709        t->close(t);
710        remove_transport(t);
711    } else {
712        D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
713    }
714}
715
716static void transport_unref(atransport *t)
717{
718    if (t) {
719        adb_mutex_lock(&transport_lock);
720        transport_unref_locked(t);
721        adb_mutex_unlock(&transport_lock);
722    }
723}
724
725void add_transport_disconnect(atransport*  t, adisconnect*  dis)
726{
727    adb_mutex_lock(&transport_lock);
728    dis->next       = &t->disconnects;
729    dis->prev       = dis->next->prev;
730    dis->prev->next = dis;
731    dis->next->prev = dis;
732    adb_mutex_unlock(&transport_lock);
733}
734
735void remove_transport_disconnect(atransport*  t, adisconnect*  dis)
736{
737    dis->prev->next = dis->next;
738    dis->next->prev = dis->prev;
739    dis->next = dis->prev = dis;
740}
741
742
743atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out)
744{
745    atransport *t;
746    atransport *result = NULL;
747    int ambiguous = 0;
748
749retry:
750    if (error_out)
751        *error_out = "device not found";
752
753    adb_mutex_lock(&transport_lock);
754    for (t = transport_list.next; t != &transport_list; t = t->next) {
755        if (t->connection_state == CS_NOPERM) {
756        if (error_out)
757            *error_out = "insufficient permissions for device";
758            continue;
759        }
760
761        /* check for matching serial number */
762        if (serial) {
763            if (t->serial && !strcmp(serial, t->serial)) {
764                result = t;
765                break;
766            }
767            if (t->devpath && !strcmp(serial, t->devpath)) {
768                result = t;
769                break;
770            }
771        } else {
772            if (ttype == kTransportUsb && t->type == kTransportUsb) {
773                if (result) {
774                    if (error_out)
775                        *error_out = "more than one device";
776                    ambiguous = 1;
777                    result = NULL;
778                    break;
779                }
780                result = t;
781            } else if (ttype == kTransportLocal && t->type == kTransportLocal) {
782                if (result) {
783                    if (error_out)
784                        *error_out = "more than one emulator";
785                    ambiguous = 1;
786                    result = NULL;
787                    break;
788                }
789                result = t;
790            } else if (ttype == kTransportAny) {
791                if (result) {
792                    if (error_out)
793                        *error_out = "more than one device and emulator";
794                    ambiguous = 1;
795                    result = NULL;
796                    break;
797                }
798                result = t;
799            }
800        }
801    }
802    adb_mutex_unlock(&transport_lock);
803
804    if (result) {
805         /* offline devices are ignored -- they are either being born or dying */
806        if (result && result->connection_state == CS_OFFLINE) {
807            if (error_out)
808                *error_out = "device offline";
809            result = NULL;
810        }
811         /* check for required connection state */
812        if (result && state != CS_ANY && result->connection_state != state) {
813            if (error_out)
814                *error_out = "invalid device state";
815            result = NULL;
816        }
817    }
818
819    if (result) {
820        /* found one that we can take */
821        if (error_out)
822            *error_out = NULL;
823    } else if (state != CS_ANY && (serial || !ambiguous)) {
824        adb_sleep_ms(1000);
825        goto retry;
826    }
827
828    return result;
829}
830
831#if ADB_HOST
832static const char *statename(atransport *t)
833{
834    switch(t->connection_state){
835    case CS_OFFLINE: return "offline";
836    case CS_BOOTLOADER: return "bootloader";
837    case CS_DEVICE: return "device";
838    case CS_HOST: return "host";
839    case CS_RECOVERY: return "recovery";
840    case CS_SIDELOAD: return "sideload";
841    case CS_NOPERM: return "no permissions";
842    default: return "unknown";
843    }
844}
845
846int list_transports(char *buf, size_t  bufsize, int show_devpath)
847{
848    char*       p   = buf;
849    char*       end = buf + bufsize;
850    int         len;
851    atransport *t;
852
853        /* XXX OVERRUN PROBLEMS XXX */
854    adb_mutex_lock(&transport_lock);
855    for(t = transport_list.next; t != &transport_list; t = t->next) {
856        const char* serial = t->serial;
857        if (!serial || !serial[0])
858            serial = "????????????";
859        if (show_devpath) {
860            const char* devpath = t->devpath;
861            if (!devpath || !devpath[0])
862                devpath = "????????????";
863            len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, devpath, statename(t));
864        } else
865            len = snprintf(p, end - p, "%s\t%s\n", serial, statename(t));
866
867        if (p + len >= end) {
868            /* discard last line if buffer is too short */
869            break;
870        }
871        p += len;
872    }
873    p[0] = 0;
874    adb_mutex_unlock(&transport_lock);
875    return p - buf;
876}
877
878
879/* hack for osx */
880void close_usb_devices()
881{
882    atransport *t;
883
884    adb_mutex_lock(&transport_lock);
885    for(t = transport_list.next; t != &transport_list; t = t->next) {
886        if ( !t->kicked ) {
887            t->kicked = 1;
888            t->kick(t);
889        }
890    }
891    adb_mutex_unlock(&transport_lock);
892}
893#endif // ADB_HOST
894
895void register_socket_transport(int s, const char *serial, int port, int local)
896{
897    atransport *t = calloc(1, sizeof(atransport));
898    char buff[32];
899
900    if (!serial) {
901        snprintf(buff, sizeof buff, "T-%p", t);
902        serial = buff;
903    }
904    D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
905    if ( init_socket_transport(t, s, port, local) < 0 ) {
906        adb_close(s);
907        free(t);
908        return;
909    }
910    if(serial) {
911        t->serial = strdup(serial);
912    }
913    register_transport(t);
914}
915
916#if ADB_HOST
917atransport *find_transport(const char *serial)
918{
919    atransport *t;
920
921    adb_mutex_lock(&transport_lock);
922    for(t = transport_list.next; t != &transport_list; t = t->next) {
923        if (t->serial && !strcmp(serial, t->serial)) {
924            break;
925        }
926        if (t->devpath && !strcmp(serial, t->devpath)) {
927            break;
928        }
929     }
930    adb_mutex_unlock(&transport_lock);
931
932    if (t != &transport_list)
933        return t;
934    else
935        return 0;
936}
937
938void unregister_transport(atransport *t)
939{
940    adb_mutex_lock(&transport_lock);
941    t->next->prev = t->prev;
942    t->prev->next = t->next;
943    adb_mutex_unlock(&transport_lock);
944
945    kick_transport(t);
946    transport_unref(t);
947}
948
949// unregisters all non-emulator TCP transports
950void unregister_all_tcp_transports()
951{
952    atransport *t, *next;
953    adb_mutex_lock(&transport_lock);
954    for (t = transport_list.next; t != &transport_list; t = next) {
955        next = t->next;
956        if (t->type == kTransportLocal && t->adb_port == 0) {
957            t->next->prev = t->prev;
958            t->prev->next = next;
959            // we cannot call kick_transport when holding transport_lock
960            if (!t->kicked)
961            {
962                t->kicked = 1;
963                t->kick(t);
964            }
965            transport_unref_locked(t);
966        }
967     }
968
969    adb_mutex_unlock(&transport_lock);
970}
971
972#endif
973
974void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable)
975{
976    atransport *t = calloc(1, sizeof(atransport));
977    D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
978      serial ? serial : "");
979    init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM));
980    if(serial) {
981        t->serial = strdup(serial);
982    }
983    if(devpath) {
984        t->devpath = strdup(devpath);
985    }
986    register_transport(t);
987}
988
989/* this should only be used for transports with connection_state == CS_NOPERM */
990void unregister_usb_transport(usb_handle *usb)
991{
992    atransport *t;
993    adb_mutex_lock(&transport_lock);
994    for(t = transport_list.next; t != &transport_list; t = t->next) {
995        if (t->usb == usb && t->connection_state == CS_NOPERM) {
996            t->next->prev = t->prev;
997            t->prev->next = t->next;
998            break;
999        }
1000     }
1001    adb_mutex_unlock(&transport_lock);
1002}
1003
1004#undef TRACE_TAG
1005#define TRACE_TAG  TRACE_RWX
1006
1007int readx(int fd, void *ptr, size_t len)
1008{
1009    char *p = ptr;
1010    int r;
1011#if ADB_TRACE
1012    int  len0 = len;
1013#endif
1014    D("readx: fd=%d wanted=%d\n", fd, (int)len);
1015    while(len > 0) {
1016        r = adb_read(fd, p, len);
1017        if(r > 0) {
1018            len -= r;
1019            p += r;
1020        } else {
1021            if (r < 0) {
1022                D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno));
1023                if (errno == EINTR)
1024                    continue;
1025            } else {
1026                D("readx: fd=%d disconnected\n", fd);
1027            }
1028            return -1;
1029        }
1030    }
1031
1032#if ADB_TRACE
1033    D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len);
1034    dump_hex( ptr, len0 );
1035#endif
1036    return 0;
1037}
1038
1039int writex(int fd, const void *ptr, size_t len)
1040{
1041    char *p = (char*) ptr;
1042    int r;
1043
1044#if ADB_TRACE
1045    D("writex: fd=%d len=%d: ", fd, (int)len);
1046    dump_hex( ptr, len );
1047#endif
1048    while(len > 0) {
1049        r = adb_write(fd, p, len);
1050        if(r > 0) {
1051            len -= r;
1052            p += r;
1053        } else {
1054            if (r < 0) {
1055                D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno));
1056                if (errno == EINTR)
1057                    continue;
1058            } else {
1059                D("writex: fd=%d disconnected\n", fd);
1060            }
1061            return -1;
1062        }
1063    }
1064    return 0;
1065}
1066
1067int check_header(apacket *p)
1068{
1069    if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1070        D("check_header(): invalid magic\n");
1071        return -1;
1072    }
1073
1074    if(p->msg.data_length > MAX_PAYLOAD) {
1075        D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length);
1076        return -1;
1077    }
1078
1079    return 0;
1080}
1081
1082int check_data(apacket *p)
1083{
1084    unsigned count, sum;
1085    unsigned char *x;
1086
1087    count = p->msg.data_length;
1088    x = p->data;
1089    sum = 0;
1090    while(count-- > 0) {
1091        sum += *x++;
1092    }
1093
1094    if(sum != p->msg.data_check) {
1095        return -1;
1096    } else {
1097        return 0;
1098    }
1099}
1100