blob: e3340afb3d8ba7277ab79d7731a7cfed5ac79423 [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
Yabin Cuiaed3c612015-09-22 15:52:57 -070017#define TRACE_TAG 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
Spencer Low363af562015-11-07 18:51:54 -080029#include <algorithm>
Dan Albertc7915a32015-05-18 16:46:31 -070030#include <list>
31
Elliott Hughes4f713192015-12-04 22:00:26 -080032#include <android-base/logging.h>
David Pursell3f902aa2016-03-01 08:58:26 -080033#include <android-base/parsenetaddress.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080034#include <android-base/stringprintf.h>
35#include <android-base/strings.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070036
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080037#include "adb.h"
Elliott Hughese67f1f82015-04-30 17:32:03 -070038#include "adb_utils.h"
Elliott Hughes1b708d32015-12-11 19:07:01 -080039#include "diagnose_usb.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080040
41static void transport_unref(atransport *t);
42
Josh Gaob7b1edf2015-11-11 17:56:12 -080043static auto& transport_list = *new std::list<atransport*>();
44static auto& pending_list = *new std::list<atransport*>();
Benoit Goby1c45ee92013-03-29 18:22:36 -070045
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080046ADB_MUTEX_DEFINE( transport_lock );
47
Todd Kennedy6fa848a2015-11-03 16:53:08 -080048const char* const kFeatureShell2 = "shell_v2";
49const char* const kFeatureCmd = "cmd";
50
Yabin Cuiaed3c612015-09-22 15:52:57 -070051static std::string dump_packet(const char* name, const char* func, apacket* p) {
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010052 unsigned command = p->msg.command;
53 int len = p->msg.data_length;
54 char cmd[9];
55 char arg0[12], arg1[12];
56 int n;
57
58 for (n = 0; n < 4; n++) {
59 int b = (command >> (n*8)) & 255;
60 if (b < 32 || b >= 127)
61 break;
62 cmd[n] = (char)b;
63 }
64 if (n == 4) {
65 cmd[4] = 0;
66 } else {
67 /* There is some non-ASCII name in the command, so dump
68 * the hexadecimal value instead */
69 snprintf(cmd, sizeof cmd, "%08x", command);
70 }
71
72 if (p->msg.arg0 < 256U)
73 snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
74 else
75 snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
76
77 if (p->msg.arg1 < 256U)
78 snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
79 else
80 snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
81
Yabin Cuiaed3c612015-09-22 15:52:57 -070082 std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
83 name, func, cmd, arg0, arg1, len);
84 result += dump_hex(p->data, len);
85 return result;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010086}
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010087
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080088static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010089read_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080090{
Yabin Cui62641292015-07-30 19:58:10 -070091 char buff[8];
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +010092 if (!name) {
93 snprintf(buff, sizeof buff, "fd=%d", fd);
94 name = buff;
95 }
Yabin Cui62641292015-07-30 19:58:10 -070096 char* p = reinterpret_cast<char*>(ppacket); /* really read a packet address */
97 int len = sizeof(apacket*);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080098 while(len > 0) {
Yabin Cui62641292015-07-30 19:58:10 -070099 int r = adb_read(fd, p, len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800100 if(r > 0) {
101 len -= r;
Yabin Cui62641292015-07-30 19:58:10 -0700102 p += r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800103 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700104 D("%s: read_packet (fd=%d), error ret=%d: %s", name, fd, r, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800105 return -1;
106 }
107 }
108
Yabin Cuiaed3c612015-09-22 15:52:57 -0700109 VLOG(TRANSPORT) << dump_packet(name, "from remote", *ppacket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800110 return 0;
111}
112
113static int
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100114write_packet(int fd, const char* name, apacket** ppacket)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800115{
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100116 char buff[8];
117 if (!name) {
118 snprintf(buff, sizeof buff, "fd=%d", fd);
119 name = buff;
120 }
Yabin Cuiaed3c612015-09-22 15:52:57 -0700121 VLOG(TRANSPORT) << dump_packet(name, "to remote", *ppacket);
Yabin Cui62641292015-07-30 19:58:10 -0700122 char* p = reinterpret_cast<char*>(ppacket); /* we really write the packet address */
123 int len = sizeof(apacket*);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800124 while(len > 0) {
Yabin Cui62641292015-07-30 19:58:10 -0700125 int r = adb_write(fd, p, len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800126 if(r > 0) {
127 len -= r;
128 p += r;
129 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700130 D("%s: write_packet (fd=%d) error ret=%d: %s", name, fd, r, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800131 return -1;
132 }
133 }
134 return 0;
135}
136
137static void transport_socket_events(int fd, unsigned events, void *_t)
138{
Dan Albertbac34742015-02-25 17:51:28 -0800139 atransport *t = reinterpret_cast<atransport*>(_t);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700140 D("transport_socket_events(fd=%d, events=%04x,...)", fd, events);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800141 if(events & FDE_READ){
142 apacket *p = 0;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100143 if(read_packet(fd, t->serial, &p)){
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700144 D("%s: failed to read packet from transport socket on fd %d", t->serial, fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800145 } else {
146 handle_packet(p, (atransport *) _t);
147 }
148 }
149}
150
151void send_packet(apacket *p, atransport *t)
152{
153 unsigned char *x;
154 unsigned sum;
155 unsigned count;
156
157 p->msg.magic = p->msg.command ^ 0xffffffff;
158
159 count = p->msg.data_length;
160 x = (unsigned char *) p->data;
161 sum = 0;
162 while(count-- > 0){
163 sum += *x++;
164 }
165 p->msg.data_check = sum;
166
167 print_packet("send", p);
168
169 if (t == NULL) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700170 D("Transport is null");
JP Abgrall408fa572011-03-16 15:57:42 -0700171 // Zap errno because print_packet() and other stuff have errno effect.
172 errno = 0;
173 fatal_errno("Transport is null");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800174 }
175
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100176 if(write_packet(t->transport_socket, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800177 fatal_errno("cannot enqueue packet on transport socket");
178 }
179}
180
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700181// The transport is opened by transport_register_func before
182// the read_transport and write_transport threads are started.
183//
184// The read_transport thread issues a SYNC(1, token) message to let
185// the write_transport thread know to start things up. In the event
186// of transport IO failure, the read_transport thread will post a
187// SYNC(0,0) message to ensure shutdown.
188//
189// The transport will not actually be closed until both threads exit, but the threads
190// will kick the transport on their way out to disconnect the underlying device.
191//
192// read_transport thread reads data from a transport (representing a usb/tcp connection),
193// and makes the main thread call handle_packet().
Josh Gaob5fea142016-02-12 14:31:15 -0800194static void read_transport_thread(void* _t) {
Dan Albertbac34742015-02-25 17:51:28 -0800195 atransport *t = reinterpret_cast<atransport*>(_t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800196 apacket *p;
197
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700198 adb_thread_setname(android::base::StringPrintf("<-%s",
199 (t->serial != nullptr ? t->serial : "transport")));
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700200 D("%s: starting read_transport thread on fd %d, SYNC online (%d)",
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100201 t->serial, t->fd, t->sync_token + 1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800202 p = get_apacket();
203 p->msg.command = A_SYNC;
204 p->msg.arg0 = 1;
205 p->msg.arg1 = ++(t->sync_token);
206 p->msg.magic = A_SYNC ^ 0xffffffff;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100207 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800208 put_apacket(p);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700209 D("%s: failed to write SYNC packet", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800210 goto oops;
211 }
212
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700213 D("%s: data pump started", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800214 for(;;) {
215 p = get_apacket();
216
217 if(t->read_from_remote(p, t) == 0){
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700218 D("%s: received remote packet, sending to transport",
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100219 t->serial);
220 if(write_packet(t->fd, t->serial, &p)){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800221 put_apacket(p);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700222 D("%s: failed to write apacket to transport", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800223 goto oops;
224 }
225 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700226 D("%s: remote read failed for transport", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800227 put_apacket(p);
228 break;
229 }
230 }
231
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700232 D("%s: SYNC offline for transport", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800233 p = get_apacket();
234 p->msg.command = A_SYNC;
235 p->msg.arg0 = 0;
236 p->msg.arg1 = 0;
237 p->msg.magic = A_SYNC ^ 0xffffffff;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100238 if(write_packet(t->fd, t->serial, &p)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800239 put_apacket(p);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700240 D("%s: failed to write SYNC apacket to transport", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800241 }
242
243oops:
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700244 D("%s: read_transport thread is exiting", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800245 kick_transport(t);
246 transport_unref(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800247}
248
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700249// write_transport thread gets packets sent by the main thread (through send_packet()),
250// and writes to a transport (representing a usb/tcp connection).
Josh Gaob5fea142016-02-12 14:31:15 -0800251static void write_transport_thread(void* _t) {
Dan Albertbac34742015-02-25 17:51:28 -0800252 atransport *t = reinterpret_cast<atransport*>(_t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800253 apacket *p;
254 int active = 0;
255
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700256 adb_thread_setname(android::base::StringPrintf("->%s",
257 (t->serial != nullptr ? t->serial : "transport")));
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700258 D("%s: starting write_transport thread, reading from fd %d",
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100259 t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800260
261 for(;;){
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100262 if(read_packet(t->fd, t->serial, &p)) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700263 D("%s: failed to read apacket from transport on fd %d",
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100264 t->serial, t->fd );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800265 break;
266 }
267 if(p->msg.command == A_SYNC){
268 if(p->msg.arg0 == 0) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700269 D("%s: transport SYNC offline", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800270 put_apacket(p);
271 break;
272 } else {
273 if(p->msg.arg1 == t->sync_token) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700274 D("%s: transport SYNC online", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800275 active = 1;
276 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700277 D("%s: transport ignoring SYNC %d != %d",
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100278 t->serial, p->msg.arg1, t->sync_token);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800279 }
280 }
281 } else {
282 if(active) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700283 D("%s: transport got packet, sending to remote", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800284 t->write_to_remote(p, t);
285 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700286 D("%s: transport ignoring packet while offline", t->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800287 }
288 }
289
290 put_apacket(p);
291 }
292
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700293 D("%s: write_transport thread is exiting, fd %d", t->serial, t->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800294 kick_transport(t);
295 transport_unref(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800296}
297
Yabin Cuif4b99282015-08-27 12:03:11 -0700298static void kick_transport_locked(atransport* t) {
299 CHECK(t != nullptr);
300 if (!t->kicked) {
301 t->kicked = true;
302 t->kick(t);
303 }
304}
305
306void kick_transport(atransport* t) {
307 adb_mutex_lock(&transport_lock);
308 kick_transport_locked(t);
309 adb_mutex_unlock(&transport_lock);
310}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800311
312static int transport_registration_send = -1;
313static int transport_registration_recv = -1;
314static fdevent transport_registration_fde;
315
316
317#if ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800318
319/* this adds support required by the 'track-devices' service.
320 * this is used to send the content of "list_transport" to any
321 * number of client connections that want it through a single
322 * live TCP connection
323 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800324struct device_tracker {
325 asocket socket;
326 int update_needed;
327 device_tracker* next;
328};
329
330/* linked list of all device trackers */
331static device_tracker* device_tracker_list;
332
333static void
334device_tracker_remove( device_tracker* tracker )
335{
336 device_tracker** pnode = &device_tracker_list;
337 device_tracker* node = *pnode;
338
339 adb_mutex_lock( &transport_lock );
340 while (node) {
341 if (node == tracker) {
342 *pnode = node->next;
343 break;
344 }
345 pnode = &node->next;
346 node = *pnode;
347 }
348 adb_mutex_unlock( &transport_lock );
349}
350
351static void
352device_tracker_close( asocket* socket )
353{
354 device_tracker* tracker = (device_tracker*) socket;
355 asocket* peer = socket->peer;
356
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700357 D( "device tracker %p removed", tracker);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800358 if (peer) {
359 peer->peer = NULL;
360 peer->close(peer);
361 }
362 device_tracker_remove(tracker);
363 free(tracker);
364}
365
366static int
367device_tracker_enqueue( asocket* socket, apacket* p )
368{
369 /* you can't read from a device tracker, close immediately */
370 put_apacket(p);
371 device_tracker_close(socket);
372 return -1;
373}
374
Elliott Hughese67f1f82015-04-30 17:32:03 -0700375static int device_tracker_send(device_tracker* tracker, const std::string& string) {
376 apacket* p = get_apacket();
377 asocket* peer = tracker->socket.peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800378
Elliott Hughese67f1f82015-04-30 17:32:03 -0700379 snprintf(reinterpret_cast<char*>(p->data), 5, "%04x", static_cast<int>(string.size()));
380 memcpy(&p->data[4], string.data(), string.size());
381 p->len = 4 + string.size();
382 return peer->enqueue(peer, p);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800383}
384
Elliott Hughese67f1f82015-04-30 17:32:03 -0700385static void device_tracker_ready(asocket* socket) {
386 device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800387
Elliott Hughese67f1f82015-04-30 17:32:03 -0700388 // We want to send the device list when the tracker connects
389 // for the first time, even if no update occurred.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800390 if (tracker->update_needed > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800391 tracker->update_needed = 0;
392
Elliott Hughese67f1f82015-04-30 17:32:03 -0700393 std::string transports = list_transports(false);
394 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800395 }
396}
397
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800398asocket*
399create_device_tracker(void)
400{
Elliott Hughesdc3b4592015-04-21 19:39:52 -0700401 device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
402 if (tracker == nullptr) fatal("cannot allocate device tracker");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800403
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700404 D( "device tracker %p created", tracker);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800405
406 tracker->socket.enqueue = device_tracker_enqueue;
407 tracker->socket.ready = device_tracker_ready;
408 tracker->socket.close = device_tracker_close;
409 tracker->update_needed = 1;
410
411 tracker->next = device_tracker_list;
412 device_tracker_list = tracker;
413
414 return &tracker->socket;
415}
416
417
Elliott Hughese67f1f82015-04-30 17:32:03 -0700418// Call this function each time the transport list has changed.
419void update_transports() {
420 std::string transports = list_transports(false);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800421
Elliott Hughese67f1f82015-04-30 17:32:03 -0700422 device_tracker* tracker = device_tracker_list;
423 while (tracker != nullptr) {
424 device_tracker* next = tracker->next;
425 // This may destroy the tracker if the connection is closed.
426 device_tracker_send(tracker, transports);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800427 tracker = next;
428 }
429}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700430
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800431#else
Elliott Hughese67f1f82015-04-30 17:32:03 -0700432
433void update_transports() {
434 // Nothing to do on the device side.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800435}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700436
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800437#endif // ADB_HOST
438
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800439struct tmsg
440{
441 atransport *transport;
442 int action;
443};
444
445static int
446transport_read_action(int fd, struct tmsg* m)
447{
448 char *p = (char*)m;
449 int len = sizeof(*m);
450 int r;
451
452 while(len > 0) {
453 r = adb_read(fd, p, len);
454 if(r > 0) {
455 len -= r;
456 p += r;
457 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700458 D("transport_read_action: on fd %d: %s", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800459 return -1;
460 }
461 }
462 return 0;
463}
464
465static int
466transport_write_action(int fd, struct tmsg* m)
467{
468 char *p = (char*)m;
469 int len = sizeof(*m);
470 int r;
471
472 while(len > 0) {
473 r = adb_write(fd, p, len);
474 if(r > 0) {
475 len -= r;
476 p += r;
477 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700478 D("transport_write_action: on fd %d: %s", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800479 return -1;
480 }
481 }
482 return 0;
483}
484
485static void transport_registration_func(int _fd, unsigned ev, void *data)
486{
487 tmsg m;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800488 int s[2];
489 atransport *t;
490
491 if(!(ev & FDE_READ)) {
492 return;
493 }
494
495 if(transport_read_action(_fd, &m)) {
496 fatal_errno("cannot read transport registration socket");
497 }
498
499 t = m.transport;
500
Dan Albert1792c232015-05-18 13:06:53 -0700501 if (m.action == 0) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700502 D("transport: %s removing and free'ing %d", t->serial, t->transport_socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800503
504 /* IMPORTANT: the remove closes one half of the
505 ** socket pair. The close closes the other half.
506 */
507 fdevent_remove(&(t->transport_fde));
508 adb_close(t->fd);
509
510 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700511 transport_list.remove(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800512 adb_mutex_unlock(&transport_lock);
513
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800514 if (t->product)
515 free(t->product);
516 if (t->serial)
517 free(t->serial);
Scott Andersone82c2db2012-05-25 14:10:02 -0700518 if (t->model)
519 free(t->model);
520 if (t->device)
521 free(t->device);
Scott Andersone109d262012-04-20 11:21:14 -0700522 if (t->devpath)
523 free(t->devpath);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800524
Dan Albertc7915a32015-05-18 16:46:31 -0700525 delete t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800526
527 update_transports();
528 return;
529 }
530
Mike Lockwood0927bf92009-08-08 12:37:44 -0400531 /* don't create transport threads for inaccessible devices */
Dan Albertdcd78a12015-05-18 16:43:57 -0700532 if (t->connection_state != kCsNoPerm) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800533 /* initial references are the two threads */
Mike Lockwood0927bf92009-08-08 12:37:44 -0400534 t->ref_count = 2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800535
Dan Albertc7915a32015-05-18 16:46:31 -0700536 if (adb_socketpair(s)) {
Mike Lockwood0927bf92009-08-08 12:37:44 -0400537 fatal_errno("cannot open transport socketpair");
538 }
539
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700540 D("transport: %s socketpair: (%d,%d) starting", t->serial, s[0], s[1]);
Mike Lockwood0927bf92009-08-08 12:37:44 -0400541
542 t->transport_socket = s[0];
543 t->fd = s[1];
544
Mike Lockwood0927bf92009-08-08 12:37:44 -0400545 fdevent_install(&(t->transport_fde),
546 t->transport_socket,
547 transport_socket_events,
548 t);
549
550 fdevent_set(&(t->transport_fde), FDE_READ);
551
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700552 if (!adb_thread_create(write_transport_thread, t)) {
553 fatal_errno("cannot create write_transport thread");
Mike Lockwood0927bf92009-08-08 12:37:44 -0400554 }
555
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700556 if (!adb_thread_create(read_transport_thread, t)) {
557 fatal_errno("cannot create read_transport thread");
Mike Lockwood0927bf92009-08-08 12:37:44 -0400558 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800559 }
560
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800561 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700562 pending_list.remove(t);
563 transport_list.push_front(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800564 adb_mutex_unlock(&transport_lock);
565
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800566 update_transports();
567}
568
569void init_transport_registration(void)
570{
571 int s[2];
572
573 if(adb_socketpair(s)){
574 fatal_errno("cannot open transport registration socketpair");
575 }
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700576 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800577
578 transport_registration_send = s[0];
579 transport_registration_recv = s[1];
580
581 fdevent_install(&transport_registration_fde,
582 transport_registration_recv,
583 transport_registration_func,
584 0);
585
586 fdevent_set(&transport_registration_fde, FDE_READ);
587}
588
589/* the fdevent select pump is single threaded */
590static void register_transport(atransport *transport)
591{
592 tmsg m;
593 m.transport = transport;
594 m.action = 1;
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700595 D("transport: %s registered", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800596 if(transport_write_action(transport_registration_send, &m)) {
597 fatal_errno("cannot write transport registration socket\n");
598 }
599}
600
601static void remove_transport(atransport *transport)
602{
603 tmsg m;
604 m.transport = transport;
605 m.action = 0;
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700606 D("transport: %s removed", transport->serial);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800607 if(transport_write_action(transport_registration_send, &m)) {
608 fatal_errno("cannot write transport registration socket\n");
609 }
610}
611
612
Yabin Cuif4b99282015-08-27 12:03:11 -0700613static void transport_unref(atransport* t) {
614 CHECK(t != nullptr);
615 adb_mutex_lock(&transport_lock);
616 CHECK_GT(t->ref_count, 0u);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400617 t->ref_count--;
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400618 if (t->ref_count == 0) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700619 D("transport: %s unref (kicking and closing)", t->serial);
Yabin Cuif4b99282015-08-27 12:03:11 -0700620 kick_transport_locked(t);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400621 t->close(t);
622 remove_transport(t);
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100623 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700624 D("transport: %s unref (count=%zu)", t->serial, t->ref_count);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400625 }
Yabin Cuif4b99282015-08-27 12:03:11 -0700626 adb_mutex_unlock(&transport_lock);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800627}
628
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700629static int qual_match(const char *to_test,
Elliott Hughes09a45a12015-04-03 16:12:15 -0700630 const char *prefix, const char *qual, bool sanitize_qual)
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700631{
632 if (!to_test || !*to_test)
633 /* Return true if both the qual and to_test are null strings. */
634 return !qual || !*qual;
635
636 if (!qual)
637 return 0;
638
639 if (prefix) {
640 while (*prefix) {
641 if (*prefix++ != *to_test++)
642 return 0;
643 }
644 }
645
646 while (*qual) {
647 char ch = *qual++;
Elliott Hughes09a45a12015-04-03 16:12:15 -0700648 if (sanitize_qual && !isalnum(ch))
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700649 ch = '_';
650 if (ch != *to_test++)
651 return 0;
652 }
653
654 /* Everything matched so far. Return true if *to_test is a NUL. */
655 return !*to_test;
656}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800657
Elliott Hughes8d28e192015-10-07 14:55:10 -0700658atransport* acquire_one_transport(TransportType type, const char* serial,
659 bool* is_ambiguous, std::string* error_out) {
660 atransport* result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800661
Elliott Hughes8d28e192015-10-07 14:55:10 -0700662 if (serial) {
663 *error_out = android::base::StringPrintf("device '%s' not found", serial);
664 } else if (type == kTransportLocal) {
665 *error_out = "no emulators found";
666 } else if (type == kTransportAny) {
667 *error_out = "no devices/emulators found";
668 } else {
669 *error_out = "no devices found";
670 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800671
672 adb_mutex_lock(&transport_lock);
Elliott Hughes8d28e192015-10-07 14:55:10 -0700673 for (const auto& t : transport_list) {
Dan Albertdcd78a12015-05-18 16:43:57 -0700674 if (t->connection_state == kCsNoPerm) {
Elliott Hughes1b708d32015-12-11 19:07:01 -0800675#if ADB_HOST
David Purselld2acbd12015-12-02 15:14:31 -0800676 *error_out = UsbNoPermissionsLongHelpText();
Elliott Hughes1b708d32015-12-11 19:07:01 -0800677#endif
Mike Lockwood37d31112009-08-08 13:53:16 -0400678 continue;
679 }
Mike Lockwood0927bf92009-08-08 12:37:44 -0400680
Elliott Hughes8d28e192015-10-07 14:55:10 -0700681 // Check for matching serial number.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800682 if (serial) {
David Pursell3f902aa2016-03-01 08:58:26 -0800683 if (t->MatchesTarget(serial)) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700684 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700685 *error_out = "more than one device";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700686 if (is_ambiguous) *is_ambiguous = true;
687 result = nullptr;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700688 break;
689 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800690 result = t;
Scott Andersone109d262012-04-20 11:21:14 -0700691 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800692 } else {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700693 if (type == kTransportUsb && t->type == kTransportUsb) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800694 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700695 *error_out = "more than one device";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700696 if (is_ambiguous) *is_ambiguous = true;
697 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800698 break;
699 }
700 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700701 } else if (type == kTransportLocal && t->type == kTransportLocal) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800702 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700703 *error_out = "more than one emulator";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700704 if (is_ambiguous) *is_ambiguous = true;
705 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800706 break;
707 }
708 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700709 } else if (type == kTransportAny) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800710 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700711 *error_out = "more than one device/emulator";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700712 if (is_ambiguous) *is_ambiguous = true;
713 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800714 break;
715 }
716 result = t;
717 }
718 }
719 }
720 adb_mutex_unlock(&transport_lock);
721
Elliott Hughes8d28e192015-10-07 14:55:10 -0700722 // Don't return unauthorized devices; the caller can't do anything with them.
723 if (result && result->connection_state == kCsUnauthorized) {
724 *error_out = "device unauthorized.\n";
725 char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
726 *error_out += "This adb server's $ADB_VENDOR_KEYS is ";
727 *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
728 *error_out += "\n";
729 *error_out += "Try 'adb kill-server' if that seems wrong.\n";
730 *error_out += "Otherwise check for a confirmation dialog on your device.";
731 result = nullptr;
732 }
Benoit Goby77e8e582013-01-15 12:36:47 -0800733
Elliott Hughes8d28e192015-10-07 14:55:10 -0700734 // Don't return offline devices; the caller can't do anything with them.
735 if (result && result->connection_state == kCsOffline) {
736 *error_out = "device offline";
737 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800738 }
739
740 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700741 *error_out = "success";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800742 }
743
744 return result;
745}
746
David Purselld2acbd12015-12-02 15:14:31 -0800747const std::string atransport::connection_state_name() const {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700748 switch (connection_state) {
David Purselld2acbd12015-12-02 15:14:31 -0800749 case kCsOffline: return "offline";
750 case kCsBootloader: return "bootloader";
751 case kCsDevice: return "device";
752 case kCsHost: return "host";
753 case kCsRecovery: return "recovery";
Elliott Hughes1b708d32015-12-11 19:07:01 -0800754 case kCsNoPerm: return UsbNoPermissionsShortHelpText();
David Purselld2acbd12015-12-02 15:14:31 -0800755 case kCsSideload: return "sideload";
756 case kCsUnauthorized: return "unauthorized";
757 default: return "unknown";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800758 }
759}
760
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100761void atransport::update_version(int version, size_t payload) {
762 protocol_version = std::min(version, A_VERSION);
763 max_payload = std::min(payload, MAX_PAYLOAD);
764}
765
766int atransport::get_protocol_version() const {
767 return protocol_version;
768}
769
770size_t atransport::get_max_payload() const {
771 return max_payload;
772}
773
David Pursell4e2fd362015-09-22 10:43:08 -0700774namespace {
David Pursell0955c662015-08-31 10:42:13 -0700775
David Pursell4e2fd362015-09-22 10:43:08 -0700776constexpr char kFeatureStringDelimiter = ',';
777
778} // namespace
Dan Albert1792c232015-05-18 13:06:53 -0700779
780const FeatureSet& supported_features() {
David Pursell4e2fd362015-09-22 10:43:08 -0700781 // Local static allocation to avoid global non-POD variables.
782 static const FeatureSet* features = new FeatureSet{
Todd Kennedy6fa848a2015-11-03 16:53:08 -0800783 kFeatureShell2,
Elliott Hughes79e1c7a2015-11-06 18:05:16 -0800784 // Internal master has 'cmd'. AOSP master doesn't.
785 // kFeatureCmd
786
David Pursellbbe3d212015-09-25 08:37:13 -0700787 // Increment ADB_SERVER_VERSION whenever the feature list changes to
788 // make sure that the adb client and server features stay in sync
789 // (http://b/24370690).
David Pursell4e2fd362015-09-22 10:43:08 -0700790 };
791
792 return *features;
793}
794
795std::string FeatureSetToString(const FeatureSet& features) {
796 return android::base::Join(features, kFeatureStringDelimiter);
797}
798
799FeatureSet StringToFeatureSet(const std::string& features_string) {
David Purselld2b588e2015-09-25 13:04:21 -0700800 if (features_string.empty()) {
801 return FeatureSet();
802 }
803
David Pursell4e2fd362015-09-22 10:43:08 -0700804 auto names = android::base::Split(features_string,
805 {kFeatureStringDelimiter});
806 return FeatureSet(names.begin(), names.end());
Dan Albert1792c232015-05-18 13:06:53 -0700807}
808
David Pursell70ef7b42015-09-30 13:35:42 -0700809bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
810 return feature_set.count(feature) > 0 &&
811 supported_features().count(feature) > 0;
812}
813
Dan Albert1792c232015-05-18 13:06:53 -0700814bool atransport::has_feature(const std::string& feature) const {
815 return features_.count(feature) > 0;
816}
817
David Pursell4e2fd362015-09-22 10:43:08 -0700818void atransport::SetFeatures(const std::string& features_string) {
819 features_ = StringToFeatureSet(features_string);
Dan Albert1792c232015-05-18 13:06:53 -0700820}
821
Yabin Cuib3298242015-08-28 15:09:44 -0700822void atransport::AddDisconnect(adisconnect* disconnect) {
823 disconnects_.push_back(disconnect);
824}
825
826void atransport::RemoveDisconnect(adisconnect* disconnect) {
827 disconnects_.remove(disconnect);
828}
829
830void atransport::RunDisconnects() {
Elliott Hughes65fe2512015-10-07 15:59:35 -0700831 for (const auto& disconnect : disconnects_) {
Yabin Cuib3298242015-08-28 15:09:44 -0700832 disconnect->func(disconnect->opaque, this);
833 }
834 disconnects_.clear();
835}
836
David Pursell3f902aa2016-03-01 08:58:26 -0800837bool atransport::MatchesTarget(const std::string& target) const {
838 if (serial) {
839 if (target == serial) {
840 return true;
841 } else if (type == kTransportLocal) {
842 // Local transports can match [tcp:|udp:]<hostname>[:port].
843 const char* local_target_ptr = target.c_str();
844
845 // For fastboot compatibility, ignore protocol prefixes.
846 if (android::base::StartsWith(target, "tcp:") ||
847 android::base::StartsWith(target, "udp:")) {
848 local_target_ptr += 4;
849 }
850
851 // Parse our |serial| and the given |target| to check if the hostnames and ports match.
852 std::string serial_host, error;
853 int serial_port = -1;
854 if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr,
855 &error)) {
856 // |target| may omit the port to default to ours.
857 std::string target_host;
858 int target_port = serial_port;
859 if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port,
860 nullptr, &error) &&
861 serial_host == target_host && serial_port == target_port) {
862 return true;
863 }
864 }
865 }
866 }
867
868 return (devpath && target == devpath) ||
869 qual_match(target.c_str(), "product:", product, false) ||
870 qual_match(target.c_str(), "model:", model, true) ||
871 qual_match(target.c_str(), "device:", device, false);
872}
873
Elliott Hughese67f1f82015-04-30 17:32:03 -0700874#if ADB_HOST
875
Dan Albertd99d9022015-05-06 16:48:52 -0700876static void append_transport_info(std::string* result, const char* key,
877 const char* value, bool sanitize) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700878 if (value == nullptr || *value == '\0') {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700879 return;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700880 }
881
Elliott Hughese67f1f82015-04-30 17:32:03 -0700882 *result += ' ';
883 *result += key;
884
885 for (const char* p = value; *p; ++p) {
886 result->push_back((!sanitize || isalnum(*p)) ? *p : '_');
887 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700888}
889
Dan Albertc7915a32015-05-18 16:46:31 -0700890static void append_transport(const atransport* t, std::string* result,
891 bool long_listing) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700892 const char* serial = t->serial;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700893 if (!serial || !serial[0]) {
Dan Albertd99d9022015-05-06 16:48:52 -0700894 serial = "(no serial number)";
Elliott Hughese67f1f82015-04-30 17:32:03 -0700895 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700896
897 if (!long_listing) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700898 *result += serial;
899 *result += '\t';
900 *result += t->connection_state_name();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700901 } else {
David Purselld2acbd12015-12-02 15:14:31 -0800902 android::base::StringAppendF(result, "%-22s %s", serial,
903 t->connection_state_name().c_str());
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700904
Elliott Hughese67f1f82015-04-30 17:32:03 -0700905 append_transport_info(result, "", t->devpath, false);
906 append_transport_info(result, "product:", t->product, false);
907 append_transport_info(result, "model:", t->model, true);
908 append_transport_info(result, "device:", t->device, false);
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700909 }
Elliott Hughese67f1f82015-04-30 17:32:03 -0700910 *result += '\n';
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700911}
912
Elliott Hughese67f1f82015-04-30 17:32:03 -0700913std::string list_transports(bool long_listing) {
914 std::string result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800915 adb_mutex_lock(&transport_lock);
Elliott Hughes65fe2512015-10-07 15:59:35 -0700916 for (const auto& t : transport_list) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700917 append_transport(t, &result, long_listing);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800918 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800919 adb_mutex_unlock(&transport_lock);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700920 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800921}
922
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800923/* hack for osx */
Dan Albertc7915a32015-05-18 16:46:31 -0700924void close_usb_devices() {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800925 adb_mutex_lock(&transport_lock);
Elliott Hughes65fe2512015-10-07 15:59:35 -0700926 for (const auto& t : transport_list) {
Dan Albertc7915a32015-05-18 16:46:31 -0700927 if (!t->kicked) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800928 t->kicked = 1;
929 t->kick(t);
930 }
931 }
932 adb_mutex_unlock(&transport_lock);
933}
934#endif // ADB_HOST
935
Dan Albertc7915a32015-05-18 16:46:31 -0700936int register_socket_transport(int s, const char *serial, int port, int local) {
937 atransport* t = new atransport();
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100938
939 if (!serial) {
Dan Albertc7915a32015-05-18 16:46:31 -0700940 char buf[32];
941 snprintf(buf, sizeof(buf), "T-%p", t);
942 serial = buf;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +0100943 }
Dan Albertc7915a32015-05-18 16:46:31 -0700944
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700945 D("transport: %s init'ing for socket %d, on port %d", serial, s, port);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700946 if (init_socket_transport(t, s, port, local) < 0) {
Dan Albertc7915a32015-05-18 16:46:31 -0700947 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700948 return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800949 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700950
951 adb_mutex_lock(&transport_lock);
Elliott Hughes65fe2512015-10-07 15:59:35 -0700952 for (const auto& transport : pending_list) {
Dan Albertc7915a32015-05-18 16:46:31 -0700953 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700954 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700955 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700956 return -1;
957 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800958 }
Benoit Goby1c45ee92013-03-29 18:22:36 -0700959
Elliott Hughes65fe2512015-10-07 15:59:35 -0700960 for (const auto& transport : transport_list) {
Dan Albertc7915a32015-05-18 16:46:31 -0700961 if (transport->serial && strcmp(serial, transport->serial) == 0) {
Benoit Goby1c45ee92013-03-29 18:22:36 -0700962 adb_mutex_unlock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -0700963 delete t;
Benoit Goby1c45ee92013-03-29 18:22:36 -0700964 return -1;
965 }
966 }
967
Dan Albertc7915a32015-05-18 16:46:31 -0700968 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700969 t->serial = strdup(serial);
970 adb_mutex_unlock(&transport_lock);
971
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800972 register_transport(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -0700973 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800974}
975
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400976#if ADB_HOST
Dan Albertc7915a32015-05-18 16:46:31 -0700977atransport *find_transport(const char *serial) {
978 atransport* result = nullptr;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400979
980 adb_mutex_lock(&transport_lock);
Yabin Cuif4b99282015-08-27 12:03:11 -0700981 for (auto& t : transport_list) {
Dan Albertc7915a32015-05-18 16:46:31 -0700982 if (t->serial && strcmp(serial, t->serial) == 0) {
983 result = t;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400984 break;
985 }
Dan Albertc7915a32015-05-18 16:46:31 -0700986 }
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400987 adb_mutex_unlock(&transport_lock);
988
Dan Albertc7915a32015-05-18 16:46:31 -0700989 return result;
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400990}
991
Yabin Cuif4b99282015-08-27 12:03:11 -0700992void kick_all_tcp_devices() {
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400993 adb_mutex_lock(&transport_lock);
Yabin Cuif4b99282015-08-27 12:03:11 -0700994 for (auto& t : transport_list) {
995 // TCP/IP devices have adb_port == 0.
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -0400996 if (t->type == kTransportLocal && t->adb_port == 0) {
Yabin Cuid6ab3c22015-08-31 11:50:24 -0700997 // Kicking breaks the read_transport thread of this transport out of any read, then
998 // the read_transport thread will notify the main thread to make this transport
999 // offline. Then the main thread will notify the write_transport thread to exit.
Yabin Cuif4b99282015-08-27 12:03:11 -07001000 // Finally, this transport will be closed and freed in the main thread.
1001 kick_transport_locked(t);
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001002 }
Dan Albertc7915a32015-05-18 16:46:31 -07001003 }
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001004 adb_mutex_unlock(&transport_lock);
1005}
1006
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001007#endif
1008
Dan Albertc7915a32015-05-18 16:46:31 -07001009void register_usb_transport(usb_handle* usb, const char* serial,
1010 const char* devpath, unsigned writeable) {
1011 atransport* t = new atransport();
1012
Yabin Cui7a3f8d62015-09-02 17:44:28 -07001013 D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb,
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001014 serial ? serial : "");
Dan Albertdcd78a12015-05-18 16:43:57 -07001015 init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001016 if(serial) {
1017 t->serial = strdup(serial);
1018 }
Dan Albertc7915a32015-05-18 16:46:31 -07001019
1020 if (devpath) {
Scott Andersone109d262012-04-20 11:21:14 -07001021 t->devpath = strdup(devpath);
1022 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001023
1024 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001025 pending_list.push_front(t);
Benoit Goby1c45ee92013-03-29 18:22:36 -07001026 adb_mutex_unlock(&transport_lock);
1027
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001028 register_transport(t);
1029}
1030
Dan Albertdcd78a12015-05-18 16:43:57 -07001031// This should only be used for transports with connection_state == kCsNoPerm.
Dan Albertc7915a32015-05-18 16:46:31 -07001032void unregister_usb_transport(usb_handle *usb) {
Mike Lockwood0927bf92009-08-08 12:37:44 -04001033 adb_mutex_lock(&transport_lock);
Dan Albertc7915a32015-05-18 16:46:31 -07001034 transport_list.remove_if([usb](atransport* t) {
1035 return t->usb == usb && t->connection_state == kCsNoPerm;
1036 });
Mike Lockwood0927bf92009-08-08 12:37:44 -04001037 adb_mutex_unlock(&transport_lock);
1038}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001039
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001040int check_header(apacket *p, atransport *t)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001041{
1042 if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
Yabin Cuiaed3c612015-09-22 15:52:57 -07001043 VLOG(RWX) << "check_header(): invalid magic";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001044 return -1;
1045 }
1046
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001047 if(p->msg.data_length > t->get_max_payload()) {
Yabin Cuiaed3c612015-09-22 15:52:57 -07001048 VLOG(RWX) << "check_header(): " << p->msg.data_length << " atransport::max_payload = "
1049 << t->get_max_payload();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001050 return -1;
1051 }
1052
1053 return 0;
1054}
1055
1056int check_data(apacket *p)
1057{
1058 unsigned count, sum;
1059 unsigned char *x;
1060
1061 count = p->msg.data_length;
1062 x = p->data;
1063 sum = 0;
1064 while(count-- > 0) {
1065 sum += *x++;
1066 }
1067
1068 if(sum != p->msg.data_check) {
1069 return -1;
1070 } else {
1071 return 0;
1072 }
1073}