blob: 70fc58ed12e8fc848f8c394ddd2a4c54ada64e64 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#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
JP Abgrall408fa572011-03-16 15:57:42 -070038#define MAX_DUMP_HEX_LEN 16
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080039static void dump_hex( const unsigned char* ptr, size_t len )
40{
41 int nn, len2 = len;
JP Abgrall408fa572011-03-16 15:57:42 -070042 // 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;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080045
JP Abgrall408fa572011-03-16 15:57:42 -070046 if (len2 > MAX_DUMP_HEX_LEN) len2 = MAX_DUMP_HEX_LEN;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080047
JP Abgrall408fa572011-03-16 15:57:42 -070048 for (nn = 0; nn < len2; nn++) {
49 sprintf(pb, "%02x", ptr[nn]);
50 pb += 2;
51 }
52 sprintf(pb++, " ");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080053
54 for (nn = 0; nn < len2; nn++) {
55 int c = ptr[nn];
56 if (c < 32 || c > 127)
57 c = '.';
JP Abgrall408fa572011-03-16 15:57:42 -070058 *pb++ = c;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080059 }
JP Abgrall408fa572011-03-16 15:57:42 -070060 *pb++ = '\0';
61 DR("%s\n", buffer);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080062}
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
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010088 D("%s: run_transport_disconnects\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080089 while (dis != &t->disconnects) {
90 adisconnect* next = dis->next;
91 dis->func( dis->opaque, t );
92 dis = next;
93 }
94}
95
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010096#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
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800136static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100137read_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800138{
139 char *p = (char*)ppacket; /* really read a packet address */
140 int r;
141 int len = sizeof(*ppacket);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100142 char buff[8];
143 if (!name) {
144 snprintf(buff, sizeof buff, "fd=%d", fd);
145 name = buff;
146 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800147 while(len > 0) {
148 r = adb_read(fd, p, len);
149 if(r > 0) {
150 len -= r;
151 p += r;
152 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100153 D("%s: read_packet (fd=%d), error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800154 if((r < 0) && (errno == EINTR)) continue;
155 return -1;
156 }
157 }
158
159#if ADB_TRACE
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100160 if (ADB_TRACING) {
161 dump_packet(name, "from remote", *ppacket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800162 }
163#endif
164 return 0;
165}
166
167static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100168write_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800169{
170 char *p = (char*) ppacket; /* we really write the packet address */
171 int r, len = sizeof(ppacket);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100172 char buff[8];
173 if (!name) {
174 snprintf(buff, sizeof buff, "fd=%d", fd);
175 name = buff;
176 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800177
178#if ADB_TRACE
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100179 if (ADB_TRACING) {
180 dump_packet(name, "to remote", *ppacket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800181 }
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 {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100190 D("%s: write_packet (fd=%d) error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800191 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{
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100200 atransport *t = _t;
JP Abgrall408fa572011-03-16 15:57:42 -0700201 D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800202 if(events & FDE_READ){
203 apacket *p = 0;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100204 if(read_packet(fd, t->serial, &p)){
205 D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800206 } 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) {
JP Abgrall0e7c4272011-02-23 18:44:39 -0800231 D("Transport is null \n");
JP Abgrall408fa572011-03-16 15:57:42 -0700232 // Zap errno because print_packet() and other stuff have errno effect.
233 errno = 0;
234 fatal_errno("Transport is null");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800235 }
236
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100237 if(write_packet(t->transport_socket, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800238 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
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100260 D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
261 t->serial, t->fd, t->sync_token + 1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800262 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100267 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800268 put_apacket(p);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100269 D("%s: failed to write SYNC packet\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800270 goto oops;
271 }
272
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100273 D("%s: data pump started\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800274 for(;;) {
275 p = get_apacket();
276
277 if(t->read_from_remote(p, t) == 0){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100278 D("%s: received remote packet, sending to transport\n",
279 t->serial);
280 if(write_packet(t->fd, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800281 put_apacket(p);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100282 D("%s: failed to write apacket to transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800283 goto oops;
284 }
285 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100286 D("%s: remote read failed for transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800287 put_apacket(p);
288 break;
289 }
290 }
291
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100292 D("%s: SYNC offline for transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800293 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100298 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800299 put_apacket(p);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100300 D("%s: failed to write SYNC apacket to transport", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800301 }
302
303oops:
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100304 D("%s: transport output thread is exiting\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800305 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
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100316 D("%s: starting transport input thread, reading from fd %d\n",
317 t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800318
319 for(;;){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100320 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 );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800323 break;
324 }
325 if(p->msg.command == A_SYNC){
326 if(p->msg.arg0 == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100327 D("%s: transport SYNC offline\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800328 put_apacket(p);
329 break;
330 } else {
331 if(p->msg.arg1 == t->sync_token) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100332 D("%s: transport SYNC online\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800333 active = 1;
334 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100335 D("%s: transport ignoring SYNC %d != %d\n",
336 t->serial, p->msg.arg1, t->sync_token);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800337 }
338 }
339 } else {
340 if(active) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100341 D("%s: transport got packet, sending to remote\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800342 t->write_to_remote(p, t);
343 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100344 D("%s: transport ignoring packet while offline\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800345 }
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
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100355 D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800356 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
Scott Andersone109d262012-04-20 11:21:14 -0700373 len = list_transports(buffer+4, bufferlen-4, 0);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800374 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100536 D("transport_read_action: on fd %d, error %d: %s\n",
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800537 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100558 D("transport_write_action: on fd %d, error %d: %s\n",
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800559 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){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100585 D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800586
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);
Scott Andersone109d262012-04-20 11:21:14 -0700604 if (t->devpath)
605 free(t->devpath);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800606
607 memset(t,0xee,sizeof(atransport));
608 free(t);
609
610 update_transports();
611 return;
612 }
613
Mike Lockwood0927bf92009-08-08 12:37:44 -0400614 /* don't create transport threads for inaccessible devices */
615 if (t->connection_state != CS_NOPERM) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800616 /* initial references are the two threads */
Mike Lockwood0927bf92009-08-08 12:37:44 -0400617 t->ref_count = 2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800618
Mike Lockwood0927bf92009-08-08 12:37:44 -0400619 if(adb_socketpair(s)) {
620 fatal_errno("cannot open transport socketpair");
621 }
622
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100623 D("transport: %s (%d,%d) starting\n", t->serial, s[0], s[1]);
Mike Lockwood0927bf92009-08-08 12:37:44 -0400624
625 t->transport_socket = s[0];
626 t->fd = s[1];
627
Mike Lockwood0927bf92009-08-08 12:37:44 -0400628 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 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800642 }
643
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800644 /* 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
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800652 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100682 D("transport: %s registered\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800683 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;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100693 D("transport: %s removed\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800694 if(transport_write_action(transport_registration_send, &m)) {
695 fatal_errno("cannot write transport registration socket\n");
696 }
697}
698
699
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400700static void transport_unref_locked(atransport *t)
701{
702 t->ref_count--;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400703 if (t->ref_count == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100704 D("transport: %s unref (kicking and closing)\n", t->serial);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400705 if (!t->kicked) {
706 t->kicked = 1;
707 t->kick(t);
708 }
709 t->close(t);
710 remove_transport(t);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100711 } else {
712 D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400713 }
714}
715
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800716static void transport_unref(atransport *t)
717{
718 if (t) {
719 adb_mutex_lock(&transport_lock);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400720 transport_unref_locked(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800721 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) {
Mike Lockwood37d31112009-08-08 13:53:16 -0400755 if (t->connection_state == CS_NOPERM) {
756 if (error_out)
757 *error_out = "insufficient permissions for device";
758 continue;
759 }
Mike Lockwood0927bf92009-08-08 12:37:44 -0400760
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800761 /* check for matching serial number */
762 if (serial) {
763 if (t->serial && !strcmp(serial, t->serial)) {
764 result = t;
765 break;
766 }
Scott Andersone109d262012-04-20 11:21:14 -0700767 if (t->devpath && !strcmp(serial, t->devpath)) {
768 result = t;
769 break;
770 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800771 } 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 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800811 /* 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";
Mike Lockwood0927bf92009-08-08 12:37:44 -0400840 case CS_NOPERM: return "no permissions";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800841 default: return "unknown";
842 }
843}
844
Scott Andersone109d262012-04-20 11:21:14 -0700845int list_transports(char *buf, size_t bufsize, int show_devpath)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800846{
847 char* p = buf;
848 char* end = buf + bufsize;
849 int len;
850 atransport *t;
851
852 /* XXX OVERRUN PROBLEMS XXX */
853 adb_mutex_lock(&transport_lock);
854 for(t = transport_list.next; t != &transport_list; t = t->next) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400855 const char* serial = t->serial;
856 if (!serial || !serial[0])
857 serial = "????????????";
Scott Andersone109d262012-04-20 11:21:14 -0700858 if (show_devpath) {
859 const char* devpath = t->devpath;
860 if (!devpath || !devpath[0])
861 devpath = "????????????";
862 len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, devpath, statename(t));
863 } else
864 len = snprintf(p, end - p, "%s\t%s\n", serial, statename(t));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800865
866 if (p + len >= end) {
867 /* discard last line if buffer is too short */
868 break;
869 }
870 p += len;
871 }
872 p[0] = 0;
873 adb_mutex_unlock(&transport_lock);
874 return p - buf;
875}
876
877
878/* hack for osx */
879void close_usb_devices()
880{
881 atransport *t;
882
883 adb_mutex_lock(&transport_lock);
884 for(t = transport_list.next; t != &transport_list; t = t->next) {
885 if ( !t->kicked ) {
886 t->kicked = 1;
887 t->kick(t);
888 }
889 }
890 adb_mutex_unlock(&transport_lock);
891}
892#endif // ADB_HOST
893
Mike Lockwoodff196702009-08-24 15:58:40 -0700894void register_socket_transport(int s, const char *serial, int port, int local)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800895{
896 atransport *t = calloc(1, sizeof(atransport));
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100897 char buff[32];
898
899 if (!serial) {
900 snprintf(buff, sizeof buff, "T-%p", t);
901 serial = buff;
902 }
903 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
Mike Lockwoodff196702009-08-24 15:58:40 -0700904 if ( init_socket_transport(t, s, port, local) < 0 ) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800905 adb_close(s);
906 free(t);
907 return;
908 }
909 if(serial) {
910 t->serial = strdup(serial);
911 }
912 register_transport(t);
913}
914
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400915#if ADB_HOST
916atransport *find_transport(const char *serial)
917{
918 atransport *t;
919
920 adb_mutex_lock(&transport_lock);
921 for(t = transport_list.next; t != &transport_list; t = t->next) {
922 if (t->serial && !strcmp(serial, t->serial)) {
923 break;
924 }
Scott Andersone109d262012-04-20 11:21:14 -0700925 if (t->devpath && !strcmp(serial, t->devpath)) {
926 break;
927 }
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400928 }
929 adb_mutex_unlock(&transport_lock);
930
931 if (t != &transport_list)
932 return t;
933 else
934 return 0;
935}
936
937void unregister_transport(atransport *t)
938{
939 adb_mutex_lock(&transport_lock);
940 t->next->prev = t->prev;
941 t->prev->next = t->next;
942 adb_mutex_unlock(&transport_lock);
943
944 kick_transport(t);
945 transport_unref(t);
946}
947
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400948// unregisters all non-emulator TCP transports
949void unregister_all_tcp_transports()
950{
951 atransport *t, *next;
952 adb_mutex_lock(&transport_lock);
953 for (t = transport_list.next; t != &transport_list; t = next) {
954 next = t->next;
955 if (t->type == kTransportLocal && t->adb_port == 0) {
956 t->next->prev = t->prev;
957 t->prev->next = next;
958 // we cannot call kick_transport when holding transport_lock
959 if (!t->kicked)
960 {
961 t->kicked = 1;
962 t->kick(t);
963 }
964 transport_unref_locked(t);
965 }
966 }
967
968 adb_mutex_unlock(&transport_lock);
969}
970
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400971#endif
972
Scott Andersone109d262012-04-20 11:21:14 -0700973void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800974{
975 atransport *t = calloc(1, sizeof(atransport));
976 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
977 serial ? serial : "");
Mike Lockwood0927bf92009-08-08 12:37:44 -0400978 init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800979 if(serial) {
980 t->serial = strdup(serial);
981 }
Scott Andersone109d262012-04-20 11:21:14 -0700982 if(devpath) {
983 t->devpath = strdup(devpath);
984 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800985 register_transport(t);
986}
987
Mike Lockwood0927bf92009-08-08 12:37:44 -0400988/* this should only be used for transports with connection_state == CS_NOPERM */
989void unregister_usb_transport(usb_handle *usb)
990{
991 atransport *t;
992 adb_mutex_lock(&transport_lock);
993 for(t = transport_list.next; t != &transport_list; t = t->next) {
994 if (t->usb == usb && t->connection_state == CS_NOPERM) {
995 t->next->prev = t->prev;
996 t->prev->next = t->next;
997 break;
998 }
999 }
1000 adb_mutex_unlock(&transport_lock);
1001}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001002
1003#undef TRACE_TAG
1004#define TRACE_TAG TRACE_RWX
1005
1006int readx(int fd, void *ptr, size_t len)
1007{
1008 char *p = ptr;
1009 int r;
1010#if ADB_TRACE
1011 int len0 = len;
1012#endif
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001013 D("readx: fd=%d wanted=%d\n", fd, (int)len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001014 while(len > 0) {
1015 r = adb_read(fd, p, len);
1016 if(r > 0) {
1017 len -= r;
1018 p += r;
1019 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001020 if (r < 0) {
1021 D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno));
1022 if (errno == EINTR)
1023 continue;
1024 } else {
1025 D("readx: fd=%d disconnected\n", fd);
1026 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001027 return -1;
1028 }
1029 }
1030
1031#if ADB_TRACE
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001032 D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001033 dump_hex( ptr, len0 );
1034#endif
1035 return 0;
1036}
1037
1038int writex(int fd, const void *ptr, size_t len)
1039{
1040 char *p = (char*) ptr;
1041 int r;
1042
1043#if ADB_TRACE
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001044 D("writex: fd=%d len=%d: ", fd, (int)len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001045 dump_hex( ptr, len );
1046#endif
1047 while(len > 0) {
1048 r = adb_write(fd, p, len);
1049 if(r > 0) {
1050 len -= r;
1051 p += r;
1052 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001053 if (r < 0) {
1054 D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno));
1055 if (errno == EINTR)
1056 continue;
1057 } else {
1058 D("writex: fd=%d disconnected\n", fd);
1059 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001060 return -1;
1061 }
1062 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001063 return 0;
1064}
1065
1066int check_header(apacket *p)
1067{
1068 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1069 D("check_header(): invalid magic\n");
1070 return -1;
1071 }
1072
1073 if(p->msg.data_length > MAX_PAYLOAD) {
1074 D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length);
1075 return -1;
1076 }
1077
1078 return 0;
1079}
1080
1081int check_data(apacket *p)
1082{
1083 unsigned count, sum;
1084 unsigned char *x;
1085
1086 count = p->msg.data_length;
1087 x = p->data;
1088 sum = 0;
1089 while(count-- > 0) {
1090 sum += *x++;
1091 }
1092
1093 if(sum != p->msg.data_check) {
1094 return -1;
1095 } else {
1096 return 0;
1097 }
1098}