1 /*
2  * Copyright (C) 2015 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 
21 #include <signal.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 
26 #include <thread>
27 
28 #include <android-base/errors.h>
29 #include <android-base/file.h>
30 #include <android-base/logging.h>
31 #include <android-base/stringprintf.h>
32 
33 #include "adb.h"
34 #include "adb_auth.h"
35 #include "adb_client.h"
36 #include "adb_listeners.h"
37 #include "adb_mdns.h"
38 #include "adb_utils.h"
39 #include "adb_wifi.h"
40 #include "client/usb.h"
41 #include "commandline.h"
42 #include "sysdeps/chrono.h"
43 #include "transport.h"
44 
45 const char** __adb_argv;
46 const char** __adb_envp;
47 
setup_daemon_logging()48 static void setup_daemon_logging() {
49     const std::string log_file_path(GetLogFilePath());
50     int fd = unix_open(log_file_path, O_WRONLY | O_CREAT | O_APPEND, 0640);
51     if (fd == -1) {
52         PLOG(FATAL) << "cannot open " << log_file_path;
53     }
54     if (dup2(fd, STDOUT_FILENO) == -1) {
55         PLOG(FATAL) << "cannot redirect stdout";
56     }
57     if (dup2(fd, STDERR_FILENO) == -1) {
58         PLOG(FATAL) << "cannot redirect stderr";
59     }
60     unix_close(fd);
61 
62     fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid());
63     LOG(INFO) << adb_version();
64 }
65 
adb_server_cleanup()66 void adb_server_cleanup() {
67     // Upon exit, we want to clean up in the following order:
68     //   1. close_smartsockets, so that we don't get any new clients
69     //   2. kick_all_transports, to avoid writing only part of a packet to a transport.
70     //   3. usb_cleanup, to tear down the USB stack.
71     //   4. mdns_cleanup, to tear down mdns stack.
72     close_smartsockets();
73     kick_all_transports();
74     usb_cleanup();
75     mdns_cleanup();
76 }
77 
intentionally_leak()78 static void intentionally_leak() {
79     void* p = ::operator new(1);
80     // The analyzer is upset about this leaking. NOLINTNEXTLINE
81     LOG(INFO) << "leaking pointer " << p;
82 }
83 
84 // one_device: if null, server owns all devices, else server owns only
85 //     device where atransport::MatchesTarget(one_device) is true.
adb_server_main(int is_daemon,const std::string & socket_spec,const char * one_device,int ack_reply_fd)86 int adb_server_main(int is_daemon, const std::string& socket_spec, const char* one_device,
87                     int ack_reply_fd) {
88 #if defined(_WIN32)
89     // adb start-server starts us up with stdout and stderr hooked up to
90     // anonymous pipes. When the C Runtime sees this, it makes stderr and
91     // stdout buffered, but to improve the chance that error output is seen,
92     // unbuffer stdout and stderr just like if we were run at the console.
93     // This also keeps stderr unbuffered when it is redirected to adb.log.
94     if (is_daemon) {
95         if (setvbuf(stdout, nullptr, _IONBF, 0) == -1) {
96             PLOG(FATAL) << "cannot make stdout unbuffered";
97         }
98         if (setvbuf(stderr, nullptr, _IONBF, 0) == -1) {
99             PLOG(FATAL) << "cannot make stderr unbuffered";
100         }
101     }
102 
103     // TODO: On Ctrl-C, consider trying to kill a starting up adb server (if we're in
104     // launch_server) by calling GenerateConsoleCtrlEvent().
105 
106     // On Windows, SIGBREAK is when Ctrl-Break is pressed or the console window is closed. It should
107     // act like Ctrl-C.
108     signal(SIGBREAK, [](int) { raise(SIGINT); });
109 #endif
110     signal(SIGINT, [](int) { fdevent_run_on_looper([]() { exit(0); }); });
111 
112     if (one_device) {
113         transport_set_one_device(one_device);
114     }
115 
116     const char* reject_kill_server = getenv("ADB_REJECT_KILL_SERVER");
117     if (reject_kill_server && strcmp(reject_kill_server, "1") == 0) {
118         adb_set_reject_kill_server(true);
119     }
120 
121     const char* leak = getenv("ADB_LEAK");
122     if (leak && strcmp(leak, "1") == 0) {
123         intentionally_leak();
124     }
125 
126     if (is_daemon) {
127         close_stdin();
128         setup_daemon_logging();
129     }
130 
131     atexit(adb_server_cleanup);
132 
133     init_reconnect_handler();
134 
135     if (!getenv("ADB_MDNS") || strcmp(getenv("ADB_MDNS"), "0") != 0) {
136         init_mdns_transport_discovery();
137     }
138 
139     if (!getenv("ADB_USB") || strcmp(getenv("ADB_USB"), "0") != 0) {
140         if (should_use_libusb()) {
141             libusb::usb_init();
142         } else {
143             usb_init();
144         }
145     } else {
146         adb_notify_device_scan_complete();
147     }
148 
149     if (!getenv("ADB_EMU") || strcmp(getenv("ADB_EMU"), "0") != 0) {
150         local_init(android::base::StringPrintf("tcp:%d", DEFAULT_ADB_LOCAL_TRANSPORT_PORT));
151     }
152 
153     std::string error;
154 
155     auto start = std::chrono::steady_clock::now();
156 
157     // If we told a previous adb server to quit because of version mismatch, we can get to this
158     // point before it's finished exiting. Retry for a while to give it some time. Don't actually
159     // accept any connections until adb_wait_for_device_initialization finishes below.
160     while (install_listener(socket_spec, kSmartSocketConnectTo, nullptr, INSTALL_LISTENER_DISABLED,
161                             nullptr, &error) != INSTALL_STATUS_OK) {
162         if (std::chrono::steady_clock::now() - start > 0.5s) {
163             LOG(FATAL) << "could not install *smartsocket* listener: " << error;
164         }
165 
166         std::this_thread::sleep_for(100ms);
167     }
168 
169     adb_auth_init();
170 
171     if (is_daemon) {
172 #if !defined(_WIN32)
173         // Start a new session for the daemon. Do this here instead of after the fork so
174         // that a ctrl-c between the "starting server" and "done starting server" messages
175         // gets a chance to terminate the server.
176         // setsid will fail with EPERM if it's already been a lead process of new session.
177         // Ignore such error.
178         if (setsid() == -1 && errno != EPERM) {
179             PLOG(FATAL) << "setsid() failed";
180         }
181 #endif
182     }
183 
184     // Wait for the USB scan to complete before notifying the parent that we're up.
185     // We need to perform this in a thread, because we would otherwise block the event loop.
186     std::thread notify_thread([ack_reply_fd]() {
187         adb_wait_for_device_initialization();
188 
189         if (ack_reply_fd >= 0) {
190             // Any error output written to stderr now goes to adb.log. We could
191             // keep around a copy of the stderr fd and use that to write any errors
192             // encountered by the following code, but that is probably overkill.
193 #if defined(_WIN32)
194             const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd);
195             const CHAR ack[] = "OK\n";
196             const DWORD bytes_to_write = arraysize(ack) - 1;
197             DWORD written = 0;
198             if (!WriteFile(ack_reply_handle, ack, bytes_to_write, &written, NULL)) {
199                 LOG(FATAL) << "cannot write ACK to handle " << ack_reply_handle
200                            << android::base::SystemErrorCodeToString(GetLastError());
201             }
202             if (written != bytes_to_write) {
203                 LOG(FATAL) << "cannot write " << bytes_to_write << " bytes of ACK: only wrote "
204                            << written << " bytes";
205             }
206             CloseHandle(ack_reply_handle);
207 #else
208             // TODO(danalbert): Can't use SendOkay because we're sending "OK\n", not
209             // "OKAY".
210             if (!android::base::WriteStringToFd("OK\n", ack_reply_fd)) {
211                 PLOG(FATAL) << "error writing ACK to fd " << ack_reply_fd;
212             }
213             unix_close(ack_reply_fd);
214 #endif
215         }
216         // We don't accept() client connections until this point: this way, clients
217         // can't see wonky state early in startup even if they're connecting directly
218         // to the server instead of going through the adb program.
219         fdevent_run_on_looper([] { enable_server_sockets(); });
220     });
221     notify_thread.detach();
222 
223 #if defined(__linux__)
224     // Write our location to .android/adb.$PORT, so that older clients can exec us.
225     std::string path;
226     if (!android::base::Readlink("/proc/self/exe", &path)) {
227         PLOG(ERROR) << "failed to readlink /proc/self/exe";
228     }
229 
230     std::optional<std::string> server_executable_path = adb_get_server_executable_path();
231     if (server_executable_path) {
232       if (!android::base::WriteStringToFile(path, *server_executable_path)) {
233           PLOG(ERROR) << "failed to write server path to " << path;
234       }
235     }
236 #endif
237 
238     D("Event loop starting");
239     fdevent_loop();
240     return 0;
241 }
242 
main(int argc,char * argv[],char * envp[])243 int main(int argc, char* argv[], char* envp[]) {
244     __adb_argv = const_cast<const char**>(argv);
245     __adb_envp = const_cast<const char**>(envp);
246     adb_trace_init(argv);
247     return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));
248 }
249