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