blob: 20d5d71398cea56caf33d8f472ad2bc9228de21a [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{
Yabin Cuid8459b32015-08-26 11:44:16 -070046 if (t != nullptr)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080047 {
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
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100333 D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800334 kick_transport(t);
335 transport_unref(t);
336 return 0;
337}
338
339
340static int transport_registration_send = -1;
341static int transport_registration_recv = -1;
342static fdevent transport_registration_fde;
343
344
345#if ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800346
347/* this adds support required by the 'track-devices' service.
348 * this is used to send the content of "list_transport" to any
349 * number of client connections that want it through a single
350 * live TCP connection
351 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800352struct device_tracker {
353 asocket socket;
354 int update_needed;
355 device_tracker* next;
356};
357
358/* linked list of all device trackers */
359static device_tracker* device_tracker_list;
360
361static void
362device_tracker_remove( device_tracker* tracker )
363{
364 device_tracker** pnode = &device_tracker_list;
365 device_tracker* node = *pnode;
366
367 adb_mutex_lock( &transport_lock );
368 while (node) {
369 if (node == tracker) {
370 *pnode = node->next;
371 break;
372 }
373 pnode = &node->next;
374 node = *pnode;
375 }
376 adb_mutex_unlock( &transport_lock );
377}
378
379static void
380device_tracker_close( asocket* socket )
381{
382 device_tracker* tracker = (device_tracker*) socket;
383 asocket* peer = socket->peer;
384
385 D( "device tracker %p removed\n", tracker);
386 if (peer) {
387 peer->peer = NULL;
388 peer->close(peer);
389 }
390 device_tracker_remove(tracker);
391 free(tracker);
392}
393
394static int
395device_tracker_enqueue( asocket* socket, apacket* p )
396{
397 /* you can't read from a device tracker, close immediately */
398 put_apacket(p);
399 device_tracker_close(socket);
400 return -1;
401}
402
Elliott Hughese67f1f82015-04-30 17:32:03 -0700403static int device_tracker_send(device_tracker* tracker, const std::string& string) {
404 apacket* p = get_apacket();
405 asocket* peer = tracker->socket.peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800406
Elliott Hughese67f1f82015-04-30 17:32:03 -0700407 snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size()));
408 memcpy(&p->data[4], string.data(), string.size());
409 p->len = 4 + string.size();
410 return peer->enqueue(peer, p);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800411}
412
Elliott Hughese67f1f82015-04-30 17:32:03 -0700413static void device_tracker_ready(asocket* socket) {
414 device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800415
Elliott Hughese67f1f82015-04-30 17:32:03 -0700416 // We want to send the device list when the tracker connects
417 // for the first time, even if no update occurred.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800418 if (tracker->update_needed > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800419 tracker->update_needed = 0;
420
Elliott Hughese67f1f82015-04-30 17:32:03 -0700421 std::string transports = list_transports(false);
422 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800423 }
424}
425
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800426asocket*
427create_device_tracker(void)
428{
Elliott Hughesdc3b4592015-04-21 19:39:52 -0700429 device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
430 if (tracker == nullptr) fatal("cannot allocate device tracker");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800431
432 D( "device tracker %p created\n", tracker);
433
434 tracker->socket.enqueue = device_tracker_enqueue;
435 tracker->socket.ready = device_tracker_ready;
436 tracker->socket.close = device_tracker_close;
437 tracker->update_needed = 1;
438
439 tracker->next = device_tracker_list;
440 device_tracker_list = tracker;
441
442 return &tracker->socket;
443}
444
445
Elliott Hughese67f1f82015-04-30 17:32:03 -0700446// Call this function each time the transport list has changed.
447void update_transports() {
448 std::string transports = list_transports(false);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800449
Elliott Hughese67f1f82015-04-30 17:32:03 -0700450 device_tracker* tracker = device_tracker_list;
451 while (tracker != nullptr) {
452 device_tracker* next = tracker->next;
453 // This may destroy the tracker if the connection is closed.
454 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800455 tracker = next;
456 }
457}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700458
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800459#else
Elliott Hughese67f1f82015-04-30 17:32:03 -0700460
461void update_transports() {
462 // Nothing to do on the device side.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800463}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700464
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800465#endif // ADB_HOST
466
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800467struct tmsg
468{
469 atransport *transport;
470 int action;
471};
472
473static int
474transport_read_action(int fd, struct tmsg* m)
475{
476 char *p = (char*)m;
477 int len = sizeof(*m);
478 int r;
479
480 while(len > 0) {
481 r = adb_read(fd, p, len);
482 if(r > 0) {
483 len -= r;
484 p += r;
485 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700486 D("transport_read_action: on fd %d: %s\n", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800487 return -1;
488 }
489 }
490 return 0;
491}
492
493static int
494transport_write_action(int fd, struct tmsg* m)
495{
496 char *p = (char*)m;
497 int len = sizeof(*m);
498 int r;
499
500 while(len > 0) {
501 r = adb_write(fd, p, len);
502 if(r > 0) {
503 len -= r;
504 p += r;
505 } else {
Elliott Hughes8fcd8bc2015-08-25 10:59:45 -0700506 D("transport_write_action: on fd %d: %s\n", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800507 return -1;
508 }
509 }
510 return 0;
511}
512
513static void transport_registration_func(int _fd, unsigned ev, void *data)
514{
515 tmsg m;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800516 int s[2];
517 atransport *t;
518
519 if(!(ev & FDE_READ)) {
520 return;
521 }
522
523 if(transport_read_action(_fd, &m)) {
524 fatal_errno("cannot read transport registration socket");
525 }
526
527 t = m.transport;
528
Dan Albert1792c232015-05-18 13:06:53 -0700529 if (m.action == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100530 D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800531
532 /* IMPORTANT: the remove closes one half of the
533 ** socket pair. The close closes the other half.
534 */
535 fdevent_remove(&(t->transport_fde));
536 adb_close(t->fd);
537
538 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700539 transport_list.remove(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800540 adb_mutex_unlock(&transport_lock);
541
542 run_transport_disconnects(t);
543
544 if (t->product)
545 free(t->product);
546 if (t->serial)
547 free(t->serial);
Scott Andersone82c2db2012-05-25 14:10:02 -0700548 if (t->model)
549 free(t->model);
550 if (t->device)
551 free(t->device);
Scott Andersone109d262012-04-20 11:21:14 -0700552 if (t->devpath)
553 free(t->devpath);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800554
Dan Albertc7915a32015-05-18 16:46:31 -0700555 delete t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800556
557 update_transports();
558 return;
559 }
560
Mike Lockwood0927bf92009-08-08 12:37:44 -0400561 /* don't create transport threads for inaccessible devices */
Dan Albertdcd78a12015-05-18 16:43:57 -0700562 if (t->connection_state != kCsNoPerm) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800563 /* initial references are the two threads */
Mike Lockwood0927bf92009-08-08 12:37:44 -0400564 t->ref_count = 2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800565
Dan Albertc7915a32015-05-18 16:46:31 -0700566 if (adb_socketpair(s)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400567 fatal_errno("cannot open transport socketpair");
568 }
569
Spencer Low8d8126a2015-07-21 02:06:26 -0700570 D("transport: %s socketpair: (%d,%d) starting\n", t->serial, s[0], s[1]);
Mike Lockwood0927bf92009-08-08 12:37:44 -0400571
572 t->transport_socket = s[0];
573 t->fd = s[1];
574
Mike Lockwood0927bf92009-08-08 12:37:44 -0400575 fdevent_install(&(t->transport_fde),
576 t->transport_socket,
577 transport_socket_events,
578 t);
579
580 fdevent_set(&(t->transport_fde), FDE_READ);
581
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700582 if (!adb_thread_create(input_thread, t)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400583 fatal_errno("cannot create input thread");
584 }
585
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700586 if (!adb_thread_create(output_thread, t)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400587 fatal_errno("cannot create output thread");
588 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800589 }
590
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800591 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700592 pending_list.remove(t);
593 transport_list.push_front(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800594 adb_mutex_unlock(&transport_lock);
595
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800596 t->disconnects.next = t->disconnects.prev = &t->disconnects;
597
598 update_transports();
599}
600
601void init_transport_registration(void)
602{
603 int s[2];
604
605 if(adb_socketpair(s)){
606 fatal_errno("cannot open transport registration socketpair");
607 }
Spencer Low8d8126a2015-07-21 02:06:26 -0700608 D("socketpair: (%d,%d)\n", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800609
610 transport_registration_send = s[0];
611 transport_registration_recv = s[1];
612
613 fdevent_install(&transport_registration_fde,
614 transport_registration_recv,
615 transport_registration_func,
616 0);
617
618 fdevent_set(&transport_registration_fde, FDE_READ);
619}
620
621/* the fdevent select pump is single threaded */
622static void register_transport(atransport *transport)
623{
624 tmsg m;
625 m.transport = transport;
626 m.action = 1;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100627 D("transport: %s registered\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800628 if(transport_write_action(transport_registration_send, &m)) {
629 fatal_errno("cannot write transport registration socket\n");
630 }
631}
632
633static void remove_transport(atransport *transport)
634{
635 tmsg m;
636 m.transport = transport;
637 m.action = 0;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100638 D("transport: %s removed\n", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800639 if(transport_write_action(transport_registration_send, &m)) {
640 fatal_errno("cannot write transport registration socket\n");
641 }
642}
643
644
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400645static void transport_unref_locked(atransport *t)
646{
647 t->ref_count--;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400648 if (t->ref_count == 0) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100649 D("transport: %s unref (kicking and closing)\n", t->serial);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400650 if (!t->kicked) {
651 t->kicked = 1;
652 t->kick(t);
653 }
654 t->close(t);
655 remove_transport(t);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100656 } else {
657 D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400658 }
659}
660
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800661static void transport_unref(atransport *t)
662{
663 if (t) {
664 adb_mutex_lock(&transport_lock);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400665 transport_unref_locked(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800666 adb_mutex_unlock(&transport_lock);
667 }
668}
669
670void add_transport_disconnect(atransport* t, adisconnect* dis)
671{
672 adb_mutex_lock(&transport_lock);
673 dis->next = &t->disconnects;
674 dis->prev = dis->next->prev;
675 dis->prev->next = dis;
676 dis->next->prev = dis;
677 adb_mutex_unlock(&transport_lock);
678}
679
680void remove_transport_disconnect(atransport* t, adisconnect* dis)
681{
682 dis->prev->next = dis->next;
683 dis->next->prev = dis->prev;
684 dis->next = dis->prev = dis;
685}
686
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700687static int qual_match(const char *to_test,
Elliott Hughes09a45a12015-04-03 16:12:15 -0700688 const char *prefix, const char *qual, bool sanitize_qual)
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700689{
690 if (!to_test || !*to_test)
691 /* Return true if both the qual and to_test are null strings. */
692 return !qual || !*qual;
693
694 if (!qual)
695 return 0;
696
697 if (prefix) {
698 while (*prefix) {
699 if (*prefix++ != *to_test++)
700 return 0;
701 }
702 }
703
704 while (*qual) {
705 char ch = *qual++;
Elliott Hughes09a45a12015-04-03 16:12:15 -0700706 if (sanitize_qual && !isalnum(ch))
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700707 ch = '_';
708 if (ch != *to_test++)
709 return 0;
710 }
711
712 /* Everything matched so far. Return true if *to_test is a NUL. */
713 return !*to_test;
714}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800715
Dan Albertdcd78a12015-05-18 16:43:57 -0700716atransport* acquire_one_transport(ConnectionState state, TransportType type,
717 const char* serial, std::string* error_out) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800718 atransport *result = NULL;
719 int ambiguous = 0;
720
721retry:
Elliott Hughese2d36772015-06-23 13:00:32 -0700722 *error_out = serial ? android::base::StringPrintf("device '%s' not found", serial) : "no devices found";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800723
724 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700725 for (auto t : transport_list) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700726 if (t->connection_state == kCsNoPerm) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700727 *error_out = "insufficient permissions for device";
Mike Lockwood37d31112009-08-08 13:53:16 -0400728 continue;
729 }
Mike Lockwood0927bf92009-08-08 12:37:44 -0400730
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800731 /* check for matching serial number */
732 if (serial) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700733 if ((t->serial && !strcmp(serial, t->serial)) ||
734 (t->devpath && !strcmp(serial, t->devpath)) ||
Elliott Hughes09a45a12015-04-03 16:12:15 -0700735 qual_match(serial, "product:", t->product, false) ||
736 qual_match(serial, "model:", t->model, true) ||
737 qual_match(serial, "device:", t->device, false)) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700738 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700739 *error_out = "more than one device";
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700740 ambiguous = 1;
741 result = NULL;
742 break;
743 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800744 result = t;
Scott Andersone109d262012-04-20 11:21:14 -0700745 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800746 } else {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700747 if (type == kTransportUsb && t->type == kTransportUsb) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800748 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700749 *error_out = "more than one device";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800750 ambiguous = 1;
751 result = NULL;
752 break;
753 }
754 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700755 } else if (type == kTransportLocal && t->type == kTransportLocal) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800756 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700757 *error_out = "more than one emulator";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800758 ambiguous = 1;
759 result = NULL;
760 break;
761 }
762 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700763 } else if (type == kTransportAny) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800764 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700765 *error_out = "more than one device/emulator";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800766 ambiguous = 1;
767 result = NULL;
768 break;
769 }
770 result = t;
771 }
772 }
773 }
774 adb_mutex_unlock(&transport_lock);
775
776 if (result) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700777 if (result->connection_state == kCsUnauthorized) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700778 *error_out = "device unauthorized.\n";
779 char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
Elliott Hughes64d303a2015-07-18 13:57:46 -0700780 *error_out += "This adb server's $ADB_VENDOR_KEYS is ";
Elliott Hughese2d36772015-06-23 13:00:32 -0700781 *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
Elliott Hughes64d303a2015-07-18 13:57:46 -0700782 *error_out += "\n";
783 *error_out += "Try 'adb kill-server' if that seems wrong.\n";
Elliott Hughese2d36772015-06-23 13:00:32 -0700784 *error_out += "Otherwise check for a confirmation dialog on your device.";
Benoit Goby77e8e582013-01-15 12:36:47 -0800785 result = NULL;
786 }
787
Elliott Hughes7be29c82015-04-16 22:54:44 -0700788 /* offline devices are ignored -- they are either being born or dying */
Dan Albertdcd78a12015-05-18 16:43:57 -0700789 if (result && result->connection_state == kCsOffline) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700790 *error_out = "device offline";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800791 result = NULL;
792 }
Elliott Hughes7be29c82015-04-16 22:54:44 -0700793
794 /* check for required connection state */
Dan Albertdcd78a12015-05-18 16:43:57 -0700795 if (result && state != kCsAny && result->connection_state != state) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700796 *error_out = "invalid device state";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800797 result = NULL;
798 }
799 }
800
801 if (result) {
802 /* found one that we can take */
Elliott Hughese2d36772015-06-23 13:00:32 -0700803 *error_out = "success";
Dan Albertdcd78a12015-05-18 16:43:57 -0700804 } else if (state != kCsAny && (serial || !ambiguous)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800805 adb_sleep_ms(1000);
806 goto retry;
807 }
808
809 return result;
810}
811
Elliott Hughese67f1f82015-04-30 17:32:03 -0700812const char* atransport::connection_state_name() const {
813 switch (connection_state) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700814 case kCsOffline: return "offline";
815 case kCsBootloader: return "bootloader";
816 case kCsDevice: return "device";
817 case kCsHost: return "host";
818 case kCsRecovery: return "recovery";
819 case kCsNoPerm: return "no permissions";
820 case kCsSideload: return "sideload";
821 case kCsUnauthorized: return "unauthorized";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800822 default: return "unknown";
823 }
824}
825
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100826void atransport::update_version(int version, size_t payload) {
827 protocol_version = std::min(version, A_VERSION);
828 max_payload = std::min(payload, MAX_PAYLOAD);
829}
830
831int atransport::get_protocol_version() const {
832 return protocol_version;
833}
834
835size_t atransport::get_max_payload() const {
836 return max_payload;
837}
838
Dan Albert1792c232015-05-18 13:06:53 -0700839// The list of features supported by the current system. Will be sent to the
840// other side of the connection in the banner.
841static const FeatureSet gSupportedFeatures = {
842 // None yet.
843};
844
845const FeatureSet& supported_features() {
846 return gSupportedFeatures;
847}
848
849bool atransport::has_feature(const std::string& feature) const {
850 return features_.count(feature) > 0;
851}
852
853void atransport::add_feature(const std::string& feature) {
854 features_.insert(feature);
855}
856
857bool atransport::CanUseFeature(const std::string& feature) const {
Elliott Hughesaa245492015-08-03 10:38:08 -0700858 return has_feature(feature) && supported_features().count(feature) > 0;
Dan Albert1792c232015-05-18 13:06:53 -0700859}
860
Elliott Hughese67f1f82015-04-30 17:32:03 -0700861#if ADB_HOST
862
Dan Albertd99d9022015-05-06 16:48:52 -0700863static void append_transport_info(std::string* result, const char* key,
864 const char* value, bool sanitize) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700865 if (value == nullptr || *value == '\0') {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700866 return;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700867 }
868
Elliott Hughese67f1f82015-04-30 17:32:03 -0700869 *result += ' ';
870 *result += key;
871
872 for (const char* p = value; *p; ++p) {
873 result->push_back((!sanitize || isalnum(*p)) ? *p : '_');
874 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700875}
876
Dan Albertc7915a32015-05-18 16:46:31 -0700877static void append_transport(const atransport* t, std::string* result,
878 bool long_listing) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700879 const char* serial = t->serial;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700880 if (!serial || !serial[0]) {
Dan Albertd99d9022015-05-06 16:48:52 -0700881 serial = "(no serial number)";
Elliott Hughese67f1f82015-04-30 17:32:03 -0700882 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700883
884 if (!long_listing) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700885 *result += serial;
886 *result += '\t';
887 *result += t->connection_state_name();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700888 } else {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700889 android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name());
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700890
Elliott Hughese67f1f82015-04-30 17:32:03 -0700891 append_transport_info(result, "", t->devpath, false);
892 append_transport_info(result, "product:", t->product, false);
893 append_transport_info(result, "model:", t->model, true);
894 append_transport_info(result, "device:", t->device, false);
Dan Albert1792c232015-05-18 13:06:53 -0700895 append_transport_info(result, "features:",
896 android::base::Join(t->features(), ',').c_str(),
897 false);
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700898 }
Elliott Hughese67f1f82015-04-30 17:32:03 -0700899 *result += '\n';
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700900}
901
Elliott Hughese67f1f82015-04-30 17:32:03 -0700902std::string list_transports(bool long_listing) {
903 std::string result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800904 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700905 for (const auto t : transport_list) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700906 append_transport(t, &result, long_listing);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800907 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800908 adb_mutex_unlock(&transport_lock);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700909 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800910}
911
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800912/* hack for osx */
Dan Albertc7915a32015-05-18 16:46:31 -0700913void close_usb_devices() {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800914 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700915 for (auto t : transport_list) {
916 if (!t->kicked) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800917 t->kicked = 1;
918 t->kick(t);
919 }
920 }
921 adb_mutex_unlock(&transport_lock);
922}
923#endif // ADB_HOST
924
Dan Albertc7915a32015-05-18 16:46:31 -0700925int register_socket_transport(int s, const char *serial, int port, int local) {
926 atransport* t = new atransport();
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100927
928 if (!serial) {
Dan Albertc7915a32015-05-18 16:46:31 -0700929 char buf[32];
930 snprintf(buf, sizeof(buf), "T-%p", t);
931 serial = buf;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100932 }
Dan Albertc7915a32015-05-18 16:46:31 -0700933
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100934 D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700935 if (init_socket_transport(t, s, port, local) < 0) {
Dan Albertc7915a32015-05-18 16:46:31 -0700936 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700937 return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800938 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700939
940 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700941 for (auto transport : pending_list) {
942 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700943 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700944 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700945 return -1;
946 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800947 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700948
Dan Albertc7915a32015-05-18 16:46:31 -0700949 for (auto transport : transport_list) {
950 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700951 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700952 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700953 return -1;
954 }
955 }
956
Dan Albertc7915a32015-05-18 16:46:31 -0700957 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700958 t->serial = strdup(serial);
959 adb_mutex_unlock(&transport_lock);
960
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800961 register_transport(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700962 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800963}
964
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400965#if ADB_HOST
Dan Albertc7915a32015-05-18 16:46:31 -0700966atransport *find_transport(const char *serial) {
967 atransport* result = nullptr;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400968
969 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700970 for (auto t : transport_list) {
971 if (t->serial && strcmp(serial, t->serial) == 0) {
972 result = t;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400973 break;
974 }
Dan Albertc7915a32015-05-18 16:46:31 -0700975 }
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400976 adb_mutex_unlock(&transport_lock);
977
Dan Albertc7915a32015-05-18 16:46:31 -0700978 return result;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400979}
980
981void unregister_transport(atransport *t)
982{
983 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700984 transport_list.remove(t);
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400985 adb_mutex_unlock(&transport_lock);
986
987 kick_transport(t);
988 transport_unref(t);
989}
990
Dan Albertc7915a32015-05-18 16:46:31 -0700991// Unregisters all non-emulator TCP transports.
992void unregister_all_tcp_transports() {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400993 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700994 for (auto it = transport_list.begin(); it != transport_list.end(); ) {
995 atransport* t = *it;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400996 if (t->type == kTransportLocal && t->adb_port == 0) {
Dan Albertc7915a32015-05-18 16:46:31 -0700997 // We cannot call kick_transport when holding transport_lock.
998 if (!t->kicked) {
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400999 t->kicked = 1;
1000 t->kick(t);
1001 }
1002 transport_unref_locked(t);
Dan Albertc7915a32015-05-18 16:46:31 -07001003
1004 it = transport_list.erase(it);
1005 } else {
1006 ++it;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001007 }
Dan Albertc7915a32015-05-18 16:46:31 -07001008 }
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001009
1010 adb_mutex_unlock(&transport_lock);
1011}
1012
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001013#endif
1014
Dan Albertc7915a32015-05-18 16:46:31 -07001015void register_usb_transport(usb_handle* usb, const char* serial,
1016 const char* devpath, unsigned writeable) {
1017 atransport* t = new atransport();
1018
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001019 D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
1020 serial ? serial : "");
Dan Albertdcd78a12015-05-18 16:43:57 -07001021 init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001022 if(serial) {
1023 t->serial = strdup(serial);
1024 }
Dan Albertc7915a32015-05-18 16:46:31 -07001025
1026 if (devpath) {
Scott Andersone109d262012-04-20 11:21:14 -07001027 t->devpath = strdup(devpath);
1028 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001029
1030 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001031 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -07001032 adb_mutex_unlock(&transport_lock);
1033
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001034 register_transport(t);
1035}
1036
Dan Albertdcd78a12015-05-18 16:43:57 -07001037// This should only be used for transports with connection_state == kCsNoPerm.
Dan Albertc7915a32015-05-18 16:46:31 -07001038void unregister_usb_transport(usb_handle *usb) {
Mike Lockwood0927bf92009-08-08 12:37:44 -04001039 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001040 transport_list.remove_if([usb](atransport* t) {
1041 return t->usb == usb && t->connection_state == kCsNoPerm;
1042 });
Mike Lockwood0927bf92009-08-08 12:37:44 -04001043 adb_mutex_unlock(&transport_lock);
1044}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001045
1046#undef TRACE_TAG
1047#define TRACE_TAG TRACE_RWX
1048
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001049int check_header(apacket *p, atransport *t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001050{
1051 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1052 D("check_header(): invalid magic\n");
1053 return -1;
1054 }
1055
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001056 if(p->msg.data_length > t->get_max_payload()) {
1057 D("check_header(): %u > atransport::max_payload = %zu\n",
1058 p->msg.data_length, t->get_max_payload());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001059 return -1;
1060 }
1061
1062 return 0;
1063}
1064
1065int check_data(apacket *p)
1066{
1067 unsigned count, sum;
1068 unsigned char *x;
1069
1070 count = p->msg.data_length;
1071 x = p->data;
1072 sum = 0;
1073 while(count-- > 0) {
1074 sum += *x++;
1075 }
1076
1077 if(sum != p->msg.data_check) {
1078 return -1;
1079 } else {
1080 return 0;
1081 }
1082}