1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #if !ADB_HOST
18
19 #define TRACE_TAG ADB_WIRELESS
20
21 #include "adb_wifi.h"
22
23 #include <unistd.h>
24 #include <optional>
25
26 #include <adbd_auth.h>
27 #include <android-base/properties.h>
28
29 #include "adb.h"
30 #include "daemon/mdns.h"
31 #include "sysdeps.h"
32 #include "transport.h"
33
34 using namespace android::base;
35
36 namespace {
37
38 static AdbdAuthContext* auth_ctx;
39
40 static void adb_disconnected(void* unused, atransport* t);
41 static struct adisconnect adb_disconnect = {adb_disconnected, nullptr};
42
adb_disconnected(void * unused,atransport * t)43 static void adb_disconnected(void* unused, atransport* t) {
44 LOG(INFO) << "ADB wifi device disconnected";
45 CHECK(t->auth_id.has_value());
46 adbd_auth_tls_device_disconnected(auth_ctx, kAdbTransportTypeWifi, t->auth_id.value());
47 }
48
49 // TODO(b/31559095): need bionic host so that we can use 'prop_info' returned
50 // from WaitForProperty
51 #if defined(__ANDROID__)
52
53 class TlsServer {
54 public:
55 explicit TlsServer(int port);
56 virtual ~TlsServer();
57 bool Start();
port()58 uint16_t port() { return port_; };
59
60 private:
61 void OnFdEvent(int fd, unsigned ev);
62 static void StaticOnFdEvent(int fd, unsigned ev, void* opaque);
63
64 fdevent* fd_event_ = nullptr;
65 uint16_t port_;
66 }; // TlsServer
67
TlsServer(int port)68 TlsServer::TlsServer(int port) : port_(port) {}
69
~TlsServer()70 TlsServer::~TlsServer() {
71 fdevent* fde = fd_event_;
72 fdevent_run_on_main_thread([fde]() {
73 if (fde != nullptr) {
74 fdevent_destroy(fde);
75 }
76 });
77 }
78
Start()79 bool TlsServer::Start() {
80 std::condition_variable cv;
81 std::mutex mutex;
82 std::optional<bool> success;
83 auto callback = [&](bool result) {
84 {
85 std::lock_guard<std::mutex> lock(mutex);
86 success = result;
87 }
88 cv.notify_one();
89 };
90
91 std::string err;
92 unique_fd fd(network_inaddr_any_server(port_, SOCK_STREAM, &err));
93 if (fd.get() == -1) {
94 LOG(ERROR) << "Failed to start TLS server [" << err << "]";
95 return false;
96 }
97 close_on_exec(fd.get());
98 int port = socket_get_local_port(fd.get());
99 if (port <= 0 || port > 65535) {
100 LOG(ERROR) << "Invalid port for tls server";
101 return false;
102 }
103 port_ = static_cast<uint16_t>(port);
104 LOG(INFO) << "adbwifi started on port " << port_;
105
106 std::unique_lock<std::mutex> lock(mutex);
107 fdevent_run_on_main_thread([&]() {
108 fd_event_ = fdevent_create(fd.release(), &TlsServer::StaticOnFdEvent, this);
109 if (fd_event_ == nullptr) {
110 LOG(ERROR) << "Failed to create fd event for TlsServer.";
111 callback(false);
112 return;
113 }
114 callback(true);
115 });
116
117 cv.wait(lock, [&]() { return success.has_value(); });
118 if (!*success) {
119 LOG(INFO) << "TlsServer fdevent_create failed";
120 return false;
121 }
122 fdevent_set(fd_event_, FDE_READ);
123 LOG(INFO) << "TlsServer running on port " << port_;
124
125 return *success;
126 }
127
128 // static
StaticOnFdEvent(int fd,unsigned ev,void * opaque)129 void TlsServer::StaticOnFdEvent(int fd, unsigned ev, void* opaque) {
130 auto server = reinterpret_cast<TlsServer*>(opaque);
131 server->OnFdEvent(fd, ev);
132 }
133
OnFdEvent(int fd,unsigned ev)134 void TlsServer::OnFdEvent(int fd, unsigned ev) {
135 if ((ev & FDE_READ) == 0 || fd != fd_event_->fd.get()) {
136 LOG(INFO) << __func__ << ": No read [ev=" << ev << " fd=" << fd << "]";
137 return;
138 }
139
140 unique_fd new_fd(adb_socket_accept(fd, nullptr, nullptr));
141 if (new_fd >= 0) {
142 LOG(INFO) << "New TLS connection [fd=" << new_fd.get() << "]";
143 close_on_exec(new_fd.get());
144 disable_tcp_nagle(new_fd.get());
145 std::string serial = android::base::StringPrintf("host-%d", new_fd.get());
146 register_socket_transport(
147 std::move(new_fd), std::move(serial), port_, 1,
148 [](atransport*) { return ReconnectResult::Abort; }, true);
149 }
150 }
151
152 TlsServer* sTlsServer = nullptr;
153 const char kWifiPortProp[] = "service.adb.tls.port";
154
155 const char kWifiEnabledProp[] = "persist.adb.tls_server.enable";
156
enable_wifi_debugging()157 static void enable_wifi_debugging() {
158 start_mdnsd();
159
160 if (sTlsServer != nullptr) {
161 delete sTlsServer;
162 }
163 sTlsServer = new TlsServer(0);
164 if (!sTlsServer->Start()) {
165 LOG(ERROR) << "Failed to start TlsServer";
166 delete sTlsServer;
167 sTlsServer = nullptr;
168 return;
169 }
170
171 // Start mdns connect service for discovery
172 register_adb_secure_connect_service(sTlsServer->port());
173 LOG(INFO) << "adb wifi started on port " << sTlsServer->port();
174 SetProperty(kWifiPortProp, std::to_string(sTlsServer->port()));
175 }
176
disable_wifi_debugging()177 static void disable_wifi_debugging() {
178 if (sTlsServer != nullptr) {
179 delete sTlsServer;
180 sTlsServer = nullptr;
181 }
182 if (is_adb_secure_connect_service_registered()) {
183 unregister_adb_secure_connect_service();
184 }
185 kick_all_tcp_tls_transports();
186 LOG(INFO) << "adb wifi stopped";
187 SetProperty(kWifiPortProp, "");
188 }
189
190 // Watches for the #kWifiEnabledProp property to toggle the TlsServer
start_wifi_enabled_observer()191 static void start_wifi_enabled_observer() {
192 std::thread([]() {
193 bool wifi_enabled = false;
194 while (true) {
195 std::string toggled_val = wifi_enabled ? "0" : "1";
196 LOG(INFO) << "Waiting for " << kWifiEnabledProp << "=" << toggled_val;
197 if (WaitForProperty(kWifiEnabledProp, toggled_val)) {
198 wifi_enabled = !wifi_enabled;
199 LOG(INFO) << kWifiEnabledProp << " changed to " << toggled_val;
200 if (wifi_enabled) {
201 enable_wifi_debugging();
202 } else {
203 disable_wifi_debugging();
204 }
205 }
206 }
207 }).detach();
208 }
209 #endif //__ANDROID__
210
211 } // namespace
212
adbd_wifi_init(AdbdAuthContext * ctx)213 void adbd_wifi_init(AdbdAuthContext* ctx) {
214 auth_ctx = ctx;
215 #if defined(__ANDROID__)
216 start_wifi_enabled_observer();
217 #endif //__ANDROID__
218 }
219
adbd_wifi_secure_connect(atransport * t)220 void adbd_wifi_secure_connect(atransport* t) {
221 t->AddDisconnect(&adb_disconnect);
222 handle_online(t);
223 send_connect(t);
224 LOG(INFO) << __func__ << ": connected " << t->serial;
225 t->auth_id = adbd_auth_tls_device_connected(auth_ctx, kAdbTransportTypeWifi, t->auth_key.data(),
226 t->auth_key.size());
227 }
228
229 #endif /* !HOST */
230