blob: 6dccb7f68b11d4266e0278bc934679d3452c50a5 [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"
Josh Gao31b5be62018-03-07 16:51:08 -080020
Dan Albert76649012015-02-24 15:51:19 -080021#include "transport.h"
22
Dan Albert055f1aa2015-02-20 17:24:58 -080023#include <ctype.h>
Dan Albert76649012015-02-24 15:51:19 -080024#include <errno.h>
Josh Gaob122b172017-08-16 16:57:01 -070025#include <inttypes.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080026#include <stdio.h>
27#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080028#include <string.h>
Dan Albert76649012015-02-24 15:51:19 -080029#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080030
Spencer Low363af562015-11-07 18:51:54 -080031#include <algorithm>
Josh Gao0bbf69c2018-02-16 13:24:58 -080032#include <deque>
Dan Albertc7915a32015-05-18 16:46:31 -070033#include <list>
Pirama Arumuga Nainar29e3dd82018-08-08 10:33:24 -070034#include <memory>
Josh Gao0cd3ae12016-09-21 12:37:10 -070035#include <mutex>
Josh Gao8a40c8a2018-08-10 14:28:24 -070036#include <set>
Josh Gaoe1dacfc2017-04-12 17:00:49 -070037#include <thread>
Dan Albertc7915a32015-05-18 16:46:31 -070038
Joshua Duong5cf78682020-01-21 13:19:42 -080039#include <adb/crypto/rsa_2048_key.h>
40#include <adb/crypto/x509_generator.h>
41#include <adb/tls/tls_connection.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080042#include <android-base/logging.h>
David Pursell3f902aa2016-03-01 08:58:26 -080043#include <android-base/parsenetaddress.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080044#include <android-base/stringprintf.h>
45#include <android-base/strings.h>
Josh Gaob122b172017-08-16 16:57:01 -070046#include <android-base/thread_annotations.h>
Elliott Hughese67f1f82015-04-30 17:32:03 -070047
Josh Gao27768452018-01-02 12:01:43 -080048#include <diagnose_usb.h>
49
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080050#include "adb.h"
Elliott Hughes0aeb5052016-06-29 17:42:01 -070051#include "adb_auth.h"
Josh Gaob800d882018-01-28 20:32:46 -080052#include "adb_io.h"
Josh Gaocfe72e22016-11-29 09:40:29 -080053#include "adb_trace.h"
Elliott Hughese67f1f82015-04-30 17:32:03 -070054#include "adb_utils.h"
Josh Gao57e09b12019-06-28 13:50:37 -070055#include "fdevent/fdevent.h"
Josh Gaoe445a6d2018-07-31 14:12:59 -070056#include "sysdeps/chrono.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080057
Joshua Duong5cf78682020-01-21 13:19:42 -080058using namespace adb::crypto;
59using namespace adb::tls;
Josh Gao982f7bd2019-02-12 13:59:03 -080060using android::base::ScopedLockAssertion;
Joshua Duong5cf78682020-01-21 13:19:42 -080061using TlsError = TlsConnection::TlsError;
Josh Gao982f7bd2019-02-12 13:59:03 -080062
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -070063static void remove_transport(atransport* transport);
Josh Gao9a8366b2019-12-09 13:45:31 -080064static void transport_destroy(atransport* transport);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080065
Josh Gaob122b172017-08-16 16:57:01 -070066// TODO: unordered_map<TransportId, atransport*>
Josh Gaob7b1edf2015-11-11 17:56:12 -080067static auto& transport_list = *new std::list<atransport*>();
68static auto& pending_list = *new std::list<atransport*>();
Benoit Goby1c45ee92013-03-29 18:22:36 -070069
Josh Gao1db71af2017-08-17 13:50:51 -070070static auto& transport_lock = *new std::recursive_mutex();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080071
Todd Kennedy51c05ec2015-11-10 00:03:25 +000072const char* const kFeatureShell2 = "shell_v2";
73const char* const kFeatureCmd = "cmd";
Josh Gao5a1e3fd2016-12-05 17:11:34 -080074const char* const kFeatureStat2 = "stat_v2";
Josh Gao34a478f2019-08-07 14:23:17 -070075const char* const kFeatureLs2 = "ls_v2";
Josh Gao5d1756c2017-02-22 17:07:01 -080076const char* const kFeatureLibusb = "libusb";
Dan Albert5176df82017-05-23 14:30:00 -070077const char* const kFeaturePushSync = "push_sync";
Dario Freni29814de2018-10-04 16:26:40 +010078const char* const kFeatureApex = "apex";
Josh Gaofb085102018-10-22 13:00:05 -070079const char* const kFeatureFixedPushMkdir = "fixed_push_mkdir";
Alex Buynytskyy01a65ee2019-01-17 13:13:56 -080080const char* const kFeatureAbb = "abb";
Josh Gao7b1cb662019-02-20 13:01:40 -080081const char* const kFeatureFixedPushSymlinkTimestamp = "fixed_push_symlink_timestamp";
Alex Buynytskyy05626c12019-02-21 14:22:51 -080082const char* const kFeatureAbbExec = "abb_exec";
Josh Gao8c2198c2019-07-11 14:15:32 -070083const char* const kFeatureRemountShell = "remount_shell";
Shukang Zhouf4ffae12020-02-13 17:01:39 -080084const char* const kFeatureTrackApp = "track_app";
Josh Gao939fc192020-03-04 19:34:08 -080085const char* const kFeatureSendRecv2 = "sendrecv_v2";
86const char* const kFeatureSendRecv2Brotli = "sendrecv_v2_brotli";
Todd Kennedy51c05ec2015-11-10 00:03:25 +000087
Luis Hector Chavez56fe7532018-04-17 14:25:04 -070088namespace {
89
Josh Gaodef91c02018-07-31 18:28:32 -070090#if ADB_HOST
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -070091// Tracks and handles atransport*s that are attempting reconnection.
92class ReconnectHandler {
93 public:
94 ReconnectHandler() = default;
95 ~ReconnectHandler() = default;
96
97 // Starts the ReconnectHandler thread.
98 void Start();
99
100 // Requests the ReconnectHandler thread to stop.
101 void Stop();
102
103 // Adds the atransport* to the queue of reconnect attempts.
104 void TrackTransport(atransport* transport);
105
Josh Gao902dace2018-08-10 14:44:54 -0700106 // Wake up the ReconnectHandler thread to have it check for kicked transports.
107 void CheckForKicked();
108
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700109 private:
110 // The main thread loop.
111 void Run();
112
113 // Tracks a reconnection attempt.
114 struct ReconnectAttempt {
115 atransport* transport;
Josh Gao95af6412018-07-30 18:51:55 -0700116 std::chrono::steady_clock::time_point reconnect_time;
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700117 size_t attempts_left;
Josh Gaoe445a6d2018-07-31 14:12:59 -0700118
119 bool operator<(const ReconnectAttempt& rhs) const {
Josh Gao8a40c8a2018-08-10 14:28:24 -0700120 if (reconnect_time == rhs.reconnect_time) {
121 return reinterpret_cast<uintptr_t>(transport) <
122 reinterpret_cast<uintptr_t>(rhs.transport);
123 }
124 return reconnect_time < rhs.reconnect_time;
Josh Gaoe445a6d2018-07-31 14:12:59 -0700125 }
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700126 };
127
128 // Only retry for up to one minute.
Josh Gaoe445a6d2018-07-31 14:12:59 -0700129 static constexpr const std::chrono::seconds kDefaultTimeout = 10s;
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700130 static constexpr const size_t kMaxAttempts = 6;
131
132 // Protects all members.
133 std::mutex reconnect_mutex_;
134 bool running_ GUARDED_BY(reconnect_mutex_) = true;
135 std::thread handler_thread_;
136 std::condition_variable reconnect_cv_;
Josh Gao8a40c8a2018-08-10 14:28:24 -0700137 std::set<ReconnectAttempt> reconnect_queue_ GUARDED_BY(reconnect_mutex_);
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700138
139 DISALLOW_COPY_AND_ASSIGN(ReconnectHandler);
140};
141
142void ReconnectHandler::Start() {
143 check_main_thread();
144 handler_thread_ = std::thread(&ReconnectHandler::Run, this);
145}
146
147void ReconnectHandler::Stop() {
148 check_main_thread();
149 {
150 std::lock_guard<std::mutex> lock(reconnect_mutex_);
151 running_ = false;
152 }
153 reconnect_cv_.notify_one();
154 handler_thread_.join();
155
156 // Drain the queue to free all resources.
157 std::lock_guard<std::mutex> lock(reconnect_mutex_);
158 while (!reconnect_queue_.empty()) {
Josh Gao8a40c8a2018-08-10 14:28:24 -0700159 ReconnectAttempt attempt = *reconnect_queue_.begin();
160 reconnect_queue_.erase(reconnect_queue_.begin());
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700161 remove_transport(attempt.transport);
162 }
163}
164
165void ReconnectHandler::TrackTransport(atransport* transport) {
166 check_main_thread();
167 {
168 std::lock_guard<std::mutex> lock(reconnect_mutex_);
169 if (!running_) return;
Josh Gaoe445a6d2018-07-31 14:12:59 -0700170 // Arbitrary sleep to give adbd time to get ready, if we disconnected because it exited.
171 auto reconnect_time = std::chrono::steady_clock::now() + 250ms;
172 reconnect_queue_.emplace(
173 ReconnectAttempt{transport, reconnect_time, ReconnectHandler::kMaxAttempts});
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700174 }
175 reconnect_cv_.notify_one();
176}
177
Josh Gao902dace2018-08-10 14:44:54 -0700178void ReconnectHandler::CheckForKicked() {
179 reconnect_cv_.notify_one();
180}
181
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700182void ReconnectHandler::Run() {
183 while (true) {
184 ReconnectAttempt attempt;
185 {
186 std::unique_lock<std::mutex> lock(reconnect_mutex_);
Josh Gao982f7bd2019-02-12 13:59:03 -0800187 ScopedLockAssertion assume_lock(reconnect_mutex_);
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700188
Josh Gao95af6412018-07-30 18:51:55 -0700189 if (!reconnect_queue_.empty()) {
190 // FIXME: libstdc++ (used on Windows) implements condition_variable with
191 // system_clock as its clock, so we're probably hosed if the clock changes,
192 // even if we use steady_clock throughout. This problem goes away once we
193 // switch to libc++.
Josh Gao8a40c8a2018-08-10 14:28:24 -0700194 reconnect_cv_.wait_until(lock, reconnect_queue_.begin()->reconnect_time);
Josh Gao95af6412018-07-30 18:51:55 -0700195 } else {
196 reconnect_cv_.wait(lock);
197 }
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700198
199 if (!running_) return;
Josh Gao902dace2018-08-10 14:44:54 -0700200
201 // Scan the whole list for kicked transports, so that we immediately handle an explicit
202 // disconnect request.
203 bool kicked = false;
204 for (auto it = reconnect_queue_.begin(); it != reconnect_queue_.end();) {
205 if (it->transport->kicked()) {
206 D("transport %s was kicked. giving up on it.", it->transport->serial.c_str());
207 remove_transport(it->transport);
208 it = reconnect_queue_.erase(it);
209 } else {
210 ++it;
211 }
212 kicked = true;
213 }
214
Josh Gao95af6412018-07-30 18:51:55 -0700215 if (reconnect_queue_.empty()) continue;
216
Josh Gao902dace2018-08-10 14:44:54 -0700217 // Go back to sleep if we either woke up spuriously, or we were woken up to remove
218 // a kicked transport, and the first transport isn't ready for reconnection yet.
Josh Gao95af6412018-07-30 18:51:55 -0700219 auto now = std::chrono::steady_clock::now();
Josh Gao8a40c8a2018-08-10 14:28:24 -0700220 if (reconnect_queue_.begin()->reconnect_time > now) {
Josh Gao95af6412018-07-30 18:51:55 -0700221 continue;
222 }
223
Josh Gao8a40c8a2018-08-10 14:28:24 -0700224 attempt = *reconnect_queue_.begin();
225 reconnect_queue_.erase(reconnect_queue_.begin());
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700226 }
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700227 D("attempting to reconnect %s", attempt.transport->serial.c_str());
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700228
Josh Gaofc2e56f2018-08-30 11:37:00 -0700229 switch (attempt.transport->Reconnect()) {
230 case ReconnectResult::Retry: {
231 D("attempting to reconnect %s failed.", attempt.transport->serial.c_str());
232 if (attempt.attempts_left == 0) {
233 D("transport %s exceeded the number of retry attempts. giving up on it.",
234 attempt.transport->serial.c_str());
235 remove_transport(attempt.transport);
236 continue;
237 }
238
239 std::lock_guard<std::mutex> lock(reconnect_mutex_);
240 reconnect_queue_.emplace(ReconnectAttempt{
241 attempt.transport,
242 std::chrono::steady_clock::now() + ReconnectHandler::kDefaultTimeout,
243 attempt.attempts_left - 1});
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700244 continue;
245 }
246
Josh Gaofc2e56f2018-08-30 11:37:00 -0700247 case ReconnectResult::Success:
248 D("reconnection to %s succeeded.", attempt.transport->serial.c_str());
249 register_transport(attempt.transport);
250 continue;
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700251
Josh Gaofc2e56f2018-08-30 11:37:00 -0700252 case ReconnectResult::Abort:
253 D("cancelling reconnection attempt to %s.", attempt.transport->serial.c_str());
254 remove_transport(attempt.transport);
255 continue;
256 }
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700257 }
258}
259
260static auto& reconnect_handler = *new ReconnectHandler();
261
Josh Gaodef91c02018-07-31 18:28:32 -0700262#endif
263
Luis Hector Chavez56fe7532018-04-17 14:25:04 -0700264} // namespace
265
Josh Gaob122b172017-08-16 16:57:01 -0700266TransportId NextTransportId() {
267 static std::atomic<TransportId> next(1);
268 return next++;
269}
270
Josh Gao3705b342019-03-28 15:47:44 -0700271void Connection::Reset() {
272 LOG(INFO) << "Connection::Reset(): stopping";
273 Stop();
274}
275
Josh Gao0bbf69c2018-02-16 13:24:58 -0800276BlockingConnectionAdapter::BlockingConnectionAdapter(std::unique_ptr<BlockingConnection> connection)
277 : underlying_(std::move(connection)) {}
278
279BlockingConnectionAdapter::~BlockingConnectionAdapter() {
280 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): destructing";
281 Stop();
282}
283
284void BlockingConnectionAdapter::Start() {
Josh Gaoc251ec52018-04-03 12:55:18 -0700285 std::lock_guard<std::mutex> lock(mutex_);
286 if (started_) {
287 LOG(FATAL) << "BlockingConnectionAdapter(" << this->transport_name_
288 << "): started multiple times";
289 }
290
Joshua Duong5cf78682020-01-21 13:19:42 -0800291 StartReadThread();
Josh Gao0bbf69c2018-02-16 13:24:58 -0800292
293 write_thread_ = std::thread([this]() {
294 LOG(INFO) << this->transport_name_ << ": write thread spawning";
295 while (true) {
296 std::unique_lock<std::mutex> lock(mutex_);
Josh Gao982f7bd2019-02-12 13:59:03 -0800297 ScopedLockAssertion assume_locked(mutex_);
Josh Gaoc251ec52018-04-03 12:55:18 -0700298 cv_.wait(lock, [this]() REQUIRES(mutex_) {
299 return this->stopped_ || !this->write_queue_.empty();
300 });
301
Josh Gao0bbf69c2018-02-16 13:24:58 -0800302 if (this->stopped_) {
303 return;
304 }
305
306 std::unique_ptr<apacket> packet = std::move(this->write_queue_.front());
307 this->write_queue_.pop_front();
308 lock.unlock();
309
310 if (!this->underlying_->Write(packet.get())) {
311 break;
312 }
313 }
314 std::call_once(this->error_flag_, [this]() { this->error_callback_(this, "write failed"); });
315 });
Josh Gaoc251ec52018-04-03 12:55:18 -0700316
317 started_ = true;
Josh Gao0bbf69c2018-02-16 13:24:58 -0800318}
319
Joshua Duong5cf78682020-01-21 13:19:42 -0800320void BlockingConnectionAdapter::StartReadThread() {
321 read_thread_ = std::thread([this]() {
322 LOG(INFO) << this->transport_name_ << ": read thread spawning";
323 while (true) {
324 auto packet = std::make_unique<apacket>();
325 if (!underlying_->Read(packet.get())) {
326 PLOG(INFO) << this->transport_name_ << ": read failed";
327 break;
328 }
329
330 bool got_stls_cmd = false;
331 if (packet->msg.command == A_STLS) {
332 got_stls_cmd = true;
333 }
334
335 read_callback_(this, std::move(packet));
336
337 // If we received the STLS packet, we are about to perform the TLS
338 // handshake. So this read thread must stop and resume after the
339 // handshake completes otherwise this will interfere in the process.
340 if (got_stls_cmd) {
341 LOG(INFO) << this->transport_name_
342 << ": Received STLS packet. Stopping read thread.";
343 return;
344 }
345 }
346 std::call_once(this->error_flag_, [this]() { this->error_callback_(this, "read failed"); });
347 });
348}
349
350bool BlockingConnectionAdapter::DoTlsHandshake(RSA* key, std::string* auth_key) {
351 std::lock_guard<std::mutex> lock(mutex_);
352 if (read_thread_.joinable()) {
353 read_thread_.join();
354 }
355 bool success = this->underlying_->DoTlsHandshake(key, auth_key);
356 StartReadThread();
357 return success;
358}
359
Josh Gao3705b342019-03-28 15:47:44 -0700360void BlockingConnectionAdapter::Reset() {
361 {
362 std::lock_guard<std::mutex> lock(mutex_);
363 if (!started_) {
364 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): not started";
365 return;
366 }
367
368 if (stopped_) {
369 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_
370 << "): already stopped";
371 return;
372 }
373 }
374
375 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): resetting";
376 this->underlying_->Reset();
377 Stop();
378}
379
Josh Gao0bbf69c2018-02-16 13:24:58 -0800380void BlockingConnectionAdapter::Stop() {
Josh Gaoc251ec52018-04-03 12:55:18 -0700381 {
382 std::lock_guard<std::mutex> lock(mutex_);
383 if (!started_) {
384 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): not started";
385 return;
386 }
Josh Gao0bbf69c2018-02-16 13:24:58 -0800387
Josh Gaoc251ec52018-04-03 12:55:18 -0700388 if (stopped_) {
389 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_
390 << "): already stopped";
391 return;
392 }
393
394 stopped_ = true;
395 }
Josh Gao0bbf69c2018-02-16 13:24:58 -0800396
397 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): stopping";
398
399 this->underlying_->Close();
Josh Gao0bbf69c2018-02-16 13:24:58 -0800400 this->cv_.notify_one();
Josh Gaoc251ec52018-04-03 12:55:18 -0700401
402 // Move the threads out into locals with the lock taken, and then unlock to let them exit.
403 std::thread read_thread;
404 std::thread write_thread;
405
406 {
407 std::lock_guard<std::mutex> lock(mutex_);
408 read_thread = std::move(read_thread_);
409 write_thread = std::move(write_thread_);
410 }
411
412 read_thread.join();
413 write_thread.join();
Josh Gao0bbf69c2018-02-16 13:24:58 -0800414
415 LOG(INFO) << "BlockingConnectionAdapter(" << this->transport_name_ << "): stopped";
416 std::call_once(this->error_flag_, [this]() { this->error_callback_(this, "requested stop"); });
417}
418
419bool BlockingConnectionAdapter::Write(std::unique_ptr<apacket> packet) {
420 {
Josh Gaoc251ec52018-04-03 12:55:18 -0700421 std::lock_guard<std::mutex> lock(this->mutex_);
Josh Gao0bbf69c2018-02-16 13:24:58 -0800422 write_queue_.emplace_back(std::move(packet));
423 }
424
425 cv_.notify_one();
426 return true;
427}
428
Joshua Duong5cf78682020-01-21 13:19:42 -0800429FdConnection::FdConnection(unique_fd fd) : fd_(std::move(fd)) {}
430
431FdConnection::~FdConnection() {}
432
433bool FdConnection::DispatchRead(void* buf, size_t len) {
434 if (tls_ != nullptr) {
435 // The TlsConnection doesn't allow 0 byte reads
436 if (len == 0) {
437 return true;
438 }
439 return tls_->ReadFully(buf, len);
440 }
441
442 return ReadFdExactly(fd_.get(), buf, len);
443}
444
445bool FdConnection::DispatchWrite(void* buf, size_t len) {
446 if (tls_ != nullptr) {
447 // The TlsConnection doesn't allow 0 byte writes
448 if (len == 0) {
449 return true;
450 }
451 return tls_->WriteFully(std::string_view(reinterpret_cast<const char*>(buf), len));
452 }
453
454 return WriteFdExactly(fd_.get(), buf, len);
455}
456
Josh Gaob800d882018-01-28 20:32:46 -0800457bool FdConnection::Read(apacket* packet) {
Joshua Duong5cf78682020-01-21 13:19:42 -0800458 if (!DispatchRead(&packet->msg, sizeof(amessage))) {
Josh Gaob800d882018-01-28 20:32:46 -0800459 D("remote local: read terminated (message)");
460 return false;
461 }
462
Josh Gaof571fcb2018-02-05 18:49:10 -0800463 if (packet->msg.data_length > MAX_PAYLOAD) {
Josh Gao5caaebd2018-02-02 14:38:04 -0800464 D("remote local: read overflow (data length = %" PRIu32 ")", packet->msg.data_length);
465 return false;
466 }
467
Josh Gaof571fcb2018-02-05 18:49:10 -0800468 packet->payload.resize(packet->msg.data_length);
469
Joshua Duong5cf78682020-01-21 13:19:42 -0800470 if (!DispatchRead(&packet->payload[0], packet->payload.size())) {
Josh Gaob800d882018-01-28 20:32:46 -0800471 D("remote local: terminated (data)");
472 return false;
473 }
474
475 return true;
476}
477
478bool FdConnection::Write(apacket* packet) {
Joshua Duong5cf78682020-01-21 13:19:42 -0800479 if (!DispatchWrite(&packet->msg, sizeof(packet->msg))) {
Josh Gaob800d882018-01-28 20:32:46 -0800480 D("remote local: write terminated");
481 return false;
482 }
483
Josh Gaof571fcb2018-02-05 18:49:10 -0800484 if (packet->msg.data_length) {
Joshua Duong5cf78682020-01-21 13:19:42 -0800485 if (!DispatchWrite(&packet->payload[0], packet->msg.data_length)) {
Josh Gaof571fcb2018-02-05 18:49:10 -0800486 D("remote local: write terminated");
487 return false;
488 }
489 }
490
Josh Gaob800d882018-01-28 20:32:46 -0800491 return true;
492}
493
Joshua Duong5cf78682020-01-21 13:19:42 -0800494bool FdConnection::DoTlsHandshake(RSA* key, std::string* auth_key) {
495 bssl::UniquePtr<EVP_PKEY> evp_pkey(EVP_PKEY_new());
496 if (!EVP_PKEY_set1_RSA(evp_pkey.get(), key)) {
497 LOG(ERROR) << "EVP_PKEY_set1_RSA failed";
498 return false;
499 }
500 auto x509 = GenerateX509Certificate(evp_pkey.get());
501 auto x509_str = X509ToPEMString(x509.get());
502 auto evp_str = Key::ToPEMString(evp_pkey.get());
Joshua Duong1b273ed2020-03-24 09:50:59 -0700503
Yurii Zubrytskyie3e64b82020-03-26 18:16:36 -0700504 int osh = cast_handle_to_int(adb_get_os_handle(fd_));
Joshua Duong5cf78682020-01-21 13:19:42 -0800505#if ADB_HOST
506 tls_ = TlsConnection::Create(TlsConnection::Role::Client,
507#else
508 tls_ = TlsConnection::Create(TlsConnection::Role::Server,
509#endif
Joshua Duong1b273ed2020-03-24 09:50:59 -0700510 x509_str, evp_str, osh);
Joshua Duong5cf78682020-01-21 13:19:42 -0800511 CHECK(tls_);
512#if ADB_HOST
513 // TLS 1.3 gives the client no message if the server rejected the
514 // certificate. This will enable a check in the tls connection to check
515 // whether the client certificate got rejected. Note that this assumes
516 // that, on handshake success, the server speaks first.
517 tls_->EnableClientPostHandshakeCheck(true);
518 // Add callback to set the certificate when server issues the
519 // CertificateRequest.
520 tls_->SetCertificateCallback(adb_tls_set_certificate);
521 // Allow any server certificate
522 tls_->SetCertVerifyCallback([](X509_STORE_CTX*) { return 1; });
523#else
524 // Add callback to check certificate against a list of known public keys
525 tls_->SetCertVerifyCallback(
526 [auth_key](X509_STORE_CTX* ctx) { return adbd_tls_verify_cert(ctx, auth_key); });
527 // Add the list of allowed client CA issuers
528 auto ca_list = adbd_tls_client_ca_list();
529 tls_->SetClientCAList(ca_list.get());
530#endif
531
532 auto err = tls_->DoHandshake();
533 if (err == TlsError::Success) {
534 return true;
535 }
536
537 tls_.reset();
538 return false;
539}
540
Josh Gaob800d882018-01-28 20:32:46 -0800541void FdConnection::Close() {
542 adb_shutdown(fd_.get());
543 fd_.reset();
544}
545
Josh Gao06d61d42016-10-06 13:31:44 -0700546void send_packet(apacket* p, atransport* t) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800547 p->msg.magic = p->msg.command ^ 0xffffffff;
Tim Murrayde471942017-12-07 11:40:00 -0800548 // compute a checksum for connection/auth packets for compatibility reasons
549 if (t->get_protocol_version() >= A_VERSION_SKIP_CHECKSUM) {
550 p->msg.data_check = 0;
551 } else {
552 p->msg.data_check = calculate_apacket_checksum(p);
553 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800554
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700555 VLOG(TRANSPORT) << dump_packet(t->serial.c_str(), "to remote", p);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800556
Yi Kongaed415c2018-07-13 18:15:16 -0700557 if (t == nullptr) {
Elliott Hughes4679a392018-10-19 13:59:44 -0700558 LOG(FATAL) << "Transport is null";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800559 }
560
Josh Gao0bbf69c2018-02-16 13:24:58 -0800561 if (t->Write(p) != 0) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700562 D("%s: failed to enqueue packet, closing transport", t->serial.c_str());
Josh Gao0bbf69c2018-02-16 13:24:58 -0800563 t->Kick();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800564 }
565}
566
Josh Gao3705b342019-03-28 15:47:44 -0700567void kick_transport(atransport* t, bool reset) {
Josh Gao1db71af2017-08-17 13:50:51 -0700568 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Yabin Cui1f4ec192016-04-05 13:50:44 -0700569 // As kick_transport() can be called from threads without guarantee that t is valid,
570 // check if the transport is in transport_list first.
Josh Gaob122b172017-08-16 16:57:01 -0700571 //
572 // TODO(jmgao): WTF? Is this actually true?
Yabin Cui1f4ec192016-04-05 13:50:44 -0700573 if (std::find(transport_list.begin(), transport_list.end(), t) != transport_list.end()) {
Josh Gao3705b342019-03-28 15:47:44 -0700574 if (reset) {
575 t->Reset();
576 } else {
577 t->Kick();
578 }
Yabin Cui1f4ec192016-04-05 13:50:44 -0700579 }
Josh Gao902dace2018-08-10 14:44:54 -0700580
581#if ADB_HOST
582 reconnect_handler.CheckForKicked();
583#endif
Yabin Cuif4b99282015-08-27 12:03:11 -0700584}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800585
586static int transport_registration_send = -1;
587static int transport_registration_recv = -1;
Josh Gao71f775a2018-05-14 11:14:33 -0700588static fdevent* transport_registration_fde;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800589
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800590#if ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800591
592/* this adds support required by the 'track-devices' service.
593 * this is used to send the content of "list_transport" to any
594 * number of client connections that want it through a single
595 * live TCP connection
596 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800597struct device_tracker {
Josh Gao1290fbf2016-11-22 14:32:34 -0800598 asocket socket;
Josh Gaoe0361d12018-02-12 17:24:00 -0800599 bool update_needed = false;
600 bool long_output = false;
601 device_tracker* next = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800602};
603
604/* linked list of all device trackers */
Josh Gao1290fbf2016-11-22 14:32:34 -0800605static device_tracker* device_tracker_list;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800606
Josh Gao1290fbf2016-11-22 14:32:34 -0800607static void device_tracker_remove(device_tracker* tracker) {
608 device_tracker** pnode = &device_tracker_list;
609 device_tracker* node = *pnode;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800610
Josh Gao1db71af2017-08-17 13:50:51 -0700611 std::lock_guard<std::recursive_mutex> lock(transport_lock);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800612 while (node) {
613 if (node == tracker) {
614 *pnode = node->next;
615 break;
616 }
617 pnode = &node->next;
Josh Gao1290fbf2016-11-22 14:32:34 -0800618 node = *pnode;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800619 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800620}
621
Josh Gao1290fbf2016-11-22 14:32:34 -0800622static void device_tracker_close(asocket* socket) {
623 device_tracker* tracker = (device_tracker*)socket;
624 asocket* peer = socket->peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800625
Josh Gao1290fbf2016-11-22 14:32:34 -0800626 D("device tracker %p removed", tracker);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800627 if (peer) {
Yi Kongaed415c2018-07-13 18:15:16 -0700628 peer->peer = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800629 peer->close(peer);
630 }
631 device_tracker_remove(tracker);
Josh Gaoe0361d12018-02-12 17:24:00 -0800632 delete tracker;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800633}
634
Josh Gao1ce99572018-03-07 16:52:28 -0800635static int device_tracker_enqueue(asocket* socket, apacket::payload_type) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800636 /* you can't read from a device tracker, close immediately */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800637 device_tracker_close(socket);
638 return -1;
639}
640
Elliott Hughese67f1f82015-04-30 17:32:03 -0700641static int device_tracker_send(device_tracker* tracker, const std::string& string) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700642 asocket* peer = tracker->socket.peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800643
Josh Gao1ce99572018-03-07 16:52:28 -0800644 apacket::payload_type data;
Josh Gao27cb7dc2018-02-01 13:17:50 -0800645 data.resize(4 + string.size());
646 char buf[5];
647 snprintf(buf, sizeof(buf), "%04x", static_cast<int>(string.size()));
648 memcpy(&data[0], buf, 4);
649 memcpy(&data[4], string.data(), string.size());
650 return peer->enqueue(peer, std::move(data));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800651}
652
Elliott Hughese67f1f82015-04-30 17:32:03 -0700653static void device_tracker_ready(asocket* socket) {
654 device_tracker* tracker = reinterpret_cast<device_tracker*>(socket);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800655
Elliott Hughese67f1f82015-04-30 17:32:03 -0700656 // We want to send the device list when the tracker connects
657 // for the first time, even if no update occurred.
Josh Gaob0c18022017-08-14 18:57:54 -0700658 if (tracker->update_needed) {
659 tracker->update_needed = false;
Elliott Hughesfc2f5f62019-07-31 14:13:57 -0700660 device_tracker_send(tracker, list_transports(tracker->long_output));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800661 }
662}
663
Josh Gaob0c18022017-08-14 18:57:54 -0700664asocket* create_device_tracker(bool long_output) {
Josh Gaoe0361d12018-02-12 17:24:00 -0800665 device_tracker* tracker = new device_tracker();
Elliott Hughes4679a392018-10-19 13:59:44 -0700666 if (tracker == nullptr) LOG(FATAL) << "cannot allocate device tracker";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800667
Josh Gao1290fbf2016-11-22 14:32:34 -0800668 D("device tracker %p created", tracker);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800669
670 tracker->socket.enqueue = device_tracker_enqueue;
Josh Gao1290fbf2016-11-22 14:32:34 -0800671 tracker->socket.ready = device_tracker_ready;
672 tracker->socket.close = device_tracker_close;
Josh Gaob0c18022017-08-14 18:57:54 -0700673 tracker->update_needed = true;
674 tracker->long_output = long_output;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800675
Josh Gao1290fbf2016-11-22 14:32:34 -0800676 tracker->next = device_tracker_list;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800677 device_tracker_list = tracker;
678
679 return &tracker->socket;
680}
681
Josh Gaofd713e52017-05-03 22:37:10 -0700682// Check if all of the USB transports are connected.
683bool iterate_transports(std::function<bool(const atransport*)> fn) {
Josh Gao1db71af2017-08-17 13:50:51 -0700684 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gaofd713e52017-05-03 22:37:10 -0700685 for (const auto& t : transport_list) {
686 if (!fn(t)) {
687 return false;
688 }
689 }
690 for (const auto& t : pending_list) {
691 if (!fn(t)) {
692 return false;
693 }
694 }
695 return true;
696}
697
Elliott Hughese67f1f82015-04-30 17:32:03 -0700698// Call this function each time the transport list has changed.
699void update_transports() {
Josh Gaofd713e52017-05-03 22:37:10 -0700700 update_transport_status();
701
702 // Notify `adb track-devices` clients.
Elliott Hughese67f1f82015-04-30 17:32:03 -0700703 device_tracker* tracker = device_tracker_list;
704 while (tracker != nullptr) {
705 device_tracker* next = tracker->next;
706 // This may destroy the tracker if the connection is closed.
Elliott Hughesfc2f5f62019-07-31 14:13:57 -0700707 device_tracker_send(tracker, list_transports(tracker->long_output));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800708 tracker = next;
709 }
710}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700711
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800712#else
Elliott Hughese67f1f82015-04-30 17:32:03 -0700713
714void update_transports() {
715 // Nothing to do on the device side.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800716}
Elliott Hughese67f1f82015-04-30 17:32:03 -0700717
Josh Gao1290fbf2016-11-22 14:32:34 -0800718#endif // ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800719
Josh Gao1290fbf2016-11-22 14:32:34 -0800720struct tmsg {
721 atransport* transport;
722 int action;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800723};
724
Josh Gao1290fbf2016-11-22 14:32:34 -0800725static int transport_read_action(int fd, struct tmsg* m) {
726 char* p = (char*)m;
727 int len = sizeof(*m);
728 int r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800729
Josh Gao1290fbf2016-11-22 14:32:34 -0800730 while (len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800731 r = adb_read(fd, p, len);
Josh Gao1290fbf2016-11-22 14:32:34 -0800732 if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800733 len -= r;
Josh Gao1290fbf2016-11-22 14:32:34 -0800734 p += r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800735 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700736 D("transport_read_action: on fd %d: %s", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800737 return -1;
738 }
739 }
740 return 0;
741}
742
Josh Gao1290fbf2016-11-22 14:32:34 -0800743static int transport_write_action(int fd, struct tmsg* m) {
744 char* p = (char*)m;
745 int len = sizeof(*m);
746 int r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800747
Josh Gao1290fbf2016-11-22 14:32:34 -0800748 while (len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800749 r = adb_write(fd, p, len);
Josh Gao1290fbf2016-11-22 14:32:34 -0800750 if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800751 len -= r;
Josh Gao1290fbf2016-11-22 14:32:34 -0800752 p += r;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800753 } else {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700754 D("transport_write_action: on fd %d: %s", fd, strerror(errno));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800755 return -1;
756 }
757 }
758 return 0;
759}
760
Josh Gao0bbf69c2018-02-16 13:24:58 -0800761static void transport_registration_func(int _fd, unsigned ev, void*) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800762 tmsg m;
Josh Gao1290fbf2016-11-22 14:32:34 -0800763 atransport* t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800764
Josh Gao1290fbf2016-11-22 14:32:34 -0800765 if (!(ev & FDE_READ)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800766 return;
767 }
768
Josh Gao1290fbf2016-11-22 14:32:34 -0800769 if (transport_read_action(_fd, &m)) {
Elliott Hughes4679a392018-10-19 13:59:44 -0700770 PLOG(FATAL) << "cannot read transport registration socket";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800771 }
772
773 t = m.transport;
774
Dan Albert1792c232015-05-18 13:06:53 -0700775 if (m.action == 0) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700776 D("transport: %s deleting", t->serial.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800777
Josh Gao0cd3ae12016-09-21 12:37:10 -0700778 {
Josh Gao1db71af2017-08-17 13:50:51 -0700779 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gao0cd3ae12016-09-21 12:37:10 -0700780 transport_list.remove(t);
781 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800782
Dan Albertc7915a32015-05-18 16:46:31 -0700783 delete t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800784
785 update_transports();
786 return;
787 }
788
Mike Lockwood0927bf92009-08-08 12:37:44 -0400789 /* don't create transport threads for inaccessible devices */
Yabin Cuib5e11412017-03-10 16:01:01 -0800790 if (t->GetConnectionState() != kCsNoPerm) {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700791 // The connection gets a reference to the atransport. It will release it
792 // upon a read/write error.
Luis Hector Chavez9a388d52018-04-25 08:56:41 -0700793 t->connection()->SetTransportName(t->serial_name());
794 t->connection()->SetReadCallback([t](Connection*, std::unique_ptr<apacket> p) {
Josh Gao0bbf69c2018-02-16 13:24:58 -0800795 if (!check_header(p.get(), t)) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700796 D("%s: remote read: bad header", t->serial.c_str());
Josh Gao0bbf69c2018-02-16 13:24:58 -0800797 return false;
798 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800799
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700800 VLOG(TRANSPORT) << dump_packet(t->serial.c_str(), "from remote", p.get());
Josh Gao0bbf69c2018-02-16 13:24:58 -0800801 apacket* packet = p.release();
Mike Lockwood0927bf92009-08-08 12:37:44 -0400802
Josh Gao0bbf69c2018-02-16 13:24:58 -0800803 // TODO: Does this need to run on the main thread?
804 fdevent_run_on_main_thread([packet, t]() { handle_packet(packet, t); });
805 return true;
806 });
Luis Hector Chavez9a388d52018-04-25 08:56:41 -0700807 t->connection()->SetErrorCallback([t](Connection*, const std::string& error) {
Josh Gaoc51726c2018-10-11 16:33:05 -0700808 LOG(INFO) << t->serial_name() << ": connection terminated: " << error;
Josh Gao0bbf69c2018-02-16 13:24:58 -0800809 fdevent_run_on_main_thread([t]() {
810 handle_offline(t);
Josh Gao9a8366b2019-12-09 13:45:31 -0800811 transport_destroy(t);
Josh Gao0bbf69c2018-02-16 13:24:58 -0800812 });
813 });
Mike Lockwood0927bf92009-08-08 12:37:44 -0400814
Luis Hector Chavez9a388d52018-04-25 08:56:41 -0700815 t->connection()->Start();
Josh Gao0bbf69c2018-02-16 13:24:58 -0800816#if ADB_HOST
817 send_connect(t);
818#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800819 }
820
Josh Gao0cd3ae12016-09-21 12:37:10 -0700821 {
Josh Gao1db71af2017-08-17 13:50:51 -0700822 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700823 auto it = std::find(pending_list.begin(), pending_list.end(), t);
824 if (it != pending_list.end()) {
825 pending_list.remove(t);
826 transport_list.push_front(t);
827 }
Josh Gao0cd3ae12016-09-21 12:37:10 -0700828 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800829
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800830 update_transports();
831}
832
Josh Gaodef91c02018-07-31 18:28:32 -0700833#if ADB_HOST
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700834void init_reconnect_handler(void) {
835 reconnect_handler.Start();
836}
Josh Gaodef91c02018-07-31 18:28:32 -0700837#endif
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700838
Josh Gao1290fbf2016-11-22 14:32:34 -0800839void init_transport_registration(void) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800840 int s[2];
841
Josh Gao1290fbf2016-11-22 14:32:34 -0800842 if (adb_socketpair(s)) {
Elliott Hughes4679a392018-10-19 13:59:44 -0700843 PLOG(FATAL) << "cannot open transport registration socketpair";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800844 }
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700845 D("socketpair: (%d,%d)", s[0], s[1]);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800846
847 transport_registration_send = s[0];
848 transport_registration_recv = s[1];
849
Josh Gao71f775a2018-05-14 11:14:33 -0700850 transport_registration_fde =
Yi Kongaed415c2018-07-13 18:15:16 -0700851 fdevent_create(transport_registration_recv, transport_registration_func, nullptr);
Josh Gao71f775a2018-05-14 11:14:33 -0700852 fdevent_set(transport_registration_fde, FDE_READ);
Josh Gao01b7bc42017-05-09 13:43:35 -0700853}
854
855void kick_all_transports() {
Josh Gaodef91c02018-07-31 18:28:32 -0700856#if ADB_HOST
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700857 reconnect_handler.Stop();
Josh Gaodef91c02018-07-31 18:28:32 -0700858#endif
Josh Gao01b7bc42017-05-09 13:43:35 -0700859 // To avoid only writing part of a packet to a transport after exit, kick all transports.
Josh Gao1db71af2017-08-17 13:50:51 -0700860 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gao01b7bc42017-05-09 13:43:35 -0700861 for (auto t : transport_list) {
862 t->Kick();
863 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800864}
865
Joshua Duong5cf78682020-01-21 13:19:42 -0800866void kick_all_tcp_tls_transports() {
867 std::lock_guard<std::recursive_mutex> lock(transport_lock);
868 for (auto t : transport_list) {
869 if (t->IsTcpDevice() && t->use_tls) {
870 t->Kick();
871 }
872 }
873}
874
875#if !ADB_HOST
876void kick_all_transports_by_auth_key(std::string_view auth_key) {
877 std::lock_guard<std::recursive_mutex> lock(transport_lock);
878 for (auto t : transport_list) {
879 if (auth_key == t->auth_key) {
880 t->Kick();
881 }
882 }
883}
884#endif
885
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800886/* the fdevent select pump is single threaded */
Josh Gaoc51726c2018-10-11 16:33:05 -0700887void register_transport(atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800888 tmsg m;
889 m.transport = transport;
890 m.action = 1;
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700891 D("transport: %s registered", transport->serial.c_str());
Josh Gao1290fbf2016-11-22 14:32:34 -0800892 if (transport_write_action(transport_registration_send, &m)) {
Elliott Hughes4679a392018-10-19 13:59:44 -0700893 PLOG(FATAL) << "cannot write transport registration socket";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800894 }
895}
896
Josh Gao1290fbf2016-11-22 14:32:34 -0800897static void remove_transport(atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800898 tmsg m;
899 m.transport = transport;
900 m.action = 0;
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700901 D("transport: %s removed", transport->serial.c_str());
Josh Gao1290fbf2016-11-22 14:32:34 -0800902 if (transport_write_action(transport_registration_send, &m)) {
Elliott Hughes4679a392018-10-19 13:59:44 -0700903 PLOG(FATAL) << "cannot write transport registration socket";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800904 }
905}
906
Josh Gao9a8366b2019-12-09 13:45:31 -0800907static void transport_destroy(atransport* t) {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -0700908 check_main_thread();
Yabin Cuif4b99282015-08-27 12:03:11 -0700909 CHECK(t != nullptr);
Josh Gao0cd3ae12016-09-21 12:37:10 -0700910
Josh Gaoe48ecce2017-09-13 13:40:57 -0700911 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gao9a8366b2019-12-09 13:45:31 -0800912 LOG(INFO) << "destroying transport " << t->serial_name();
913 t->connection()->Stop();
Josh Gaodef91c02018-07-31 18:28:32 -0700914#if ADB_HOST
Josh Gao9a8366b2019-12-09 13:45:31 -0800915 if (t->IsTcpDevice() && !t->kicked()) {
916 D("transport: %s destroy (attempting reconnection)", t->serial.c_str());
Josh Gao4414e4c2018-12-04 01:07:50 -0800917
Josh Gao9a8366b2019-12-09 13:45:31 -0800918 // We need to clear the transport's keys, so that on the next connection, it tries
919 // again from the beginning.
920 t->ResetKeys();
921 reconnect_handler.TrackTransport(t);
922 return;
923 }
Josh Gaodef91c02018-07-31 18:28:32 -0700924#endif
925
Josh Gao9a8366b2019-12-09 13:45:31 -0800926 D("transport: %s destroy (kicking and closing)", t->serial.c_str());
927 remove_transport(t);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800928}
929
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700930static int qual_match(const std::string& to_test, const char* prefix, const std::string& qual,
Josh Gao1290fbf2016-11-22 14:32:34 -0800931 bool sanitize_qual) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700932 if (to_test.empty()) /* Return true if both the qual and to_test are empty strings. */
933 return qual.empty();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700934
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700935 if (qual.empty()) return 0;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700936
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700937 const char* ptr = to_test.c_str();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700938 if (prefix) {
939 while (*prefix) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700940 if (*prefix++ != *ptr++) return 0;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700941 }
942 }
943
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700944 for (char ch : qual) {
Josh Gao1290fbf2016-11-22 14:32:34 -0800945 if (sanitize_qual && !isalnum(ch)) ch = '_';
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700946 if (ch != *ptr++) return 0;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700947 }
948
Luis Hector Chavez6150a372018-07-18 21:18:27 -0700949 /* Everything matched so far. Return true if *ptr is a NUL. */
950 return !*ptr;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700951}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800952
Josh Gaob122b172017-08-16 16:57:01 -0700953atransport* acquire_one_transport(TransportType type, const char* serial, TransportId transport_id,
954 bool* is_ambiguous, std::string* error_out,
955 bool accept_any_state) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700956 atransport* result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800957
Josh Gaob122b172017-08-16 16:57:01 -0700958 if (transport_id != 0) {
959 *error_out =
960 android::base::StringPrintf("no device with transport id '%" PRIu64 "'", transport_id);
961 } else if (serial) {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700962 *error_out = android::base::StringPrintf("device '%s' not found", serial);
963 } else if (type == kTransportLocal) {
964 *error_out = "no emulators found";
965 } else if (type == kTransportAny) {
966 *error_out = "no devices/emulators found";
967 } else {
968 *error_out = "no devices found";
969 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800970
Josh Gao1db71af2017-08-17 13:50:51 -0700971 std::unique_lock<std::recursive_mutex> lock(transport_lock);
Elliott Hughes8d28e192015-10-07 14:55:10 -0700972 for (const auto& t : transport_list) {
Yabin Cuib5e11412017-03-10 16:01:01 -0800973 if (t->GetConnectionState() == kCsNoPerm) {
David Purselld2acbd12015-12-02 15:14:31 -0800974 *error_out = UsbNoPermissionsLongHelpText();
Mike Lockwood37d31112009-08-08 13:53:16 -0400975 continue;
976 }
Mike Lockwood0927bf92009-08-08 12:37:44 -0400977
Josh Gaob122b172017-08-16 16:57:01 -0700978 if (transport_id) {
979 if (t->id == transport_id) {
980 result = t;
981 break;
982 }
983 } else if (serial) {
David Pursell3f902aa2016-03-01 08:58:26 -0800984 if (t->MatchesTarget(serial)) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700985 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700986 *error_out = "more than one device";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700987 if (is_ambiguous) *is_ambiguous = true;
988 result = nullptr;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700989 break;
990 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800991 result = t;
Scott Andersone109d262012-04-20 11:21:14 -0700992 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800993 } else {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700994 if (type == kTransportUsb && t->type == kTransportUsb) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800995 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -0700996 *error_out = "more than one device";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700997 if (is_ambiguous) *is_ambiguous = true;
998 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800999 break;
1000 }
1001 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001002 } else if (type == kTransportLocal && t->type == kTransportLocal) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001003 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -07001004 *error_out = "more than one emulator";
Elliott Hughes8d28e192015-10-07 14:55:10 -07001005 if (is_ambiguous) *is_ambiguous = true;
1006 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001007 break;
1008 }
1009 result = t;
Elliott Hughes3bd73c12015-05-05 13:10:43 -07001010 } else if (type == kTransportAny) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001011 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -07001012 *error_out = "more than one device/emulator";
Elliott Hughes8d28e192015-10-07 14:55:10 -07001013 if (is_ambiguous) *is_ambiguous = true;
1014 result = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001015 break;
1016 }
1017 result = t;
1018 }
1019 }
1020 }
Josh Gao0cd3ae12016-09-21 12:37:10 -07001021 lock.unlock();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001022
Josh Gao704494b2018-05-04 16:04:49 -07001023 if (result && !accept_any_state) {
1024 // The caller requires an active transport.
1025 // Make sure that we're actually connected.
1026 ConnectionState state = result->GetConnectionState();
1027 switch (state) {
1028 case kCsConnecting:
1029 *error_out = "device still connecting";
1030 result = nullptr;
1031 break;
Benoit Goby77e8e582013-01-15 12:36:47 -08001032
Josh Gao704494b2018-05-04 16:04:49 -07001033 case kCsAuthorizing:
1034 *error_out = "device still authorizing";
1035 result = nullptr;
1036 break;
1037
1038 case kCsUnauthorized: {
1039 *error_out = "device unauthorized.\n";
1040 char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS");
1041 *error_out += "This adb server's $ADB_VENDOR_KEYS is ";
1042 *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set";
1043 *error_out += "\n";
1044 *error_out += "Try 'adb kill-server' if that seems wrong.\n";
1045 *error_out += "Otherwise check for a confirmation dialog on your device.";
1046 result = nullptr;
1047 break;
1048 }
1049
1050 case kCsOffline:
1051 *error_out = "device offline";
1052 result = nullptr;
1053 break;
1054
1055 default:
1056 break;
1057 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001058 }
1059
1060 if (result) {
Elliott Hughese2d36772015-06-23 13:00:32 -07001061 *error_out = "success";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001062 }
1063
1064 return result;
1065}
1066
Luis Hector Chavez56fe7532018-04-17 14:25:04 -07001067bool ConnectionWaitable::WaitForConnection(std::chrono::milliseconds timeout) {
1068 std::unique_lock<std::mutex> lock(mutex_);
Josh Gao982f7bd2019-02-12 13:59:03 -08001069 ScopedLockAssertion assume_locked(mutex_);
Luis Hector Chavez56fe7532018-04-17 14:25:04 -07001070 return cv_.wait_for(lock, timeout, [&]() REQUIRES(mutex_) {
1071 return connection_established_ready_;
1072 }) && connection_established_;
1073}
1074
1075void ConnectionWaitable::SetConnectionEstablished(bool success) {
1076 {
1077 std::lock_guard<std::mutex> lock(mutex_);
1078 if (connection_established_ready_) return;
1079 connection_established_ready_ = true;
1080 connection_established_ = success;
1081 D("connection established with %d", success);
1082 }
1083 cv_.notify_one();
1084}
1085
1086atransport::~atransport() {
1087 // If the connection callback had not been run before, run it now.
1088 SetConnectionEstablished(false);
1089}
1090
Yabin Cuib5e11412017-03-10 16:01:01 -08001091int atransport::Write(apacket* p) {
Luis Hector Chavez9a388d52018-04-25 08:56:41 -07001092 return this->connection()->Write(std::unique_ptr<apacket>(p)) ? 0 : -1;
Yabin Cuib5e11412017-03-10 16:01:01 -08001093}
1094
Josh Gao3705b342019-03-28 15:47:44 -07001095void atransport::Reset() {
1096 if (!kicked_.exchange(true)) {
1097 LOG(INFO) << "resetting transport " << this << " " << this->serial;
1098 this->connection()->Reset();
1099 }
1100}
1101
Yabin Cui7f274902016-04-18 11:22:34 -07001102void atransport::Kick() {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -07001103 if (!kicked_.exchange(true)) {
Josh Gao3705b342019-03-28 15:47:44 -07001104 LOG(INFO) << "kicking transport " << this << " " << this->serial;
Luis Hector Chavez9a388d52018-04-25 08:56:41 -07001105 this->connection()->Stop();
Yabin Cui7f274902016-04-18 11:22:34 -07001106 }
1107}
1108
Yabin Cuib5e11412017-03-10 16:01:01 -08001109ConnectionState atransport::GetConnectionState() const {
1110 return connection_state_;
1111}
1112
1113void atransport::SetConnectionState(ConnectionState state) {
1114 check_main_thread();
1115 connection_state_ = state;
1116}
1117
Luis Hector Chavez9a388d52018-04-25 08:56:41 -07001118void atransport::SetConnection(std::unique_ptr<Connection> connection) {
1119 std::lock_guard<std::mutex> lock(mutex_);
1120 connection_ = std::shared_ptr<Connection>(std::move(connection));
1121}
1122
Josh Gaoffbd3362018-02-28 14:44:23 -08001123std::string atransport::connection_state_name() const {
Yabin Cuib5e11412017-03-10 16:01:01 -08001124 ConnectionState state = GetConnectionState();
1125 switch (state) {
Josh Gao1290fbf2016-11-22 14:32:34 -08001126 case kCsOffline:
1127 return "offline";
1128 case kCsBootloader:
1129 return "bootloader";
1130 case kCsDevice:
1131 return "device";
1132 case kCsHost:
1133 return "host";
1134 case kCsRecovery:
1135 return "recovery";
Tao Bao55d407e2019-04-07 23:24:03 -07001136 case kCsRescue:
1137 return "rescue";
Josh Gao1290fbf2016-11-22 14:32:34 -08001138 case kCsNoPerm:
1139 return UsbNoPermissionsShortHelpText();
1140 case kCsSideload:
1141 return "sideload";
1142 case kCsUnauthorized:
1143 return "unauthorized";
Josh Gao704494b2018-05-04 16:04:49 -07001144 case kCsAuthorizing:
1145 return "authorizing";
1146 case kCsConnecting:
1147 return "connecting";
Josh Gao1290fbf2016-11-22 14:32:34 -08001148 default:
1149 return "unknown";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001150 }
1151}
1152
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001153void atransport::update_version(int version, size_t payload) {
1154 protocol_version = std::min(version, A_VERSION);
1155 max_payload = std::min(payload, MAX_PAYLOAD);
1156}
1157
1158int atransport::get_protocol_version() const {
1159 return protocol_version;
1160}
1161
Joshua Duong5cf78682020-01-21 13:19:42 -08001162int atransport::get_tls_version() const {
1163 return tls_version;
1164}
1165
Tamas Berghammer3d2904c2015-07-13 19:12:28 +01001166size_t atransport::get_max_payload() const {
1167 return max_payload;
1168}
1169
Dan Albert1792c232015-05-18 13:06:53 -07001170const FeatureSet& supported_features() {
David Pursell4e2fd362015-09-22 10:43:08 -07001171 // Local static allocation to avoid global non-POD variables.
1172 static const FeatureSet* features = new FeatureSet{
Josh Gao7b1cb662019-02-20 13:01:40 -08001173 kFeatureShell2,
1174 kFeatureCmd,
1175 kFeatureStat2,
Josh Gao34a478f2019-08-07 14:23:17 -07001176 kFeatureLs2,
Josh Gao7b1cb662019-02-20 13:01:40 -08001177 kFeatureFixedPushMkdir,
1178 kFeatureApex,
1179 kFeatureAbb,
1180 kFeatureFixedPushSymlinkTimestamp,
Alex Buynytskyy05626c12019-02-21 14:22:51 -08001181 kFeatureAbbExec,
Josh Gao8c2198c2019-07-11 14:15:32 -07001182 kFeatureRemountShell,
Shukang Zhouf4ffae12020-02-13 17:01:39 -08001183 kFeatureTrackApp,
Josh Gao939fc192020-03-04 19:34:08 -08001184 kFeatureSendRecv2,
1185 kFeatureSendRecv2Brotli,
Josh Gao919b70c2018-11-08 22:39:43 -08001186 // Increment ADB_SERVER_VERSION when adding a feature that adbd needs
1187 // to know about. Otherwise, the client can be stuck running an old
1188 // version of the server even after upgrading their copy of adb.
1189 // (http://b/24370690)
David Pursell4e2fd362015-09-22 10:43:08 -07001190 };
1191
1192 return *features;
1193}
1194
1195std::string FeatureSetToString(const FeatureSet& features) {
Elliott Hughes86ab9ff2018-09-05 12:13:11 -07001196 return android::base::Join(features, ',');
David Pursell4e2fd362015-09-22 10:43:08 -07001197}
1198
1199FeatureSet StringToFeatureSet(const std::string& features_string) {
David Purselld2b588e2015-09-25 13:04:21 -07001200 if (features_string.empty()) {
1201 return FeatureSet();
1202 }
1203
Elliott Hughes86ab9ff2018-09-05 12:13:11 -07001204 auto names = android::base::Split(features_string, ",");
David Pursell4e2fd362015-09-22 10:43:08 -07001205 return FeatureSet(names.begin(), names.end());
Dan Albert1792c232015-05-18 13:06:53 -07001206}
1207
David Pursell70ef7b42015-09-30 13:35:42 -07001208bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
Josh Gao1290fbf2016-11-22 14:32:34 -08001209 return feature_set.count(feature) > 0 && supported_features().count(feature) > 0;
David Pursell70ef7b42015-09-30 13:35:42 -07001210}
1211
Dan Albert1792c232015-05-18 13:06:53 -07001212bool atransport::has_feature(const std::string& feature) const {
1213 return features_.count(feature) > 0;
1214}
1215
David Pursell4e2fd362015-09-22 10:43:08 -07001216void atransport::SetFeatures(const std::string& features_string) {
1217 features_ = StringToFeatureSet(features_string);
Dan Albert1792c232015-05-18 13:06:53 -07001218}
1219
Yabin Cuib3298242015-08-28 15:09:44 -07001220void atransport::AddDisconnect(adisconnect* disconnect) {
1221 disconnects_.push_back(disconnect);
1222}
1223
1224void atransport::RemoveDisconnect(adisconnect* disconnect) {
1225 disconnects_.remove(disconnect);
1226}
1227
1228void atransport::RunDisconnects() {
Elliott Hughes65fe2512015-10-07 15:59:35 -07001229 for (const auto& disconnect : disconnects_) {
Yabin Cuib3298242015-08-28 15:09:44 -07001230 disconnect->func(disconnect->opaque, this);
1231 }
1232 disconnects_.clear();
1233}
1234
David Pursell3f902aa2016-03-01 08:58:26 -08001235bool atransport::MatchesTarget(const std::string& target) const {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001236 if (!serial.empty()) {
David Pursell3f902aa2016-03-01 08:58:26 -08001237 if (target == serial) {
1238 return true;
1239 } else if (type == kTransportLocal) {
1240 // Local transports can match [tcp:|udp:]<hostname>[:port].
1241 const char* local_target_ptr = target.c_str();
1242
1243 // For fastboot compatibility, ignore protocol prefixes.
1244 if (android::base::StartsWith(target, "tcp:") ||
Josh Gao1290fbf2016-11-22 14:32:34 -08001245 android::base::StartsWith(target, "udp:")) {
David Pursell3f902aa2016-03-01 08:58:26 -08001246 local_target_ptr += 4;
1247 }
1248
1249 // Parse our |serial| and the given |target| to check if the hostnames and ports match.
1250 std::string serial_host, error;
1251 int serial_port = -1;
Josh Gao1290fbf2016-11-22 14:32:34 -08001252 if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) {
David Pursell3f902aa2016-03-01 08:58:26 -08001253 // |target| may omit the port to default to ours.
1254 std::string target_host;
1255 int target_port = serial_port;
1256 if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port,
1257 nullptr, &error) &&
Josh Gao1290fbf2016-11-22 14:32:34 -08001258 serial_host == target_host && serial_port == target_port) {
David Pursell3f902aa2016-03-01 08:58:26 -08001259 return true;
1260 }
1261 }
1262 }
1263 }
1264
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001265 return (target == devpath) || qual_match(target, "product:", product, false) ||
1266 qual_match(target, "model:", model, true) ||
1267 qual_match(target, "device:", device, false);
David Pursell3f902aa2016-03-01 08:58:26 -08001268}
1269
Luis Hector Chavez56fe7532018-04-17 14:25:04 -07001270void atransport::SetConnectionEstablished(bool success) {
1271 connection_waitable_->SetConnectionEstablished(success);
1272}
1273
Josh Gaofc2e56f2018-08-30 11:37:00 -07001274ReconnectResult atransport::Reconnect() {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -07001275 return reconnect_(this);
1276}
1277
Elliott Hughese67f1f82015-04-30 17:32:03 -07001278#if ADB_HOST
1279
Josh Gaob122b172017-08-16 16:57:01 -07001280// We use newline as our delimiter, make sure to never output it.
1281static std::string sanitize(std::string str, bool alphanumeric) {
1282 auto pred = alphanumeric ? [](const char c) { return !isalnum(c); }
1283 : [](const char c) { return c == '\n'; };
1284 std::replace_if(str.begin(), str.end(), pred, '_');
1285 return str;
1286}
1287
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001288static void append_transport_info(std::string* result, const char* key, const std::string& value,
Josh Gaob122b172017-08-16 16:57:01 -07001289 bool alphanumeric) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001290 if (value.empty()) {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001291 return;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001292 }
1293
Elliott Hughese67f1f82015-04-30 17:32:03 -07001294 *result += ' ';
1295 *result += key;
Josh Gaob122b172017-08-16 16:57:01 -07001296 *result += sanitize(value, alphanumeric);
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001297}
1298
Josh Gao1290fbf2016-11-22 14:32:34 -08001299static void append_transport(const atransport* t, std::string* result, bool long_listing) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001300 std::string serial = t->serial;
1301 if (serial.empty()) {
Dan Albertd99d9022015-05-06 16:48:52 -07001302 serial = "(no serial number)";
Elliott Hughese67f1f82015-04-30 17:32:03 -07001303 }
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001304
1305 if (!long_listing) {
Elliott Hughese67f1f82015-04-30 17:32:03 -07001306 *result += serial;
1307 *result += '\t';
1308 *result += t->connection_state_name();
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001309 } else {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001310 android::base::StringAppendF(result, "%-22s %s", serial.c_str(),
1311 t->connection_state_name().c_str());
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001312
Elliott Hughese67f1f82015-04-30 17:32:03 -07001313 append_transport_info(result, "", t->devpath, false);
1314 append_transport_info(result, "product:", t->product, false);
1315 append_transport_info(result, "model:", t->model, true);
1316 append_transport_info(result, "device:", t->device, false);
Josh Gaob122b172017-08-16 16:57:01 -07001317
1318 // Put id at the end, so that anyone parsing the output here can always find it by scanning
1319 // backwards from newlines, even with hypothetical devices named 'transport_id:1'.
1320 *result += " transport_id:";
1321 *result += std::to_string(t->id);
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001322 }
Elliott Hughese67f1f82015-04-30 17:32:03 -07001323 *result += '\n';
Scott Anderson2ca3e6b2012-05-30 18:11:27 -07001324}
1325
Elliott Hughese67f1f82015-04-30 17:32:03 -07001326std::string list_transports(bool long_listing) {
Josh Gao1db71af2017-08-17 13:50:51 -07001327 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Artem Iglikov04398a92017-12-17 10:56:07 +00001328
1329 auto sorted_transport_list = transport_list;
1330 sorted_transport_list.sort([](atransport*& x, atransport*& y) {
1331 if (x->type != y->type) {
1332 return x->type < y->type;
1333 }
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001334 return x->serial < y->serial;
Artem Iglikov04398a92017-12-17 10:56:07 +00001335 });
1336
1337 std::string result;
1338 for (const auto& t : sorted_transport_list) {
Elliott Hughese67f1f82015-04-30 17:32:03 -07001339 append_transport(t, &result, long_listing);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001340 }
Elliott Hughese67f1f82015-04-30 17:32:03 -07001341 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001342}
1343
Josh Gao3705b342019-03-28 15:47:44 -07001344void close_usb_devices(std::function<bool(const atransport*)> predicate, bool reset) {
Josh Gao1db71af2017-08-17 13:50:51 -07001345 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gao22d2b3e2016-10-27 14:01:08 -07001346 for (auto& t : transport_list) {
1347 if (predicate(t)) {
Josh Gao3705b342019-03-28 15:47:44 -07001348 if (reset) {
1349 t->Reset();
1350 } else {
1351 t->Kick();
1352 }
Josh Gao22d2b3e2016-10-27 14:01:08 -07001353 }
1354 }
1355}
1356
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001357/* hack for osx */
Josh Gao3705b342019-03-28 15:47:44 -07001358void close_usb_devices(bool reset) {
1359 close_usb_devices([](const atransport*) { return true; }, reset);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001360}
Josh Gao1290fbf2016-11-22 14:32:34 -08001361#endif // ADB_HOST
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001362
Josh Gao362e6962018-08-08 16:20:14 -07001363bool register_socket_transport(unique_fd s, std::string serial, int port, int local,
Joshua Duong5cf78682020-01-21 13:19:42 -08001364 atransport::ReconnectCallback reconnect, bool use_tls, int* error) {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -07001365 atransport* t = new atransport(std::move(reconnect), kCsOffline);
Joshua Duong5cf78682020-01-21 13:19:42 -08001366 t->use_tls = use_tls;
David 'Digit' Turner730ff3b2011-01-06 14:11:07 +01001367
Josh Gao3b4de3c2018-08-02 13:58:24 -07001368 D("transport: %s init'ing for socket %d, on port %d", serial.c_str(), s.get(), port);
Josh Gao56300c92018-07-25 17:21:49 -07001369 if (init_socket_transport(t, std::move(s), port, local) < 0) {
Dan Albertc7915a32015-05-18 16:46:31 -07001370 delete t;
Josh Gao362e6962018-08-08 16:20:14 -07001371 if (error) *error = errno;
1372 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001373 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001374
Josh Gao1db71af2017-08-17 13:50:51 -07001375 std::unique_lock<std::recursive_mutex> lock(transport_lock);
Elliott Hughes65fe2512015-10-07 15:59:35 -07001376 for (const auto& transport : pending_list) {
Josh Gao3b4de3c2018-08-02 13:58:24 -07001377 if (serial == transport->serial) {
Yabin Cuib74c6492016-04-29 16:53:52 -07001378 VLOG(TRANSPORT) << "socket transport " << transport->serial
Josh Gao1290fbf2016-11-22 14:32:34 -08001379 << " is already in pending_list and fails to register";
Dan Albertc7915a32015-05-18 16:46:31 -07001380 delete t;
Josh Gao362e6962018-08-08 16:20:14 -07001381 if (error) *error = EALREADY;
1382 return false;
Benoit Goby1c45ee92013-03-29 18:22:36 -07001383 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001384 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001385
Elliott Hughes65fe2512015-10-07 15:59:35 -07001386 for (const auto& transport : transport_list) {
Josh Gao3b4de3c2018-08-02 13:58:24 -07001387 if (serial == transport->serial) {
Yabin Cuib74c6492016-04-29 16:53:52 -07001388 VLOG(TRANSPORT) << "socket transport " << transport->serial
Josh Gao1290fbf2016-11-22 14:32:34 -08001389 << " is already in transport_list and fails to register";
Dan Albertc7915a32015-05-18 16:46:31 -07001390 delete t;
Josh Gao362e6962018-08-08 16:20:14 -07001391 if (error) *error = EALREADY;
1392 return false;
Benoit Goby1c45ee92013-03-29 18:22:36 -07001393 }
1394 }
1395
Josh Gao3b4de3c2018-08-02 13:58:24 -07001396 t->serial = std::move(serial);
Dan Albertc7915a32015-05-18 16:46:31 -07001397 pending_list.push_front(t);
Josh Gao0cd3ae12016-09-21 12:37:10 -07001398
1399 lock.unlock();
Benoit Goby1c45ee92013-03-29 18:22:36 -07001400
Luis Hector Chavez56fe7532018-04-17 14:25:04 -07001401 auto waitable = t->connection_waitable();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001402 register_transport(t);
Luis Hector Chavez56fe7532018-04-17 14:25:04 -07001403
Luis Hector Chavezc587f022018-05-01 17:12:16 -07001404 if (local == 1) {
1405 // Do not wait for emulator transports.
Josh Gao362e6962018-08-08 16:20:14 -07001406 return true;
Luis Hector Chavezc587f022018-05-01 17:12:16 -07001407 }
1408
Josh Gao362e6962018-08-08 16:20:14 -07001409 if (!waitable->WaitForConnection(std::chrono::seconds(10))) {
1410 if (error) *error = ETIMEDOUT;
1411 return false;
1412 }
1413
1414 if (t->GetConnectionState() == kCsUnauthorized) {
1415 if (error) *error = EPERM;
1416 return false;
1417 }
1418
1419 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001420}
1421
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001422#if ADB_HOST
Josh Gao1290fbf2016-11-22 14:32:34 -08001423atransport* find_transport(const char* serial) {
Dan Albertc7915a32015-05-18 16:46:31 -07001424 atransport* result = nullptr;
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001425
Josh Gao1db71af2017-08-17 13:50:51 -07001426 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Yabin Cuif4b99282015-08-27 12:03:11 -07001427 for (auto& t : transport_list) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001428 if (strcmp(serial, t->serial.c_str()) == 0) {
Dan Albertc7915a32015-05-18 16:46:31 -07001429 result = t;
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001430 break;
1431 }
Dan Albertc7915a32015-05-18 16:46:31 -07001432 }
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001433
Dan Albertc7915a32015-05-18 16:46:31 -07001434 return result;
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001435}
1436
Yabin Cuif4b99282015-08-27 12:03:11 -07001437void kick_all_tcp_devices() {
Josh Gao1db71af2017-08-17 13:50:51 -07001438 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Yabin Cuif4b99282015-08-27 12:03:11 -07001439 for (auto& t : transport_list) {
Yabin Cuib74c6492016-04-29 16:53:52 -07001440 if (t->IsTcpDevice()) {
Yabin Cuid6ab3c22015-08-31 11:50:24 -07001441 // Kicking breaks the read_transport thread of this transport out of any read, then
1442 // the read_transport thread will notify the main thread to make this transport
1443 // offline. Then the main thread will notify the write_transport thread to exit.
Yabin Cuif4b99282015-08-27 12:03:11 -07001444 // Finally, this transport will be closed and freed in the main thread.
Yabin Cui7f274902016-04-18 11:22:34 -07001445 t->Kick();
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001446 }
Dan Albertc7915a32015-05-18 16:46:31 -07001447 }
Josh Gao902dace2018-08-10 14:44:54 -07001448#if ADB_HOST
1449 reconnect_handler.CheckForKicked();
1450#endif
Mike Lockwoodcbbe79a2010-05-24 10:44:35 -04001451}
1452
Mike Lockwood8cf0d592009-10-11 23:04:18 -04001453#endif
1454
Josh Gao1290fbf2016-11-22 14:32:34 -08001455void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath,
1456 unsigned writeable) {
Luis Hector Chavez454bc7c2018-04-20 10:31:29 -07001457 atransport* t = new atransport(writeable ? kCsOffline : kCsNoPerm);
Dan Albertc7915a32015-05-18 16:46:31 -07001458
Josh Gao1290fbf2016-11-22 14:32:34 -08001459 D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : "");
Yabin Cuib5e11412017-03-10 16:01:01 -08001460 init_usb_transport(t, usb);
Josh Gao1290fbf2016-11-22 14:32:34 -08001461 if (serial) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001462 t->serial = serial;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001463 }
Dan Albertc7915a32015-05-18 16:46:31 -07001464
1465 if (devpath) {
Luis Hector Chavez6150a372018-07-18 21:18:27 -07001466 t->devpath = devpath;
Scott Andersone109d262012-04-20 11:21:14 -07001467 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001468
Josh Gao0cd3ae12016-09-21 12:37:10 -07001469 {
Josh Gao1db71af2017-08-17 13:50:51 -07001470 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gao0cd3ae12016-09-21 12:37:10 -07001471 pending_list.push_front(t);
1472 }
Benoit Goby1c45ee92013-03-29 18:22:36 -07001473
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001474 register_transport(t);
1475}
1476
Josh Gaoc51726c2018-10-11 16:33:05 -07001477#if ADB_HOST
Dan Albertdcd78a12015-05-18 16:43:57 -07001478// This should only be used for transports with connection_state == kCsNoPerm.
Josh Gao1290fbf2016-11-22 14:32:34 -08001479void unregister_usb_transport(usb_handle* usb) {
Josh Gao1db71af2017-08-17 13:50:51 -07001480 std::lock_guard<std::recursive_mutex> lock(transport_lock);
Josh Gaob800d882018-01-28 20:32:46 -08001481 transport_list.remove_if([usb](atransport* t) {
Josh Gaoce5ce872018-12-11 13:11:52 -08001482 return t->GetUsbHandle() == usb && t->GetConnectionState() == kCsNoPerm;
Josh Gaob800d882018-01-28 20:32:46 -08001483 });
Mike Lockwood0927bf92009-08-08 12:37:44 -04001484}
Josh Gaoc51726c2018-10-11 16:33:05 -07001485#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001486
Josh Gao36dadca2017-05-16 15:02:45 -07001487bool check_header(apacket* p, atransport* t) {
Josh Gao1290fbf2016-11-22 14:32:34 -08001488 if (p->msg.magic != (p->msg.command ^ 0xffffffff)) {
Yabin Cuib5e11412017-03-10 16:01:01 -08001489 VLOG(RWX) << "check_header(): invalid magic command = " << std::hex << p->msg.command
1490 << ", magic = " << p->msg.magic;
Josh Gao36dadca2017-05-16 15:02:45 -07001491 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001492 }
1493
Josh Gao1290fbf2016-11-22 14:32:34 -08001494 if (p->msg.data_length > t->get_max_payload()) {
1495 VLOG(RWX) << "check_header(): " << p->msg.data_length
1496 << " atransport::max_payload = " << t->get_max_payload();
Josh Gao36dadca2017-05-16 15:02:45 -07001497 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001498 }
1499
Josh Gao36dadca2017-05-16 15:02:45 -07001500 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001501}
1502
Josh Gao3bd28792016-10-05 19:02:29 -07001503#if ADB_HOST
Joshua Duong5cf78682020-01-21 13:19:42 -08001504std::shared_ptr<RSA> atransport::Key() {
1505 if (keys_.empty()) {
1506 return nullptr;
1507 }
1508
1509 std::shared_ptr<RSA> result = keys_[0];
1510 return result;
1511}
1512
Josh Gao2e671202016-08-18 22:00:12 -07001513std::shared_ptr<RSA> atransport::NextKey() {
Josh Gao4414e4c2018-12-04 01:07:50 -08001514 if (keys_.empty()) {
1515 LOG(INFO) << "fetching keys for transport " << this->serial_name();
1516 keys_ = adb_auth_get_private_keys();
1517
1518 // We should have gotten at least one key: the one that's automatically generated.
1519 CHECK(!keys_.empty());
Joshua Duong5cf78682020-01-21 13:19:42 -08001520 } else {
1521 keys_.pop_front();
Josh Gao4414e4c2018-12-04 01:07:50 -08001522 }
Elliott Hughes0aeb5052016-06-29 17:42:01 -07001523
Josh Gao2e671202016-08-18 22:00:12 -07001524 std::shared_ptr<RSA> result = keys_[0];
Elliott Hughes0aeb5052016-06-29 17:42:01 -07001525 return result;
1526}
Josh Gao4414e4c2018-12-04 01:07:50 -08001527
1528void atransport::ResetKeys() {
1529 keys_.clear();
1530}
Josh Gao3bd28792016-10-05 19:02:29 -07001531#endif