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