1 /*
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
17 #define TRACE_TAG ADB
18
19 #include "sysdeps.h"
20 #include "adb.h"
21
22 #include <ctype.h>
23 #include <errno.h>
24 #include <stdarg.h>
25 #include <stddef.h>
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <sys/time.h>
31 #include <time.h>
32
33 #include <chrono>
34 #include <condition_variable>
35 #include <mutex>
36 #include <string>
37 #include <string_view>
38 #include <thread>
39 #include <vector>
40
41 #include <android-base/errors.h>
42 #include <android-base/file.h>
43 #include <android-base/logging.h>
44 #include <android-base/macros.h>
45 #include <android-base/parsenetaddress.h>
46 #include <android-base/stringprintf.h>
47 #include <android-base/strings.h>
48 #include <build/version.h>
49 #include <platform_tools_version.h>
50
51 #include "adb_auth.h"
52 #include "adb_io.h"
53 #include "adb_listeners.h"
54 #include "adb_unique_fd.h"
55 #include "adb_utils.h"
56 #include "adb_wifi.h"
57 #include "sysdeps/chrono.h"
58 #include "transport.h"
59
60 #if !ADB_HOST
61 #include <sys/capability.h>
62 #include <sys/mount.h>
63 #include <android-base/properties.h>
64 using namespace std::chrono_literals;
65
66 #include "daemon/logging.h"
67 #endif
68
69 #if ADB_HOST
70 #include "client/usb.h"
71 #endif
72
adb_version()73 std::string adb_version() {
74 // Don't change the format of this --- it's parsed by ddmlib.
75 return android::base::StringPrintf(
76 "Android Debug Bridge version %d.%d.%d\n"
77 "Version %s-%s\n"
78 "Installed as %s\n",
79 ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
80 PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str(),
81 android::base::GetExecutablePath().c_str());
82 }
83
calculate_apacket_checksum(const apacket * p)84 uint32_t calculate_apacket_checksum(const apacket* p) {
85 uint32_t sum = 0;
86 for (size_t i = 0; i < p->msg.data_length; ++i) {
87 sum += static_cast<uint8_t>(p->payload[i]);
88 }
89 return sum;
90 }
91
get_apacket(void)92 apacket* get_apacket(void)
93 {
94 apacket* p = new apacket();
95 if (p == nullptr) {
96 LOG(FATAL) << "failed to allocate an apacket";
97 }
98
99 memset(&p->msg, 0, sizeof(p->msg));
100 return p;
101 }
102
put_apacket(apacket * p)103 void put_apacket(apacket *p)
104 {
105 delete p;
106 }
107
handle_online(atransport * t)108 void handle_online(atransport *t)
109 {
110 D("adb: online");
111 t->online = 1;
112 t->SetConnectionEstablished(true);
113 }
114
handle_offline(atransport * t)115 void handle_offline(atransport *t)
116 {
117 if (t->GetConnectionState() == kCsOffline) {
118 LOG(INFO) << t->serial_name() << ": already offline";
119 return;
120 }
121
122 LOG(INFO) << t->serial_name() << ": offline";
123
124 t->SetConnectionState(kCsOffline);
125
126 // Close the associated usb
127 t->online = 0;
128
129 // This is necessary to avoid a race condition that occurred when a transport closes
130 // while a client socket is still active.
131 close_all_sockets(t);
132
133 t->RunDisconnects();
134 }
135
136 #if DEBUG_PACKETS
137 #define DUMPMAX 32
print_packet(const char * label,apacket * p)138 void print_packet(const char *label, apacket *p)
139 {
140 const char* tag;
141 unsigned count;
142
143 switch(p->msg.command){
144 case A_SYNC: tag = "SYNC"; break;
145 case A_CNXN: tag = "CNXN" ; break;
146 case A_OPEN: tag = "OPEN"; break;
147 case A_OKAY: tag = "OKAY"; break;
148 case A_CLSE: tag = "CLSE"; break;
149 case A_WRTE: tag = "WRTE"; break;
150 case A_AUTH: tag = "AUTH"; break;
151 case A_STLS:
152 tag = "STLS";
153 break;
154 default: tag = "????"; break;
155 }
156
157 fprintf(stderr, "%s: %s %08x %08x %04x \"",
158 label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
159 count = p->msg.data_length;
160 const char* x = p->payload.data();
161 if (count > DUMPMAX) {
162 count = DUMPMAX;
163 tag = "\n";
164 } else {
165 tag = "\"\n";
166 }
167 while (count-- > 0) {
168 if ((*x >= ' ') && (*x < 127)) {
169 fputc(*x, stderr);
170 } else {
171 fputc('.', stderr);
172 }
173 x++;
174 }
175 fputs(tag, stderr);
176 }
177 #endif
178
send_ready(unsigned local,unsigned remote,atransport * t)179 static void send_ready(unsigned local, unsigned remote, atransport *t)
180 {
181 D("Calling send_ready");
182 apacket *p = get_apacket();
183 p->msg.command = A_OKAY;
184 p->msg.arg0 = local;
185 p->msg.arg1 = remote;
186 send_packet(p, t);
187 }
188
send_close(unsigned local,unsigned remote,atransport * t)189 static void send_close(unsigned local, unsigned remote, atransport *t)
190 {
191 D("Calling send_close");
192 apacket *p = get_apacket();
193 p->msg.command = A_CLSE;
194 p->msg.arg0 = local;
195 p->msg.arg1 = remote;
196 send_packet(p, t);
197 }
198
get_connection_string()199 std::string get_connection_string() {
200 std::vector<std::string> connection_properties;
201
202 #if !ADB_HOST
203 static const char* cnxn_props[] = {
204 "ro.product.name",
205 "ro.product.model",
206 "ro.product.device",
207 };
208
209 for (const auto& prop : cnxn_props) {
210 std::string value = std::string(prop) + "=" + android::base::GetProperty(prop, "");
211 connection_properties.push_back(value);
212 }
213 #endif
214
215 connection_properties.push_back(android::base::StringPrintf(
216 "features=%s", FeatureSetToString(supported_features()).c_str()));
217
218 return android::base::StringPrintf(
219 "%s::%s", adb_device_banner,
220 android::base::Join(connection_properties, ';').c_str());
221 }
222
send_tls_request(atransport * t)223 void send_tls_request(atransport* t) {
224 D("Calling send_tls_request");
225 apacket* p = get_apacket();
226 p->msg.command = A_STLS;
227 p->msg.arg0 = A_STLS_VERSION;
228 p->msg.data_length = 0;
229 send_packet(p, t);
230 }
231
send_connect(atransport * t)232 void send_connect(atransport* t) {
233 D("Calling send_connect");
234 apacket* cp = get_apacket();
235 cp->msg.command = A_CNXN;
236 // Send the max supported version, but because the transport is
237 // initialized to A_VERSION_MIN, this will be compatible with every
238 // device.
239 cp->msg.arg0 = A_VERSION;
240 cp->msg.arg1 = t->get_max_payload();
241
242 std::string connection_str = get_connection_string();
243 // Connect and auth packets are limited to MAX_PAYLOAD_V1 because we don't
244 // yet know how much data the other size is willing to accept.
245 if (connection_str.length() > MAX_PAYLOAD_V1) {
246 LOG(FATAL) << "Connection banner is too long (length = "
247 << connection_str.length() << ")";
248 }
249
250 cp->payload.assign(connection_str.begin(), connection_str.end());
251 cp->msg.data_length = cp->payload.size();
252
253 send_packet(cp, t);
254 }
255
parse_banner(const std::string & banner,atransport * t)256 void parse_banner(const std::string& banner, atransport* t) {
257 D("parse_banner: %s", banner.c_str());
258
259 // The format is something like:
260 // "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;".
261 std::vector<std::string> pieces = android::base::Split(banner, ":");
262
263 // Reset the features list or else if the server sends no features we may
264 // keep the existing feature set (http://b/24405971).
265 t->SetFeatures("");
266
267 if (pieces.size() > 2) {
268 const std::string& props = pieces[2];
269 for (const auto& prop : android::base::Split(props, ";")) {
270 // The list of properties was traditionally ;-terminated rather than ;-separated.
271 if (prop.empty()) continue;
272
273 std::vector<std::string> key_value = android::base::Split(prop, "=");
274 if (key_value.size() != 2) continue;
275
276 const std::string& key = key_value[0];
277 const std::string& value = key_value[1];
278 if (key == "ro.product.name") {
279 t->product = value;
280 } else if (key == "ro.product.model") {
281 t->model = value;
282 } else if (key == "ro.product.device") {
283 t->device = value;
284 } else if (key == "features") {
285 t->SetFeatures(value);
286 }
287 }
288 }
289
290 const std::string& type = pieces[0];
291 if (type == "bootloader") {
292 D("setting connection_state to kCsBootloader");
293 t->SetConnectionState(kCsBootloader);
294 } else if (type == "device") {
295 D("setting connection_state to kCsDevice");
296 t->SetConnectionState(kCsDevice);
297 } else if (type == "recovery") {
298 D("setting connection_state to kCsRecovery");
299 t->SetConnectionState(kCsRecovery);
300 } else if (type == "sideload") {
301 D("setting connection_state to kCsSideload");
302 t->SetConnectionState(kCsSideload);
303 } else if (type == "rescue") {
304 D("setting connection_state to kCsRescue");
305 t->SetConnectionState(kCsRescue);
306 } else {
307 D("setting connection_state to kCsHost");
308 t->SetConnectionState(kCsHost);
309 }
310 }
311
handle_new_connection(atransport * t,apacket * p)312 static void handle_new_connection(atransport* t, apacket* p) {
313 handle_offline(t);
314
315 t->update_version(p->msg.arg0, p->msg.arg1);
316 std::string banner(p->payload.begin(), p->payload.end());
317 parse_banner(banner, t);
318
319 #if ADB_HOST
320 handle_online(t);
321 #else
322 ADB_LOG(Connection) << "received CNXN: version=" << p->msg.arg0 << ", maxdata = " << p->msg.arg1
323 << ", banner = '" << banner << "'";
324
325 if (t->use_tls) {
326 // We still handshake in TLS mode. If auth_required is disabled,
327 // we'll just not verify the client's certificate. This should be the
328 // first packet the client receives to indicate the new protocol.
329 send_tls_request(t);
330 } else if (!auth_required) {
331 LOG(INFO) << "authentication not required";
332 handle_online(t);
333 send_connect(t);
334 } else {
335 send_auth_request(t);
336 }
337 #endif
338
339 update_transports();
340 }
341
handle_packet(apacket * p,atransport * t)342 void handle_packet(apacket *p, atransport *t)
343 {
344 D("handle_packet() %c%c%c%c", ((char*) (&(p->msg.command)))[0],
345 ((char*) (&(p->msg.command)))[1],
346 ((char*) (&(p->msg.command)))[2],
347 ((char*) (&(p->msg.command)))[3]);
348 print_packet("recv", p);
349 CHECK_EQ(p->payload.size(), p->msg.data_length);
350
351 switch(p->msg.command){
352 case A_CNXN: // CONNECT(version, maxdata, "system-id-string")
353 handle_new_connection(t, p);
354 break;
355 case A_STLS: // TLS(version, "")
356 t->use_tls = true;
357 #if ADB_HOST
358 send_tls_request(t);
359 adb_auth_tls_handshake(t);
360 #else
361 adbd_auth_tls_handshake(t);
362 #endif
363 break;
364
365 case A_AUTH:
366 // All AUTH commands are ignored in TLS mode
367 if (t->use_tls) {
368 break;
369 }
370 switch (p->msg.arg0) {
371 #if ADB_HOST
372 case ADB_AUTH_TOKEN:
373 if (t->GetConnectionState() != kCsAuthorizing) {
374 t->SetConnectionState(kCsAuthorizing);
375 }
376 send_auth_response(p->payload.data(), p->msg.data_length, t);
377 break;
378 #else
379 case ADB_AUTH_SIGNATURE: {
380 // TODO: Switch to string_view.
381 std::string signature(p->payload.begin(), p->payload.end());
382 std::string auth_key;
383 if (adbd_auth_verify(t->token, sizeof(t->token), signature, &auth_key)) {
384 adbd_auth_verified(t);
385 t->failed_auth_attempts = 0;
386 t->auth_key = auth_key;
387 adbd_notify_framework_connected_key(t);
388 } else {
389 if (t->failed_auth_attempts++ > 256) std::this_thread::sleep_for(1s);
390 send_auth_request(t);
391 }
392 break;
393 }
394
395 case ADB_AUTH_RSAPUBLICKEY:
396 t->auth_key = std::string(p->payload.data());
397 adbd_auth_confirm_key(t);
398 break;
399 #endif
400 default:
401 t->SetConnectionState(kCsOffline);
402 handle_offline(t);
403 break;
404 }
405 break;
406
407 case A_OPEN: /* OPEN(local-id, 0, "destination") */
408 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) {
409 std::string_view address(p->payload.begin(), p->payload.size());
410
411 // Historically, we received service names as a char*, and stopped at the first NUL
412 // byte. The client sent strings with null termination, which post-string_view, start
413 // being interpreted as part of the string, unless we explicitly strip them.
414 address = StripTrailingNulls(address);
415
416 asocket* s = create_local_service_socket(address, t);
417 if (s == nullptr) {
418 send_close(0, p->msg.arg0, t);
419 } else {
420 s->peer = create_remote_socket(p->msg.arg0, t);
421 s->peer->peer = s;
422 send_ready(s->id, s->peer->id, t);
423 s->ready(s);
424 }
425 }
426 break;
427
428 case A_OKAY: /* READY(local-id, remote-id, "") */
429 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
430 asocket* s = find_local_socket(p->msg.arg1, 0);
431 if (s) {
432 if(s->peer == nullptr) {
433 /* On first READY message, create the connection. */
434 s->peer = create_remote_socket(p->msg.arg0, t);
435 s->peer->peer = s;
436 s->ready(s);
437 } else if (s->peer->id == p->msg.arg0) {
438 /* Other READY messages must use the same local-id */
439 s->ready(s);
440 } else {
441 D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s", p->msg.arg0,
442 p->msg.arg1, s->peer->id, p->msg.arg1, t->serial.c_str());
443 }
444 } else {
445 // When receiving A_OKAY from device for A_OPEN request, the host server may
446 // have closed the local socket because of client disconnection. Then we need
447 // to send A_CLSE back to device to close the service on device.
448 send_close(p->msg.arg1, p->msg.arg0, t);
449 }
450 }
451 break;
452
453 case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */
454 if (t->online && p->msg.arg1 != 0) {
455 asocket* s = find_local_socket(p->msg.arg1, p->msg.arg0);
456 if (s) {
457 /* According to protocol.txt, p->msg.arg0 might be 0 to indicate
458 * a failed OPEN only. However, due to a bug in previous ADB
459 * versions, CLOSE(0, remote-id, "") was also used for normal
460 * CLOSE() operations.
461 *
462 * This is bad because it means a compromised adbd could
463 * send packets to close connections between the host and
464 * other devices. To avoid this, only allow this if the local
465 * socket has a peer on the same transport.
466 */
467 if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) {
468 D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s", p->msg.arg1,
469 t->serial.c_str(), s->peer->transport->serial.c_str());
470 } else {
471 s->close(s);
472 }
473 }
474 }
475 break;
476
477 case A_WRTE: /* WRITE(local-id, remote-id, <data>) */
478 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
479 asocket* s = find_local_socket(p->msg.arg1, p->msg.arg0);
480 if (s) {
481 unsigned rid = p->msg.arg0;
482 if (s->enqueue(s, std::move(p->payload)) == 0) {
483 D("Enqueue the socket");
484 send_ready(s->id, rid, t);
485 }
486 }
487 }
488 break;
489
490 default:
491 printf("handle_packet: what is %08x?!\n", p->msg.command);
492 }
493
494 put_apacket(p);
495 }
496
497 #if ADB_HOST
498
499 #ifdef _WIN32
500
501 // Try to make a handle non-inheritable and if there is an error, don't output
502 // any error info, but leave GetLastError() for the caller to read. This is
503 // convenient if the caller is expecting that this may fail and they'd like to
504 // ignore such a failure.
_try_make_handle_noninheritable(HANDLE h)505 static bool _try_make_handle_noninheritable(HANDLE h) {
506 if (h != INVALID_HANDLE_VALUE && h != NULL) {
507 return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false;
508 }
509
510 return true;
511 }
512
513 // Try to make a handle non-inheritable with the expectation that this should
514 // succeed, so if this fails, output error info.
_make_handle_noninheritable(HANDLE h)515 static bool _make_handle_noninheritable(HANDLE h) {
516 if (!_try_make_handle_noninheritable(h)) {
517 // Show the handle value to give us a clue in case we have problems
518 // with pseudo-handle values.
519 fprintf(stderr, "adb: cannot make handle 0x%p non-inheritable: %s\n", h,
520 android::base::SystemErrorCodeToString(GetLastError()).c_str());
521 return false;
522 }
523
524 return true;
525 }
526
527 // Create anonymous pipe, preventing inheritance of the read pipe and setting
528 // security of the write pipe to sa.
_create_anonymous_pipe(unique_handle * pipe_read_out,unique_handle * pipe_write_out,SECURITY_ATTRIBUTES * sa)529 static bool _create_anonymous_pipe(unique_handle* pipe_read_out,
530 unique_handle* pipe_write_out,
531 SECURITY_ATTRIBUTES* sa) {
532 HANDLE pipe_read_raw = NULL;
533 HANDLE pipe_write_raw = NULL;
534 if (!CreatePipe(&pipe_read_raw, &pipe_write_raw, sa, 0)) {
535 fprintf(stderr, "adb: CreatePipe failed: %s\n",
536 android::base::SystemErrorCodeToString(GetLastError()).c_str());
537 return false;
538 }
539
540 unique_handle pipe_read(pipe_read_raw);
541 pipe_read_raw = NULL;
542 unique_handle pipe_write(pipe_write_raw);
543 pipe_write_raw = NULL;
544
545 if (!_make_handle_noninheritable(pipe_read.get())) {
546 return false;
547 }
548
549 *pipe_read_out = std::move(pipe_read);
550 *pipe_write_out = std::move(pipe_write);
551
552 return true;
553 }
554
555 // Read from a pipe (that we take ownership of) and write the result to stdout/stderr. Return on
556 // error or when the pipe is closed. Internally makes inheritable handles, so this should not be
557 // called if subprocesses may be started concurrently.
_redirect_pipe_thread(HANDLE h,DWORD nStdHandle)558 static unsigned _redirect_pipe_thread(HANDLE h, DWORD nStdHandle) {
559 // Take ownership of the HANDLE and close when we're done.
560 unique_handle read_pipe(h);
561 const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ? "stdout" : "stderr";
562 const int original_fd = fileno(nStdHandle == STD_OUTPUT_HANDLE ? stdout : stderr);
563 std::unique_ptr<FILE, decltype(&fclose)> stream(nullptr, fclose);
564
565 if (original_fd == -1) {
566 fprintf(stderr, "adb: failed to get file descriptor for %s: %s\n", output_name,
567 strerror(errno));
568 return EXIT_FAILURE;
569 }
570
571 // If fileno() is -2, stdout/stderr is not associated with an output stream, so we should read,
572 // but don't write. Otherwise, make a FILE* identical to stdout/stderr except that it is in
573 // binary mode with no CR/LR translation since we're reading raw.
574 if (original_fd >= 0) {
575 // This internally makes a duplicate file handle that is inheritable, so callers should not
576 // call this function if subprocesses may be started concurrently.
577 const int fd = dup(original_fd);
578 if (fd == -1) {
579 fprintf(stderr, "adb: failed to duplicate file descriptor for %s: %s\n", output_name,
580 strerror(errno));
581 return EXIT_FAILURE;
582 }
583
584 // Note that although we call fdopen() below with a binary flag, it may not adhere to that
585 // flag, so we have to set the mode manually.
586 if (_setmode(fd, _O_BINARY) == -1) {
587 fprintf(stderr, "adb: failed to set binary mode for duplicate of %s: %s\n", output_name,
588 strerror(errno));
589 unix_close(fd);
590 return EXIT_FAILURE;
591 }
592
593 stream.reset(fdopen(fd, "wb"));
594 if (stream.get() == nullptr) {
595 fprintf(stderr, "adb: failed to open duplicate stream for %s: %s\n", output_name,
596 strerror(errno));
597 unix_close(fd);
598 return EXIT_FAILURE;
599 }
600
601 // Unbuffer the stream because it will be buffered by default and we want subprocess output
602 // to be shown immediately.
603 if (setvbuf(stream.get(), NULL, _IONBF, 0) == -1) {
604 fprintf(stderr, "adb: failed to unbuffer %s: %s\n", output_name, strerror(errno));
605 return EXIT_FAILURE;
606 }
607
608 // fd will be closed when stream is closed.
609 }
610
611 while (true) {
612 char buf[64 * 1024];
613 DWORD bytes_read = 0;
614 if (!ReadFile(read_pipe.get(), buf, sizeof(buf), &bytes_read, NULL)) {
615 const DWORD err = GetLastError();
616 // ERROR_BROKEN_PIPE is expected when the subprocess closes
617 // the other end of the pipe.
618 if (err == ERROR_BROKEN_PIPE) {
619 return EXIT_SUCCESS;
620 } else {
621 fprintf(stderr, "adb: failed to read from %s: %s\n", output_name,
622 android::base::SystemErrorCodeToString(err).c_str());
623 return EXIT_FAILURE;
624 }
625 }
626
627 // Don't try to write if our stdout/stderr was not setup by the parent process.
628 if (stream) {
629 // fwrite() actually calls adb_fwrite() which can write UTF-8 to the console.
630 const size_t bytes_written = fwrite(buf, 1, bytes_read, stream.get());
631 if (bytes_written != bytes_read) {
632 fprintf(stderr, "adb: error: only wrote %zu of %lu bytes to %s\n", bytes_written,
633 bytes_read, output_name);
634 return EXIT_FAILURE;
635 }
636 }
637 }
638 }
639
_redirect_stdout_thread(HANDLE h)640 static unsigned __stdcall _redirect_stdout_thread(HANDLE h) {
641 adb_thread_setname("stdout redirect");
642 return _redirect_pipe_thread(h, STD_OUTPUT_HANDLE);
643 }
644
_redirect_stderr_thread(HANDLE h)645 static unsigned __stdcall _redirect_stderr_thread(HANDLE h) {
646 adb_thread_setname("stderr redirect");
647 return _redirect_pipe_thread(h, STD_ERROR_HANDLE);
648 }
649
650 #endif
651
ReportServerStartupFailure(pid_t pid)652 static void ReportServerStartupFailure(pid_t pid) {
653 fprintf(stderr, "ADB server didn't ACK\n");
654 fprintf(stderr, "Full server startup log: %s\n", GetLogFilePath().c_str());
655 fprintf(stderr, "Server had pid: %d\n", pid);
656
657 android::base::unique_fd fd(unix_open(GetLogFilePath(), O_RDONLY));
658 if (fd == -1) return;
659
660 // Let's not show more than 128KiB of log...
661 unix_lseek(fd, -128 * 1024, SEEK_END);
662 std::string content;
663 if (!android::base::ReadFdToString(fd, &content)) return;
664
665 std::string header = android::base::StringPrintf("--- adb starting (pid %d) ---", pid);
666 std::vector<std::string> lines = android::base::Split(content, "\n");
667 int i = lines.size() - 1;
668 while (i >= 0 && lines[i] != header) --i;
669 while (static_cast<size_t>(i) < lines.size()) fprintf(stderr, "%s\n", lines[i++].c_str());
670 }
671
launch_server(const std::string & socket_spec)672 int launch_server(const std::string& socket_spec) {
673 #if defined(_WIN32)
674 /* we need to start the server in the background */
675 /* we create a PIPE that will be used to wait for the server's "OK" */
676 /* message since the pipe handles must be inheritable, we use a */
677 /* security attribute */
678 SECURITY_ATTRIBUTES sa;
679 sa.nLength = sizeof(sa);
680 sa.lpSecurityDescriptor = NULL;
681 sa.bInheritHandle = TRUE;
682
683 // Redirect stdin to Windows /dev/null. If we instead pass an original
684 // stdin/stdout/stderr handle and it is a console handle, when the adb
685 // server starts up, the C Runtime will see a console handle for a process
686 // that isn't connected to a console and it will configure
687 // stdin/stdout/stderr to be closed. At that point, freopen() could be used
688 // to reopen stderr/out, but it would take more massaging to fixup the file
689 // descriptor number that freopen() uses. It's simplest to avoid all of this
690 // complexity by just redirecting stdin to `nul' and then the C Runtime acts
691 // as expected.
692 unique_handle nul_read(CreateFileW(L"nul", GENERIC_READ,
693 FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, OPEN_EXISTING,
694 FILE_ATTRIBUTE_NORMAL, NULL));
695 if (nul_read.get() == INVALID_HANDLE_VALUE) {
696 fprintf(stderr, "adb: CreateFileW 'nul' failed: %s\n",
697 android::base::SystemErrorCodeToString(GetLastError()).c_str());
698 return -1;
699 }
700
701 // Create pipes with non-inheritable read handle, inheritable write handle. We need to connect
702 // the subprocess to pipes instead of just letting the subprocess inherit our existing
703 // stdout/stderr handles because a DETACHED_PROCESS cannot write to a console that it is not
704 // attached to.
705 unique_handle ack_read, ack_write;
706 if (!_create_anonymous_pipe(&ack_read, &ack_write, &sa)) {
707 return -1;
708 }
709 unique_handle stdout_read, stdout_write;
710 if (!_create_anonymous_pipe(&stdout_read, &stdout_write, &sa)) {
711 return -1;
712 }
713 unique_handle stderr_read, stderr_write;
714 if (!_create_anonymous_pipe(&stderr_read, &stderr_write, &sa)) {
715 return -1;
716 }
717
718 /* Some programs want to launch an adb command and collect its output by
719 * calling CreateProcess with inheritable stdout/stderr handles, then
720 * using read() to get its output. When this happens, the stdout/stderr
721 * handles passed to the adb client process will also be inheritable.
722 * When starting the adb server here, care must be taken to reset them
723 * to non-inheritable.
724 * Otherwise, something bad happens: even if the adb command completes,
725 * the calling process is stuck while read()-ing from the stdout/stderr
726 * descriptors, because they're connected to corresponding handles in the
727 * adb server process (even if the latter never uses/writes to them).
728 * Note that even if we don't pass these handles in the STARTUPINFO struct,
729 * if they're marked inheritable, they're still inherited, requiring us to
730 * deal with this.
731 *
732 * If we're still having problems with inheriting random handles in the
733 * future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly
734 * specify which handles should be inherited: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/16/10248328.aspx
735 *
736 * Older versions of Windows return console pseudo-handles that cannot be
737 * made non-inheritable, so ignore those failures.
738 */
739 _try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE));
740 _try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE));
741 _try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE));
742
743 STARTUPINFOW startup;
744 ZeroMemory( &startup, sizeof(startup) );
745 startup.cb = sizeof(startup);
746 startup.hStdInput = nul_read.get();
747 startup.hStdOutput = stdout_write.get();
748 startup.hStdError = stderr_write.get();
749 startup.dwFlags = STARTF_USESTDHANDLES;
750
751 // Verify that the pipe_write handle value can be passed on the command line
752 // as %d and that the rest of adb code can pass it around in an int.
753 const int ack_write_as_int = cast_handle_to_int(ack_write.get());
754 if (cast_int_to_handle(ack_write_as_int) != ack_write.get()) {
755 // If this fires, either handle values are larger than 32-bits or else
756 // there is a bug in our casting.
757 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx
758 fprintf(stderr, "adb: cannot fit pipe handle value into 32-bits: 0x%p\n", ack_write.get());
759 return -1;
760 }
761
762 // get path of current program
763 WCHAR program_path[MAX_PATH];
764 const DWORD module_result = GetModuleFileNameW(NULL, program_path,
765 arraysize(program_path));
766 if ((module_result >= arraysize(program_path)) || (module_result == 0)) {
767 // String truncation or some other error.
768 fprintf(stderr, "adb: cannot get executable path: %s\n",
769 android::base::SystemErrorCodeToString(GetLastError()).c_str());
770 return -1;
771 }
772
773 WCHAR args[64];
774 snwprintf(args, arraysize(args), L"adb -L %s fork-server server --reply-fd %d",
775 socket_spec.c_str(), ack_write_as_int);
776
777 PROCESS_INFORMATION pinfo;
778 ZeroMemory(&pinfo, sizeof(pinfo));
779
780 if (!CreateProcessW(
781 program_path, /* program path */
782 args,
783 /* the fork-server argument will set the
784 debug = 2 in the child */
785 NULL, /* process handle is not inheritable */
786 NULL, /* thread handle is not inheritable */
787 TRUE, /* yes, inherit some handles */
788 DETACHED_PROCESS, /* the new process doesn't have a console */
789 NULL, /* use parent's environment block */
790 NULL, /* use parent's starting directory */
791 &startup, /* startup info, i.e. std handles */
792 &pinfo )) {
793 fprintf(stderr, "adb: CreateProcessW failed: %s\n",
794 android::base::SystemErrorCodeToString(GetLastError()).c_str());
795 return -1;
796 }
797
798 unique_handle process_handle(pinfo.hProcess);
799 pinfo.hProcess = NULL;
800
801 // Close handles that we no longer need to complete the rest.
802 CloseHandle(pinfo.hThread);
803 pinfo.hThread = NULL;
804
805 nul_read.reset();
806 ack_write.reset();
807 stdout_write.reset();
808 stderr_write.reset();
809
810 // Start threads to read from subprocess stdout/stderr and write to ours to make subprocess
811 // errors easier to diagnose. Note that the threads internally create inheritable handles, but
812 // that is ok because we've already spawned the subprocess.
813
814 // In the past, reading from a pipe before the child process's C Runtime
815 // started up and called GetFileType() caused a hang: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/02/10243553.aspx#10244216
816 // This is reportedly fixed in Windows Vista: https://support.microsoft.com/en-us/kb/2009703
817 // I was unable to reproduce the problem on Windows XP. It sounds like a
818 // Windows Update may have fixed this: https://www.duckware.com/tech/peeknamedpipe.html
819 unique_handle stdout_thread(reinterpret_cast<HANDLE>(
820 _beginthreadex(NULL, 0, _redirect_stdout_thread, stdout_read.get(),
821 0, NULL)));
822 if (stdout_thread.get() == nullptr) {
823 fprintf(stderr, "adb: cannot create thread: %s\n", strerror(errno));
824 return -1;
825 }
826 stdout_read.release(); // Transfer ownership to new thread
827
828 unique_handle stderr_thread(reinterpret_cast<HANDLE>(
829 _beginthreadex(NULL, 0, _redirect_stderr_thread, stderr_read.get(),
830 0, NULL)));
831 if (stderr_thread.get() == nullptr) {
832 fprintf(stderr, "adb: cannot create thread: %s\n", strerror(errno));
833 return -1;
834 }
835 stderr_read.release(); // Transfer ownership to new thread
836
837 bool got_ack = false;
838
839 // Wait for the "OK\n" message, for the pipe to be closed, or other error.
840 {
841 char temp[3];
842 DWORD count = 0;
843
844 if (ReadFile(ack_read.get(), temp, sizeof(temp), &count, NULL)) {
845 const CHAR expected[] = "OK\n";
846 const DWORD expected_length = arraysize(expected) - 1;
847 if (count == expected_length &&
848 memcmp(temp, expected, expected_length) == 0) {
849 got_ack = true;
850 } else {
851 ReportServerStartupFailure(pinfo.dwProcessId);
852 return -1;
853 }
854 } else {
855 const DWORD err = GetLastError();
856 // If the ACK was not written and the process exited, GetLastError()
857 // is probably ERROR_BROKEN_PIPE, in which case that info is not
858 // useful to the user.
859 fprintf(stderr, "could not read ok from ADB Server%s\n",
860 err == ERROR_BROKEN_PIPE ? "" :
861 android::base::StringPrintf(": %s",
862 android::base::SystemErrorCodeToString(err).c_str()).c_str());
863 }
864 }
865
866 // Always try to wait a bit for threads reading stdout/stderr to finish.
867 // If the process started ok, it should close the pipes causing the threads
868 // to finish. If the process had an error, it should exit, also causing
869 // the pipes to be closed. In that case we want to read all of the output
870 // and write it out so that the user can diagnose failures.
871 const DWORD thread_timeout_ms = 15 * 1000;
872 const HANDLE threads[] = { stdout_thread.get(), stderr_thread.get() };
873 const DWORD wait_result = WaitForMultipleObjects(arraysize(threads),
874 threads, TRUE, thread_timeout_ms);
875 if (wait_result == WAIT_TIMEOUT) {
876 // Threads did not finish after waiting a little while. Perhaps the
877 // server didn't close pipes, or it is hung.
878 fprintf(stderr, "adb: timed out waiting for threads to finish reading from ADB server\n");
879 // Process handles are signaled when the process exits, so if we wait
880 // on the handle for 0 seconds and it returns 'timeout', that means that
881 // the process is still running.
882 if (WaitForSingleObject(process_handle.get(), 0) == WAIT_TIMEOUT) {
883 // We could TerminateProcess(), but that seems somewhat presumptive.
884 fprintf(stderr, "adb: server is running with process id %lu\n", pinfo.dwProcessId);
885 }
886 return -1;
887 }
888
889 if (wait_result != WAIT_OBJECT_0) {
890 fprintf(stderr, "adb: unexpected result waiting for threads: %lu: %s\n", wait_result,
891 android::base::SystemErrorCodeToString(GetLastError()).c_str());
892 return -1;
893 }
894
895 // For now ignore the thread exit codes and assume they worked properly.
896
897 if (!got_ack) {
898 return -1;
899 }
900 #else /* !defined(_WIN32) */
901 // set up a pipe so the child can tell us when it is ready.
902 unique_fd pipe_read, pipe_write;
903 if (!Pipe(&pipe_read, &pipe_write)) {
904 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
905 return -1;
906 }
907
908 std::string path = android::base::GetExecutablePath();
909
910 pid_t pid = fork();
911 if (pid < 0) return -1;
912
913 if (pid == 0) {
914 // child side of the fork
915 pipe_read.reset();
916
917 // android::base::Pipe unconditionally opens the pipe with O_CLOEXEC.
918 // Undo this manually.
919 fcntl(pipe_write.get(), F_SETFD, 0);
920
921 char reply_fd[30];
922 snprintf(reply_fd, sizeof(reply_fd), "%d", pipe_write.get());
923 // child process
924 int result = execl(path.c_str(), "adb", "-L", socket_spec.c_str(), "fork-server", "server",
925 "--reply-fd", reply_fd, NULL);
926 // this should not return
927 fprintf(stderr, "adb: execl returned %d: %s\n", result, strerror(errno));
928 } else {
929 // parent side of the fork
930 char temp[3] = {};
931 // wait for the "OK\n" message
932 pipe_write.reset();
933 int ret = adb_read(pipe_read.get(), temp, 3);
934 int saved_errno = errno;
935 pipe_read.reset();
936 if (ret < 0) {
937 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
938 return -1;
939 }
940 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
941 ReportServerStartupFailure(pid);
942 return -1;
943 }
944 }
945 #endif /* !defined(_WIN32) */
946 return 0;
947 }
948 #endif /* ADB_HOST */
949
handle_forward_request(const char * service,atransport * transport,int reply_fd)950 bool handle_forward_request(const char* service, atransport* transport, int reply_fd) {
951 return handle_forward_request(service, [transport](std::string*) { return transport; },
952 reply_fd);
953 }
954
955 // Try to handle a network forwarding request.
handle_forward_request(const char * service,std::function<atransport * (std::string * error)> transport_acquirer,int reply_fd)956 bool handle_forward_request(const char* service,
957 std::function<atransport*(std::string* error)> transport_acquirer,
958 int reply_fd) {
959 if (!strcmp(service, "list-forward")) {
960 // Create the list of forward redirections.
961 std::string listeners = format_listeners();
962 #if ADB_HOST
963 SendOkay(reply_fd);
964 #endif
965 SendProtocolString(reply_fd, listeners);
966 return true;
967 }
968
969 if (!strcmp(service, "killforward-all")) {
970 remove_all_listeners();
971 #if ADB_HOST
972 /* On the host: 1st OKAY is connect, 2nd OKAY is status */
973 SendOkay(reply_fd);
974 #endif
975 SendOkay(reply_fd);
976 return true;
977 }
978
979 if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) {
980 // killforward:local
981 // forward:(norebind:)?local;remote
982 std::string error;
983 atransport* transport = transport_acquirer(&error);
984 if (!transport) {
985 SendFail(reply_fd, error);
986 return true;
987 }
988
989 bool kill_forward = false;
990 bool no_rebind = false;
991 if (android::base::StartsWith(service, "killforward:")) {
992 kill_forward = true;
993 service += 12;
994 } else {
995 service += 8; // skip past "forward:"
996 if (android::base::StartsWith(service, "norebind:")) {
997 no_rebind = true;
998 service += 9;
999 }
1000 }
1001
1002 std::vector<std::string> pieces = android::base::Split(service, ";");
1003
1004 if (kill_forward) {
1005 // Check killforward: parameter format: '<local>'
1006 if (pieces.size() != 1 || pieces[0].empty()) {
1007 SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service));
1008 return true;
1009 }
1010 } else {
1011 // Check forward: parameter format: '<local>;<remote>'
1012 if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') {
1013 SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service));
1014 return true;
1015 }
1016 }
1017
1018 InstallStatus r;
1019 int resolved_tcp_port = 0;
1020 if (kill_forward) {
1021 r = remove_listener(pieces[0].c_str(), transport);
1022 } else {
1023 r = install_listener(pieces[0], pieces[1].c_str(), transport, no_rebind,
1024 &resolved_tcp_port, &error);
1025 }
1026 if (r == INSTALL_STATUS_OK) {
1027 #if ADB_HOST
1028 // On the host: 1st OKAY is connect, 2nd OKAY is status.
1029 SendOkay(reply_fd);
1030 #endif
1031 SendOkay(reply_fd);
1032
1033 // If a TCP port was resolved, send the actual port number back.
1034 if (resolved_tcp_port != 0) {
1035 SendProtocolString(reply_fd, android::base::StringPrintf("%d", resolved_tcp_port));
1036 }
1037
1038 return true;
1039 }
1040
1041 std::string message;
1042 switch (r) {
1043 case INSTALL_STATUS_OK: message = "success (!)"; break;
1044 case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break;
1045 case INSTALL_STATUS_CANNOT_BIND:
1046 message = android::base::StringPrintf("cannot bind listener: %s",
1047 error.c_str());
1048 break;
1049 case INSTALL_STATUS_CANNOT_REBIND:
1050 message = android::base::StringPrintf("cannot rebind existing socket");
1051 break;
1052 case INSTALL_STATUS_LISTENER_NOT_FOUND:
1053 message = android::base::StringPrintf("listener '%s' not found", service);
1054 break;
1055 }
1056 SendFail(reply_fd, message);
1057 return true;
1058 }
1059
1060 return false;
1061 }
1062
1063 #if ADB_HOST
SendOkay(int fd,const std::string & s)1064 static int SendOkay(int fd, const std::string& s) {
1065 SendOkay(fd);
1066 SendProtocolString(fd, s);
1067 return 0;
1068 }
1069
handle_host_request(std::string_view service,TransportType type,const char * serial,TransportId transport_id,int reply_fd,asocket * s)1070 HostRequestResult handle_host_request(std::string_view service, TransportType type,
1071 const char* serial, TransportId transport_id, int reply_fd,
1072 asocket* s) {
1073 if (service == "kill") {
1074 fprintf(stderr, "adb server killed by remote request\n");
1075 fflush(stdout);
1076
1077 // Send a reply even though we don't read it anymore, so that old versions
1078 // of adb that do read it don't spew error messages.
1079 SendOkay(reply_fd);
1080
1081 // Rely on process exit to close the socket for us.
1082 exit(0);
1083 }
1084
1085 LOG(DEBUG) << "handle_host_request(" << service << ")";
1086
1087 // Transport selection:
1088 if (service.starts_with("transport") || service.starts_with("tport:")) {
1089 TransportType type = kTransportAny;
1090
1091 std::string serial_storage;
1092 bool legacy = true;
1093
1094 // New transport selection protocol:
1095 // This is essentially identical to the previous version, except it returns the selected
1096 // transport id to the caller as well.
1097 if (android::base::ConsumePrefix(&service, "tport:")) {
1098 legacy = false;
1099 if (android::base::ConsumePrefix(&service, "serial:")) {
1100 serial_storage = service;
1101 serial = serial_storage.c_str();
1102 } else if (service == "usb") {
1103 type = kTransportUsb;
1104 } else if (service == "local") {
1105 type = kTransportLocal;
1106 } else if (service == "any") {
1107 type = kTransportAny;
1108 }
1109
1110 // Selection by id is unimplemented, since you obviously already know the transport id
1111 // you're connecting to.
1112 } else {
1113 if (android::base::ConsumePrefix(&service, "transport-id:")) {
1114 if (!ParseUint(&transport_id, service)) {
1115 SendFail(reply_fd, "invalid transport id");
1116 return HostRequestResult::Handled;
1117 }
1118 } else if (service == "transport-usb") {
1119 type = kTransportUsb;
1120 } else if (service == "transport-local") {
1121 type = kTransportLocal;
1122 } else if (service == "transport-any") {
1123 type = kTransportAny;
1124 } else if (android::base::ConsumePrefix(&service, "transport:")) {
1125 serial_storage = service;
1126 serial = serial_storage.c_str();
1127 }
1128 }
1129
1130 std::string error;
1131 atransport* t = acquire_one_transport(type, serial, transport_id, nullptr, &error);
1132 if (t != nullptr) {
1133 s->transport = t;
1134 SendOkay(reply_fd);
1135
1136 if (!legacy) {
1137 // Nothing we can do if this fails.
1138 WriteFdExactly(reply_fd, &t->id, sizeof(t->id));
1139 }
1140
1141 return HostRequestResult::SwitchedTransport;
1142 } else {
1143 SendFail(reply_fd, error);
1144 return HostRequestResult::Handled;
1145 }
1146 }
1147
1148 // return a list of all connected devices
1149 if (service == "devices" || service == "devices-l") {
1150 bool long_listing = service == "devices-l";
1151 D("Getting device list...");
1152 std::string device_list = list_transports(long_listing);
1153 D("Sending device list...");
1154 SendOkay(reply_fd, device_list);
1155 return HostRequestResult::Handled;
1156 }
1157
1158 if (service == "reconnect-offline") {
1159 std::string response;
1160 close_usb_devices([&response](const atransport* transport) {
1161 if (!ConnectionStateIsOnline(transport->GetConnectionState())) {
1162 response += "reconnecting " + transport->serial_name() + "\n";
1163 return true;
1164 }
1165 return false;
1166 }, true);
1167 if (!response.empty()) {
1168 response.resize(response.size() - 1);
1169 }
1170 SendOkay(reply_fd, response);
1171 return HostRequestResult::Handled;
1172 }
1173
1174 if (service == "features") {
1175 std::string error;
1176 atransport* t =
1177 s->transport ? s->transport
1178 : acquire_one_transport(type, serial, transport_id, nullptr, &error);
1179 if (t != nullptr) {
1180 SendOkay(reply_fd, FeatureSetToString(t->features()));
1181 } else {
1182 SendFail(reply_fd, error);
1183 }
1184 return HostRequestResult::Handled;
1185 }
1186
1187 if (service == "host-features") {
1188 FeatureSet features = supported_features();
1189 // Abuse features to report libusb status.
1190 if (should_use_libusb()) {
1191 features.insert(kFeatureLibusb);
1192 }
1193 features.insert(kFeaturePushSync);
1194 SendOkay(reply_fd, FeatureSetToString(features));
1195 return HostRequestResult::Handled;
1196 }
1197
1198 // remove TCP transport
1199 if (service.starts_with("disconnect:")) {
1200 std::string address(service.substr(11));
1201 if (address.empty()) {
1202 kick_all_tcp_devices();
1203 SendOkay(reply_fd, "disconnected everything");
1204 return HostRequestResult::Handled;
1205 }
1206
1207 std::string serial;
1208 std::string host;
1209 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
1210 std::string error;
1211 if (address.starts_with("vsock:") || address.starts_with("localfilesystem:")) {
1212 serial = address;
1213 } else if (!android::base::ParseNetAddress(address, &host, &port, &serial, &error)) {
1214 SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s",
1215 address.c_str(), error.c_str()));
1216 return HostRequestResult::Handled;
1217 }
1218 atransport* t = find_transport(serial.c_str());
1219 if (t == nullptr) {
1220 SendFail(reply_fd, android::base::StringPrintf("no such device '%s'", serial.c_str()));
1221 return HostRequestResult::Handled;
1222 }
1223 kick_transport(t);
1224 SendOkay(reply_fd, android::base::StringPrintf("disconnected %s", address.c_str()));
1225 return HostRequestResult::Handled;
1226 }
1227
1228 // Returns our value for ADB_SERVER_VERSION.
1229 if (service == "version") {
1230 SendOkay(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION));
1231 return HostRequestResult::Handled;
1232 }
1233
1234 // These always report "unknown" rather than the actual error, for scripts.
1235 if (service == "get-serialno") {
1236 std::string error;
1237 atransport* t =
1238 s->transport ? s->transport
1239 : acquire_one_transport(type, serial, transport_id, nullptr, &error);
1240 if (t) {
1241 SendOkay(reply_fd, !t->serial.empty() ? t->serial : "unknown");
1242 } else {
1243 SendFail(reply_fd, error);
1244 }
1245 return HostRequestResult::Handled;
1246 }
1247 if (service == "get-devpath") {
1248 std::string error;
1249 atransport* t =
1250 s->transport ? s->transport
1251 : acquire_one_transport(type, serial, transport_id, nullptr, &error);
1252 if (t) {
1253 SendOkay(reply_fd, !t->devpath.empty() ? t->devpath : "unknown");
1254 } else {
1255 SendFail(reply_fd, error);
1256 }
1257 return HostRequestResult::Handled;
1258 }
1259 if (service == "get-state") {
1260 std::string error;
1261 atransport* t =
1262 s->transport ? s->transport
1263 : acquire_one_transport(type, serial, transport_id, nullptr, &error);
1264 if (t) {
1265 SendOkay(reply_fd, t->connection_state_name());
1266 } else {
1267 SendFail(reply_fd, error);
1268 }
1269 return HostRequestResult::Handled;
1270 }
1271
1272 // Indicates a new emulator instance has started.
1273 if (android::base::ConsumePrefix(&service, "emulator:")) {
1274 unsigned int port;
1275 if (!ParseUint(&port, service)) {
1276 LOG(ERROR) << "received invalid port for emulator: " << service;
1277 } else {
1278 local_connect(port);
1279 }
1280
1281 /* we don't even need to send a reply */
1282 return HostRequestResult::Handled;
1283 }
1284
1285 if (service == "reconnect") {
1286 std::string response;
1287 atransport* t = s->transport ? s->transport
1288 : acquire_one_transport(type, serial, transport_id, nullptr,
1289 &response, true);
1290 if (t != nullptr) {
1291 kick_transport(t, true);
1292 response =
1293 "reconnecting " + t->serial_name() + " [" + t->connection_state_name() + "]\n";
1294 }
1295 SendOkay(reply_fd, response);
1296 return HostRequestResult::Handled;
1297 }
1298
1299 // TODO: Switch handle_forward_request to string_view.
1300 std::string service_str(service);
1301 auto transport_acquirer = [=](std::string* error) {
1302 if (s->transport) {
1303 return s->transport;
1304 } else {
1305 std::string error;
1306 return acquire_one_transport(type, serial, transport_id, nullptr, &error);
1307 }
1308 };
1309 if (handle_forward_request(service_str.c_str(), transport_acquirer, reply_fd)) {
1310 return HostRequestResult::Handled;
1311 }
1312
1313 return HostRequestResult::Unhandled;
1314 }
1315
1316 static auto& init_mutex = *new std::mutex();
1317 static auto& init_cv = *new std::condition_variable();
1318 static bool device_scan_complete = false;
1319 static bool transports_ready = false;
1320
update_transport_status()1321 void update_transport_status() {
1322 bool result = iterate_transports([](const atransport* t) {
1323 if (t->type == kTransportUsb && t->online != 1) {
1324 return false;
1325 }
1326 return true;
1327 });
1328
1329 bool ready;
1330 {
1331 std::lock_guard<std::mutex> lock(init_mutex);
1332 transports_ready = result;
1333 ready = transports_ready && device_scan_complete;
1334 }
1335
1336 if (ready) {
1337 init_cv.notify_all();
1338 }
1339 }
1340
adb_notify_device_scan_complete()1341 void adb_notify_device_scan_complete() {
1342 {
1343 std::lock_guard<std::mutex> lock(init_mutex);
1344 if (device_scan_complete) {
1345 return;
1346 }
1347
1348 device_scan_complete = true;
1349 }
1350
1351 update_transport_status();
1352 }
1353
adb_wait_for_device_initialization()1354 void adb_wait_for_device_initialization() {
1355 std::unique_lock<std::mutex> lock(init_mutex);
1356 init_cv.wait_for(lock, 3s, []() { return device_scan_complete && transports_ready; });
1357 }
1358
1359 #endif // ADB_HOST
1360