blob: afdab86fa3575a7f6fba4a9d228463341b77cd57 [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
Dan Albert33134262015-03-19 15:21:08 -070017#define TRACE_TAG TRACE_TRANSPORT
Dan Albert76649012015-02-24 15:51:19 -080018
Dan Albert33134262015-03-19 15:21:08 -070019#include "sysdeps.h"
Dan Albert76649012015-02-24 15:51:19 -080020#include "transport.h"
21
Dan Albert055f1aa2015-02-20 17:24:58 -080022#include <ctype.h>
Dan Albert76649012015-02-24 15:51:19 -080023#include <errno.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080024#include <stdio.h>
25#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080026#include <string.h>
Dan Albert76649012015-02-24 15:51:19 -080027#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080028
Dan Albertc7915a32015-05-18 16:46:31 -070029#include <list>
30
Elliott Hughese67f1f82015-04-30 17:32:03 -070031#include <base/stringprintf.h>
Dan Albert1792c232015-05-18 13:06:53 -070032#include <base/strings.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070033
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080034#include "adb.h"
Elliott Hughese67f1f82015-04-30 17:32:03 -070035#include "adb_utils.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080036
37static void transport_unref(atransport *t);
38
Dan Albertc7915a32015-05-18 16:46:31 -070039static std::list<atransport*> transport_list;
40static std::list<atransport*> pending_list;
Benoit Goby1c45ee92013-03-29 18:22:36 -070041
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042ADB_MUTEX_DEFINE( transport_lock );
43
Dan Albert055f1aa2015-02-20 17:24:58 -080044void kick_transport(atransport* t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080045{
46 if (t && !t->kicked)
47 {
48 int kicked;
49
50 adb_mutex_lock(&transport_lock);
51 kicked = t->kicked;
52 if (!kicked)
53 t->kicked = 1;
54 adb_mutex_unlock(&transport_lock);
55
56 if (!kicked)
57 t->kick(t);
58 }
59}
60
Dan Albert055f1aa2015-02-20 17:24:58 -080061// Each atransport contains a list of adisconnects (t->disconnects).
62// An adisconnect contains a link to the next/prev adisconnect, a function
63// pointer to a disconnect callback which takes a void* piece of user data and
64// the atransport, and some user data for the callback (helpfully named
65// "opaque").
66//
67// The list is circular. New items are added to the entry member of the list
68// (t->disconnects) by add_transport_disconnect.
69//
70// run_transport_disconnects invokes each function in the list.
71//
72// Gotchas:
73// * run_transport_disconnects assumes that t->disconnects is non-null, so
74// this can't be run on a zeroed atransport.
75// * The callbacks in this list are not removed when called, and this function
76// is not guarded against running more than once. As such, ensure that this
77// function is not called multiple times on the same atransport.
78// TODO(danalbert): Just fix this so that it is guarded once you have tests.
79void run_transport_disconnects(atransport* t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080080{
81 adisconnect* dis = t->disconnects.next;
82
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010083 D("%s: run_transport_disconnects\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080084 while (dis != &t->disconnects) {
85 adisconnect* next = dis->next;
86 dis->func( dis->opaque, t );
87 dis = next;
88 }
89}
90
Elliott Hughese67f1f82015-04-30 17:32:03 -070091static void dump_packet(const char* name, const char* func, apacket* p) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010092 unsigned command = p->msg.command;
93 int len = p->msg.data_length;
94 char cmd[9];
95 char arg0[12], arg1[12];
96 int n;
97
98 for (n = 0; n < 4; n++) {
99 int b = (command >> (n*8)) & 255;
100 if (b < 32 || b >= 127)
101 break;
102 cmd[n] = (char)b;
103 }
104 if (n == 4) {
105 cmd[4] = 0;
106 } else {
107 /* There is some non-ASCII name in the command, so dump
108 * the hexadecimal value instead */
109 snprintf(cmd, sizeof cmd, "%08x", command);
110 }
111
112 if (p->msg.arg0 < 256U)
113 snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
114 else
115 snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
116
117 if (p->msg.arg1 < 256U)
118 snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
119 else
120 snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
121
122 D("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
123 name, func, cmd, arg0, arg1, len);
124 dump_hex(p->data, len);
125}
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100126
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800127static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100128read_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800129{
Yabin Cui62641292015-07-30 19:58:10 -0700130 char buff[8];
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100131 if (!name) {
132 snprintf(buff, sizeof buff, "fd=%d", fd);
133 name = buff;
134 }
Yabin Cui62641292015-07-30 19:58:10 -0700135 char* p = reinterpret_cast<char*>(ppacket); /* really read a packet address */
136 int len = sizeof(apacket*);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800137 while(len > 0) {
Yabin Cui62641292015-07-30 19:58:10 -0700138 int r = adb_read(fd, p, len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800139 if(r > 0) {
140 len -= r;
Yabin Cui62641292015-07-30 19:58:10 -0700141 p += r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800142 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700143 D("%s: read_packet (fd=%d), error ret=%d: %s\n", name, fd, r, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800144 return -1;
145 }
146 }
147
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100148 if (ADB_TRACING) {
149 dump_packet(name, "from remote", *ppacket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800150 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800151 return 0;
152}
153
154static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100155write_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800156{
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100157 char buff[8];
158 if (!name) {
159 snprintf(buff, sizeof buff, "fd=%d", fd);
160 name = buff;
161 }
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100162 if (ADB_TRACING) {
163 dump_packet(name, "to remote", *ppacket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800164 }
Yabin Cui62641292015-07-30 19:58:10 -0700165 char* p = reinterpret_cast<char*>(ppacket); /* we really write the packet address */
166 int len = sizeof(apacket*);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800167 while(len > 0) {
Yabin Cui62641292015-07-30 19:58:10 -0700168 int r = adb_write(fd, p, len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800169 if(r > 0) {
170 len -= r;
171 p += r;
172 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700173 D("%s: write_packet (fd=%d) error ret=%d: %s\n", name, fd, r, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800174 return -1;
175 }
176 }
177 return 0;
178}
179
180static void transport_socket_events(int fd, unsigned events, void *_t)
181{
Dan Albertbac34742015-02-25 17:51:28 -0800182 atransport *t = reinterpret_cast<atransport*>(_t);
JP Abgrall408fa572011-03-16 15:57:42 -0700183 D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800184 if(events & FDE_READ){
185 apacket *p = 0;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100186 if(read_packet(fd, t->serial, &p)){
187 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 -0800188 } else {
189 handle_packet(p, (atransport *) _t);
190 }
191 }
192}
193
194void send_packet(apacket *p, atransport *t)
195{
196 unsigned char *x;
197 unsigned sum;
198 unsigned count;
199
200 p->msg.magic = p->msg.command ^ 0xffffffff;
201
202 count = p->msg.data_length;
203 x = (unsigned char *) p->data;
204 sum = 0;
205 while(count-- > 0){
206 sum += *x++;
207 }
208 p->msg.data_check = sum;
209
210 print_packet("send", p);
211
212 if (t == NULL) {
JP Abgrall0e7c4272011-02-23 18:44:39 -0800213 D("Transport is null \n");
JP Abgrall408fa572011-03-16 15:57:42 -0700214 // Zap errno because print_packet() and other stuff have errno effect.
215 errno = 0;
216 fatal_errno("Transport is null");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800217 }
218
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100219 if(write_packet(t->transport_socket, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800220 fatal_errno("cannot enqueue packet on transport socket");
221 }
222}
223
224/* The transport is opened by transport_register_func before
225** the input and output threads are started.
226**
227** The output thread issues a SYNC(1, token) message to let
228** the input thread know to start things up. In the event
229** of transport IO failure, the output thread will post a
230** SYNC(0,0) message to ensure shutdown.
231**
232** The transport will not actually be closed until both
233** threads exit, but the input thread will kick the transport
234** on its way out to disconnect the underlying device.
235*/
236
237static void *output_thread(void *_t)
238{
Dan Albertbac34742015-02-25 17:51:28 -0800239 atransport *t = reinterpret_cast<atransport*>(_t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800240 apacket *p;
241
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100242 D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
243 t->serial, t->fd, t->sync_token + 1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800244 p = get_apacket();
245 p->msg.command = A_SYNC;
246 p->msg.arg0 = 1;
247 p->msg.arg1 = ++(t->sync_token);
248 p->msg.magic = A_SYNC ^ 0xffffffff;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100249 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800250 put_apacket(p);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100251 D("%s: failed to write SYNC packet\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800252 goto oops;
253 }
254
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100255 D("%s: data pump started\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800256 for(;;) {
257 p = get_apacket();
258
259 if(t->read_from_remote(p, t) == 0){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100260 D("%s: received remote packet, sending to transport\n",
261 t->serial);
262 if(write_packet(t->fd, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800263 put_apacket(p);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100264 D("%s: failed to write apacket to transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800265 goto oops;
266 }
267 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100268 D("%s: remote read failed for transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800269 put_apacket(p);
270 break;
271 }
272 }
273
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100274 D("%s: SYNC offline for transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275 p = get_apacket();
276 p->msg.command = A_SYNC;
277 p->msg.arg0 = 0;
278 p->msg.arg1 = 0;
279 p->msg.magic = A_SYNC ^ 0xffffffff;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100280 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800281 put_apacket(p);
Spencer Low8d8126a2015-07-21 02:06:26 -0700282 D("%s: failed to write SYNC apacket to transport\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800283 }
284
285oops:
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100286 D("%s: transport output thread is exiting\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800287 kick_transport(t);
288 transport_unref(t);
289 return 0;
290}
291
292static void *input_thread(void *_t)
293{
Dan Albertbac34742015-02-25 17:51:28 -0800294 atransport *t = reinterpret_cast<atransport*>(_t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800295 apacket *p;
296 int active = 0;
297
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100298 D("%s: starting transport input thread, reading from fd %d\n",
299 t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800300
301 for(;;){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100302 if(read_packet(t->fd, t->serial, &p)) {
303 D("%s: failed to read apacket from transport on fd %d\n",
304 t->serial, t->fd );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800305 break;
306 }
307 if(p->msg.command == A_SYNC){
308 if(p->msg.arg0 == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100309 D("%s: transport SYNC offline\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800310 put_apacket(p);
311 break;
312 } else {
313 if(p->msg.arg1 == t->sync_token) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100314 D("%s: transport SYNC online\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800315 active = 1;
316 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100317 D("%s: transport ignoring SYNC %d != %d\n",
318 t->serial, p->msg.arg1, t->sync_token);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800319 }
320 }
321 } else {
322 if(active) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100323 D("%s: transport got packet, sending to remote\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800324 t->write_to_remote(p, t);
325 } else {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100326 D("%s: transport ignoring packet while offline\n", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800327 }
328 }
329
330 put_apacket(p);
331 }
332
333 // this is necessary to avoid a race condition that occured when a transport closes
334 // while a client socket is still active.
335 close_all_sockets(t);
336
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100337 D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800338 kick_transport(t);
339 transport_unref(t);
340 return 0;
341}
342
343
344static int transport_registration_send = -1;
345static int transport_registration_recv = -1;
346static fdevent transport_registration_fde;
347
348
349#if ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800350
351/* this adds support required by the 'track-devices' service.
352 * this is used to send the content of "list_transport" to any
353 * number of client connections that want it through a single
354 * live TCP connection
355 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800356struct device_tracker {
357 asocket socket;
358 int update_needed;
359 device_tracker* next;
360};
361
362/* linked list of all device trackers */
363static device_tracker* device_tracker_list;
364
365static void
366device_tracker_remove( device_tracker* tracker )
367{
368 device_tracker** pnode = &device_tracker_list;
369 device_tracker* node = *pnode;
370
371 adb_mutex_lock( &transport_lock );
372 while (node) {
373 if (node == tracker) {
374 *pnode = node->next;
375 break;
376 }
377 pnode = &node->next;
378 node = *pnode;
379 }
380 adb_mutex_unlock( &transport_lock );
381}
382
383static void
384device_tracker_close( asocket* socket )
385{
386 device_tracker* tracker = (device_tracker*) socket;
387 asocket* peer = socket->peer;
388
389 D( "device tracker %p removed\n", tracker);
390 if (peer) {
391 peer->peer = NULL;
392 peer->close(peer);
393 }
394 device_tracker_remove(tracker);
395 free(tracker);
396}
397
398static int
399device_tracker_enqueue( asocket* socket, apacket* p )
400{
401 /* you can't read from a device tracker, close immediately */
402 put_apacket(p);
403 device_tracker_close(socket);
404 return -1;
405}
406
Elliott Hughese67f1f82015-04-30 17:32:03 -0700407static int device_tracker_send(device_tracker* tracker, const std::string& string) {
408 apacket* p = get_apacket();
409 asocket* peer = tracker->socket.peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800410
Elliott Hughese67f1f82015-04-30 17:32:03 -0700411 snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size()));
412 memcpy(&p->data[4], string.data(), string.size());
413 p->len = 4 + string.size();
414 return peer->enqueue(peer, p);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800415}
416
Elliott Hughese67f1f82015-04-30 17:32:03 -0700417static void device_tracker_ready(asocket* socket) {
418 device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800419
Elliott Hughese67f1f82015-04-30 17:32:03 -0700420 // We want to send the device list when the tracker connects
421 // for the first time, even if no update occurred.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800422 if (tracker->update_needed > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800423 tracker->update_needed = 0;
424
Elliott Hughese67f1f82015-04-30 17:32:03 -0700425 std::string transports = list_transports(false);
426 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800427 }
428}
429
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800430asocket*
431create_device_tracker(void)
432{
Elliott Hughesdc3b4592015-04-21 19:39:52 -0700433 device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
434 if (tracker == nullptr) fatal("cannot allocate device tracker");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800435
436 D( "device tracker %p created\n", tracker);
437
438 tracker->socket.enqueue = device_tracker_enqueue;
439 tracker->socket.ready = device_tracker_ready;
440 tracker->socket.close = device_tracker_close;
441 tracker->update_needed = 1;
442
443 tracker->next = device_tracker_list;
444 device_tracker_list = tracker;
445
446 return &tracker->socket;
447}
448
449
Elliott Hughese67f1f82015-04-30 17:32:03 -0700450// Call this function each time the transport list has changed.
451void update_transports() {
452 std::string transports = list_transports(false);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800453
Elliott Hughese67f1f82015-04-30 17:32:03 -0700454 device_tracker* tracker = device_tracker_list;
455 while (tracker != nullptr) {
456 device_tracker* next = tracker->next;
457 // This may destroy the tracker if the connection is closed.
458 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800459 tracker = next;
460 }
461}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700462
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800463#else
Elliott Hughese67f1f82015-04-30 17:32:03 -0700464
465void update_transports() {
466 // Nothing to do on the device side.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800467}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700468
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800469#endif // ADB_HOST
470
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800471struct tmsg
472{
473 atransport *transport;
474 int action;
475};
476
477static int
478transport_read_action(int fd, struct tmsg* m)
479{
480 char *p = (char*)m;
481 int len = sizeof(*m);
482 int r;
483
484 while(len > 0) {
485 r = adb_read(fd, p, len);
486 if(r > 0) {
487 len -= r;
488 p += r;
489 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700490 D("transport_read_action: on fd %d: %s\n", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800491 return -1;
492 }
493 }
494 return 0;
495}
496
497static int
498transport_write_action(int fd, struct tmsg* m)
499{
500 char *p = (char*)m;
501 int len = sizeof(*m);
502 int r;
503
504 while(len > 0) {
505 r = adb_write(fd, p, len);
506 if(r > 0) {
507 len -= r;
508 p += r;
509 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700510 D("transport_write_action: on fd %d: %s\n", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800511 return -1;
512 }
513 }
514 return 0;
515}
516
517static void transport_registration_func(int _fd, unsigned ev, void *data)
518{
519 tmsg m;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800520 int s[2];
521 atransport *t;
522
523 if(!(ev & FDE_READ)) {
524 return;
525 }
526
527 if(transport_read_action(_fd, &m)) {
528 fatal_errno("cannot read transport registration socket");
529 }
530
531 t = m.transport;
532
Dan Albert1792c232015-05-18 13:06:53 -0700533 if (m.action == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100534 D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800535
536 /* IMPORTANT: the remove closes one half of the
537 ** socket pair. The close closes the other half.
538 */
539 fdevent_remove(&(t->transport_fde));
540 adb_close(t->fd);
541
542 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700543 transport_list.remove(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800544 adb_mutex_unlock(&transport_lock);
545
546 run_transport_disconnects(t);
547
548 if (t->product)
549 free(t->product);
550 if (t->serial)
551 free(t->serial);
Scott Andersone82c2db2012-05-25 14:10:02 -0700552 if (t->model)
553 free(t->model);
554 if (t->device)
555 free(t->device);
Scott Andersone109d262012-04-20 11:21:14 -0700556 if (t->devpath)
557 free(t->devpath);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800558
Dan Albertc7915a32015-05-18 16:46:31 -0700559 delete t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800560
561 update_transports();
562 return;
563 }
564
Mike Lockwood0927bf92009-08-08 12:37:44 -0400565 /* don't create transport threads for inaccessible devices */
Dan Albertdcd78a12015-05-18 16:43:57 -0700566 if (t->connection_state != kCsNoPerm) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800567 /* initial references are the two threads */
Mike Lockwood0927bf92009-08-08 12:37:44 -0400568 t->ref_count = 2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800569
Dan Albertc7915a32015-05-18 16:46:31 -0700570 if (adb_socketpair(s)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400571 fatal_errno("cannot open transport socketpair");
572 }
573
Spencer Low8d8126a2015-07-21 02:06:26 -0700574 D("transport: %s socketpair: (%d,%d) starting\n", t->serial, s[0], s[1]);
Mike Lockwood0927bf92009-08-08 12:37:44 -0400575
576 t->transport_socket = s[0];
577 t->fd = s[1];
578
Mike Lockwood0927bf92009-08-08 12:37:44 -0400579 fdevent_install(&(t->transport_fde),
580 t->transport_socket,
581 transport_socket_events,
582 t);
583
584 fdevent_set(&(t->transport_fde), FDE_READ);
585
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700586 if (!adb_thread_create(input_thread, t)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400587 fatal_errno("cannot create input thread");
588 }
589
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700590 if (!adb_thread_create(output_thread, t)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400591 fatal_errno("cannot create output thread");
592 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800593 }
594
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800595 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700596 pending_list.remove(t);
597 transport_list.push_front(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800598 adb_mutex_unlock(&transport_lock);
599
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800600 t->disconnects.next = t->disconnects.prev = &t->disconnects;
601
602 update_transports();
603}
604
605void init_transport_registration(void)
606{
607 int s[2];
608
609 if(adb_socketpair(s)){
610 fatal_errno("cannot open transport registration socketpair");
611 }
Spencer Low8d8126a2015-07-21 02:06:26 -0700612 D("socketpair: (%d,%d)\n", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800613
614 transport_registration_send = s[0];
615 transport_registration_recv = s[1];
616
617 fdevent_install(&transport_registration_fde,
618 transport_registration_recv,
619 transport_registration_func,
620 0);
621
622 fdevent_set(&transport_registration_fde, FDE_READ);
623}
624
625/* the fdevent select pump is single threaded */
626static void register_transport(atransport *transport)
627{
628 tmsg m;
629 m.transport = transport;
630 m.action = 1;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100631 D("transport: %s registered\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800632 if(transport_write_action(transport_registration_send, &m)) {
633 fatal_errno("cannot write transport registration socket\n");
634 }
635}
636
637static void remove_transport(atransport *transport)
638{
639 tmsg m;
640 m.transport = transport;
641 m.action = 0;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100642 D("transport: %s removed\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800643 if(transport_write_action(transport_registration_send, &m)) {
644 fatal_errno("cannot write transport registration socket\n");
645 }
646}
647
648
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400649static void transport_unref_locked(atransport *t)
650{
651 t->ref_count--;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400652 if (t->ref_count == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100653 D("transport: %s unref (kicking and closing)\n", t->serial);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400654 if (!t->kicked) {
655 t->kicked = 1;
656 t->kick(t);
657 }
658 t->close(t);
659 remove_transport(t);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100660 } else {
661 D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400662 }
663}
664
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800665static void transport_unref(atransport *t)
666{
667 if (t) {
668 adb_mutex_lock(&transport_lock);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400669 transport_unref_locked(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800670 adb_mutex_unlock(&transport_lock);
671 }
672}
673
674void add_transport_disconnect(atransport* t, adisconnect* dis)
675{
676 adb_mutex_lock(&transport_lock);
677 dis->next = &t->disconnects;
678 dis->prev = dis->next->prev;
679 dis->prev->next = dis;
680 dis->next->prev = dis;
681 adb_mutex_unlock(&transport_lock);
682}
683
684void remove_transport_disconnect(atransport* t, adisconnect* dis)
685{
686 dis->prev->next = dis->next;
687 dis->next->prev = dis->prev;
688 dis->next = dis->prev = dis;
689}
690
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700691static int qual_match(const char *to_test,
Elliott Hughes09a45a12015-04-03 16:12:15 -0700692 const char *prefix, const char *qual, bool sanitize_qual)
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700693{
694 if (!to_test || !*to_test)
695 /* Return true if both the qual and to_test are null strings. */
696 return !qual || !*qual;
697
698 if (!qual)
699 return 0;
700
701 if (prefix) {
702 while (*prefix) {
703 if (*prefix++ != *to_test++)
704 return 0;
705 }
706 }
707
708 while (*qual) {
709 char ch = *qual++;
Elliott Hughes09a45a12015-04-03 16:12:15 -0700710 if (sanitize_qual && !isalnum(ch))
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700711 ch = '_';
712 if (ch != *to_test++)
713 return 0;
714 }
715
716 /* Everything matched so far. Return true if *to_test is a NUL. */
717 return !*to_test;
718}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800719
Dan Albertdcd78a12015-05-18 16:43:57 -0700720atransport* acquire_one_transport(ConnectionState state, TransportType type,
721 const char* serial, std::string* error_out) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800722 atransport *result = NULL;
723 int ambiguous = 0;
724
725retry:
Elliott Hughese2d36772015-06-23 13:00:32 -0700726 *error_out = serial ? android::base::StringPrintf("device '%s' not found", serial) : "no devices found";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800727
728 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700729 for (auto t : transport_list) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700730 if (t->connection_state == kCsNoPerm) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700731 *error_out = "insufficient permissions for device";
Mike Lockwood37d31112009-08-08 13:53:16 -0400732 continue;
733 }
Mike Lockwood0927bf92009-08-08 12:37:44 -0400734
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800735 /* check for matching serial number */
736 if (serial) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700737 if ((t->serial && !strcmp(serial, t->serial)) ||
738 (t->devpath && !strcmp(serial, t->devpath)) ||
Elliott Hughes09a45a12015-04-03 16:12:15 -0700739 qual_match(serial, "product:", t->product, false) ||
740 qual_match(serial, "model:", t->model, true) ||
741 qual_match(serial, "device:", t->device, false)) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700742 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700743 *error_out = "more than one device";
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700744 ambiguous = 1;
745 result = NULL;
746 break;
747 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800748 result = t;
Scott Andersone109d262012-04-20 11:21:14 -0700749 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800750 } else {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700751 if (type == kTransportUsb && t->type == kTransportUsb) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800752 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700753 *error_out = "more than one device";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800754 ambiguous = 1;
755 result = NULL;
756 break;
757 }
758 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700759 } else if (type == kTransportLocal && t->type == kTransportLocal) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800760 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700761 *error_out = "more than one emulator";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800762 ambiguous = 1;
763 result = NULL;
764 break;
765 }
766 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700767 } else if (type == kTransportAny) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800768 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700769 *error_out = "more than one device/emulator";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800770 ambiguous = 1;
771 result = NULL;
772 break;
773 }
774 result = t;
775 }
776 }
777 }
778 adb_mutex_unlock(&transport_lock);
779
780 if (result) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700781 if (result->connection_state == kCsUnauthorized) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700782 *error_out = "device unauthorized.\n";
783 char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
Elliott Hughes64d303a2015-07-18 13:57:46 -0700784 *error_out += "This adb server's $ADB_VENDOR_KEYS is ";
Elliott Hughese2d36772015-06-23 13:00:32 -0700785 *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
Elliott Hughes64d303a2015-07-18 13:57:46 -0700786 *error_out += "\n";
787 *error_out += "Try 'adb kill-server' if that seems wrong.\n";
Elliott Hughese2d36772015-06-23 13:00:32 -0700788 *error_out += "Otherwise check for a confirmation dialog on your device.";
Benoit Goby77e8e582013-01-15 12:36:47 -0800789 result = NULL;
790 }
791
Elliott Hughes7be29c82015-04-16 22:54:44 -0700792 /* offline devices are ignored -- they are either being born or dying */
Dan Albertdcd78a12015-05-18 16:43:57 -0700793 if (result && result->connection_state == kCsOffline) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700794 *error_out = "device offline";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800795 result = NULL;
796 }
Elliott Hughes7be29c82015-04-16 22:54:44 -0700797
798 /* check for required connection state */
Dan Albertdcd78a12015-05-18 16:43:57 -0700799 if (result && state != kCsAny && result->connection_state != state) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700800 *error_out = "invalid device state";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800801 result = NULL;
802 }
803 }
804
805 if (result) {
806 /* found one that we can take */
Elliott Hughese2d36772015-06-23 13:00:32 -0700807 *error_out = "success";
Dan Albertdcd78a12015-05-18 16:43:57 -0700808 } else if (state != kCsAny && (serial || !ambiguous)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800809 adb_sleep_ms(1000);
810 goto retry;
811 }
812
813 return result;
814}
815
Elliott Hughese67f1f82015-04-30 17:32:03 -0700816const char* atransport::connection_state_name() const {
817 switch (connection_state) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700818 case kCsOffline: return "offline";
819 case kCsBootloader: return "bootloader";
820 case kCsDevice: return "device";
821 case kCsHost: return "host";
822 case kCsRecovery: return "recovery";
823 case kCsNoPerm: return "no permissions";
824 case kCsSideload: return "sideload";
825 case kCsUnauthorized: return "unauthorized";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800826 default: return "unknown";
827 }
828}
829
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100830void atransport::update_version(int version, size_t payload) {
831 protocol_version = std::min(version, A_VERSION);
832 max_payload = std::min(payload, MAX_PAYLOAD);
833}
834
835int atransport::get_protocol_version() const {
836 return protocol_version;
837}
838
839size_t atransport::get_max_payload() const {
840 return max_payload;
841}
842
Dan Albert1792c232015-05-18 13:06:53 -0700843// The list of features supported by the current system. Will be sent to the
844// other side of the connection in the banner.
845static const FeatureSet gSupportedFeatures = {
846 // None yet.
847};
848
849const FeatureSet& supported_features() {
850 return gSupportedFeatures;
851}
852
853bool atransport::has_feature(const std::string& feature) const {
854 return features_.count(feature) > 0;
855}
856
857void atransport::add_feature(const std::string& feature) {
858 features_.insert(feature);
859}
860
861bool atransport::CanUseFeature(const std::string& feature) const {
Elliott Hughesaa245492015-08-03 10:38:08 -0700862 return has_feature(feature) && supported_features().count(feature) > 0;
Dan Albert1792c232015-05-18 13:06:53 -0700863}
864
Elliott Hughese67f1f82015-04-30 17:32:03 -0700865#if ADB_HOST
866
Dan Albertd99d9022015-05-06 16:48:52 -0700867static void append_transport_info(std::string* result, const char* key,
868 const char* value, bool sanitize) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700869 if (value == nullptr || *value == '\0') {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700870 return;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700871 }
872
Elliott Hughese67f1f82015-04-30 17:32:03 -0700873 *result += ' ';
874 *result += key;
875
876 for (const char* p = value; *p; ++p) {
877 result->push_back((!sanitize || isalnum(*p)) ? *p : '_');
878 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700879}
880
Dan Albertc7915a32015-05-18 16:46:31 -0700881static void append_transport(const atransport* t, std::string* result,
882 bool long_listing) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700883 const char* serial = t->serial;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700884 if (!serial || !serial[0]) {
Dan Albertd99d9022015-05-06 16:48:52 -0700885 serial = "(no serial number)";
Elliott Hughese67f1f82015-04-30 17:32:03 -0700886 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700887
888 if (!long_listing) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700889 *result += serial;
890 *result += '\t';
891 *result += t->connection_state_name();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700892 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700893 android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name());
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700894
Elliott Hughese67f1f82015-04-30 17:32:03 -0700895 append_transport_info(result, "", t->devpath, false);
896 append_transport_info(result, "product:", t->product, false);
897 append_transport_info(result, "model:", t->model, true);
898 append_transport_info(result, "device:", t->device, false);
Dan Albert1792c232015-05-18 13:06:53 -0700899 append_transport_info(result, "features:",
900 android::base::Join(t->features(), ',').c_str(),
901 false);
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700902 }
Elliott Hughese67f1f82015-04-30 17:32:03 -0700903 *result += '\n';
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700904}
905
Elliott Hughese67f1f82015-04-30 17:32:03 -0700906std::string list_transports(bool long_listing) {
907 std::string result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800908 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700909 for (const auto t : transport_list) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700910 append_transport(t, &result, long_listing);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800911 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800912 adb_mutex_unlock(&transport_lock);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700913 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800914}
915
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800916/* hack for osx */
Dan Albertc7915a32015-05-18 16:46:31 -0700917void close_usb_devices() {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800918 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700919 for (auto t : transport_list) {
920 if (!t->kicked) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800921 t->kicked = 1;
922 t->kick(t);
923 }
924 }
925 adb_mutex_unlock(&transport_lock);
926}
927#endif // ADB_HOST
928
Dan Albertc7915a32015-05-18 16:46:31 -0700929int register_socket_transport(int s, const char *serial, int port, int local) {
930 atransport* t = new atransport();
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100931
932 if (!serial) {
Dan Albertc7915a32015-05-18 16:46:31 -0700933 char buf[32];
934 snprintf(buf, sizeof(buf), "T-%p", t);
935 serial = buf;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100936 }
Dan Albertc7915a32015-05-18 16:46:31 -0700937
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100938 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700939 if (init_socket_transport(t, s, port, local) < 0) {
Dan Albertc7915a32015-05-18 16:46:31 -0700940 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700941 return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800942 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700943
944 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700945 for (auto transport : pending_list) {
946 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700947 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700948 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700949 return -1;
950 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800951 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700952
Dan Albertc7915a32015-05-18 16:46:31 -0700953 for (auto transport : transport_list) {
954 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700955 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700956 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700957 return -1;
958 }
959 }
960
Dan Albertc7915a32015-05-18 16:46:31 -0700961 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700962 t->serial = strdup(serial);
963 adb_mutex_unlock(&transport_lock);
964
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800965 register_transport(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700966 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800967}
968
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400969#if ADB_HOST
Dan Albertc7915a32015-05-18 16:46:31 -0700970atransport *find_transport(const char *serial) {
971 atransport* result = nullptr;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400972
973 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700974 for (auto t : transport_list) {
975 if (t->serial && strcmp(serial, t->serial) == 0) {
976 result = t;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400977 break;
978 }
Dan Albertc7915a32015-05-18 16:46:31 -0700979 }
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400980 adb_mutex_unlock(&transport_lock);
981
Dan Albertc7915a32015-05-18 16:46:31 -0700982 return result;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400983}
984
985void unregister_transport(atransport *t)
986{
987 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700988 transport_list.remove(t);
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400989 adb_mutex_unlock(&transport_lock);
990
991 kick_transport(t);
992 transport_unref(t);
993}
994
Dan Albertc7915a32015-05-18 16:46:31 -0700995// Unregisters all non-emulator TCP transports.
996void unregister_all_tcp_transports() {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400997 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700998 for (auto it = transport_list.begin(); it != transport_list.end(); ) {
999 atransport* t = *it;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001000 if (t->type == kTransportLocal && t->adb_port == 0) {
Dan Albertc7915a32015-05-18 16:46:31 -07001001 // We cannot call kick_transport when holding transport_lock.
1002 if (!t->kicked) {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001003 t->kicked = 1;
1004 t->kick(t);
1005 }
1006 transport_unref_locked(t);
Dan Albertc7915a32015-05-18 16:46:31 -07001007
1008 it = transport_list.erase(it);
1009 } else {
1010 ++it;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001011 }
Dan Albertc7915a32015-05-18 16:46:31 -07001012 }
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001013
1014 adb_mutex_unlock(&transport_lock);
1015}
1016
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001017#endif
1018
Dan Albertc7915a32015-05-18 16:46:31 -07001019void register_usb_transport(usb_handle* usb, const char* serial,
1020 const char* devpath, unsigned writeable) {
1021 atransport* t = new atransport();
1022
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001023 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
1024 serial ? serial : "");
Dan Albertdcd78a12015-05-18 16:43:57 -07001025 init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001026 if(serial) {
1027 t->serial = strdup(serial);
1028 }
Dan Albertc7915a32015-05-18 16:46:31 -07001029
1030 if (devpath) {
Scott Andersone109d262012-04-20 11:21:14 -07001031 t->devpath = strdup(devpath);
1032 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001033
1034 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001035 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -07001036 adb_mutex_unlock(&transport_lock);
1037
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001038 register_transport(t);
1039}
1040
Dan Albertdcd78a12015-05-18 16:43:57 -07001041// This should only be used for transports with connection_state == kCsNoPerm.
Dan Albertc7915a32015-05-18 16:46:31 -07001042void unregister_usb_transport(usb_handle *usb) {
Mike Lockwood0927bf92009-08-08 12:37:44 -04001043 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001044 transport_list.remove_if([usb](atransport* t) {
1045 return t->usb == usb && t->connection_state == kCsNoPerm;
1046 });
Mike Lockwood0927bf92009-08-08 12:37:44 -04001047 adb_mutex_unlock(&transport_lock);
1048}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001049
1050#undef TRACE_TAG
1051#define TRACE_TAG TRACE_RWX
1052
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001053int check_header(apacket *p, atransport *t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001054{
1055 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1056 D("check_header(): invalid magic\n");
1057 return -1;
1058 }
1059
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001060 if(p->msg.data_length > t->get_max_payload()) {
1061 D("check_header(): %u > atransport::max_payload = %zu\n",
1062 p->msg.data_length, t->get_max_payload());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001063 return -1;
1064 }
1065
1066 return 0;
1067}
1068
1069int check_data(apacket *p)
1070{
1071 unsigned count, sum;
1072 unsigned char *x;
1073
1074 count = p->msg.data_length;
1075 x = p->data;
1076 sum = 0;
1077 while(count-- > 0) {
1078 sum += *x++;
1079 }
1080
1081 if(sum != p->msg.data_check) {
1082 return -1;
1083 } else {
1084 return 0;
1085 }
1086}