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/quick_exit.h>
32 #include <android-base/stringprintf.h>
33
34 #include "adb.h"
35 #include "adb_auth.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
setup_daemon_logging()42 static void setup_daemon_logging() {
43 const std::string log_file_path(GetLogFilePath());
44 int fd = unix_open(log_file_path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0640);
45 if (fd == -1) {
46 fatal("cannot open '%s': %s", log_file_path.c_str(), strerror(errno));
47 }
48 if (dup2(fd, STDOUT_FILENO) == -1) {
49 fatal("cannot redirect stdout: %s", strerror(errno));
50 }
51 if (dup2(fd, STDERR_FILENO) == -1) {
52 fatal("cannot redirect stderr: %s", strerror(errno));
53 }
54 unix_close(fd);
55
56 fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid());
57 LOG(INFO) << adb_version();
58 }
59
60 #if defined(_WIN32)
ctrlc_handler(DWORD type)61 static BOOL WINAPI ctrlc_handler(DWORD type) {
62 // TODO: Consider trying to kill a starting up adb server (if we're in
63 // launch_server) by calling GenerateConsoleCtrlEvent().
64 android::base::quick_exit(STATUS_CONTROL_C_EXIT);
65 return TRUE;
66 }
67 #endif
68
adb_server_cleanup()69 void adb_server_cleanup() {
70 // Upon exit, we want to clean up in the following order:
71 // 1. close_smartsockets, so that we don't get any new clients
72 // 2. kick_all_transports, to avoid writing only part of a packet to a transport.
73 // 3. usb_cleanup, to tear down the USB stack.
74 close_smartsockets();
75 kick_all_transports();
76 usb_cleanup();
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, NULL, _IONBF, 0) == -1) {
88 fatal("cannot make stdout unbuffered: %s", strerror(errno));
89 }
90 if (setvbuf(stderr, NULL, _IONBF, 0) == -1) {
91 fatal("cannot make stderr unbuffered: %s", strerror(errno));
92 }
93 }
94
95 SetConsoleCtrlHandler(ctrlc_handler, TRUE);
96 #else
97 signal(SIGINT, [](int) {
98 fdevent_run_on_main_thread([]() { android::base::quick_exit(0); });
99 });
100 #endif
101
102 if (is_daemon) {
103 close_stdin();
104 setup_daemon_logging();
105 }
106
107 android::base::at_quick_exit(adb_server_cleanup);
108
109 init_transport_registration();
110 init_mdns_transport_discovery();
111
112 usb_init();
113 local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
114
115 std::string error;
116
117 auto start = std::chrono::steady_clock::now();
118
119 // If we told a previous adb server to quit because of version mismatch, we can get to this
120 // point before it's finished exiting. Retry for a while to give it some time.
121 while (install_listener(socket_spec, "*smartsocket*", nullptr, 0, nullptr, &error) !=
122 INSTALL_STATUS_OK) {
123 if (std::chrono::steady_clock::now() - start > 0.5s) {
124 fatal("could not install *smartsocket* listener: %s", error.c_str());
125 }
126
127 std::this_thread::sleep_for(100ms);
128 }
129
130 adb_auth_init();
131
132 if (is_daemon) {
133 #if !defined(_WIN32)
134 // Start a new session for the daemon. Do this here instead of after the fork so
135 // that a ctrl-c between the "starting server" and "done starting server" messages
136 // gets a chance to terminate the server.
137 // setsid will fail with EPERM if it's already been a lead process of new session.
138 // Ignore such error.
139 if (setsid() == -1 && errno != EPERM) {
140 fatal("setsid() failed: %s", strerror(errno));
141 }
142 #endif
143
144 // Wait for the USB scan to complete before notifying the parent that we're up.
145 // We need to perform this in a thread, because we would otherwise block the event loop.
146 std::thread notify_thread([ack_reply_fd]() {
147 adb_wait_for_device_initialization();
148
149 // Any error output written to stderr now goes to adb.log. We could
150 // keep around a copy of the stderr fd and use that to write any errors
151 // encountered by the following code, but that is probably overkill.
152 #if defined(_WIN32)
153 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd);
154 const CHAR ack[] = "OK\n";
155 const DWORD bytes_to_write = arraysize(ack) - 1;
156 DWORD written = 0;
157 if (!WriteFile(ack_reply_handle, ack, bytes_to_write, &written, NULL)) {
158 fatal("adb: cannot write ACK to handle 0x%p: %s", ack_reply_handle,
159 android::base::SystemErrorCodeToString(GetLastError()).c_str());
160 }
161 if (written != bytes_to_write) {
162 fatal("adb: cannot write %lu bytes of ACK: only wrote %lu bytes", bytes_to_write,
163 written);
164 }
165 CloseHandle(ack_reply_handle);
166 #else
167 // TODO(danalbert): Can't use SendOkay because we're sending "OK\n", not
168 // "OKAY".
169 if (!android::base::WriteStringToFd("OK\n", ack_reply_fd)) {
170 fatal_errno("error writing ACK to fd %d", ack_reply_fd);
171 }
172 unix_close(ack_reply_fd);
173 #endif
174 });
175 notify_thread.detach();
176 }
177
178 D("Event loop starting");
179 fdevent_loop();
180
181 return 0;
182 }
183
main(int argc,char ** argv)184 int main(int argc, char** argv) {
185 adb_trace_init(argv);
186 return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));
187 }
188