Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 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 | |
Yabin Cui | aed3c61 | 2015-09-22 15:52:57 -0700 | [diff] [blame] | 17 | #define TRACE_TAG ADB |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 18 | |
| 19 | #include "sysdeps.h" |
| 20 | |
| 21 | #include <signal.h> |
| 22 | #include <stdio.h> |
| 23 | #include <stdlib.h> |
Josh Gao | 9ad736a | 2016-02-04 11:59:12 -0800 | [diff] [blame] | 24 | #include <unistd.h> |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 25 | |
| 26 | // We only build the affinity WAR code for Linux. |
| 27 | #if defined(__linux__) |
| 28 | #include <sched.h> |
| 29 | #endif |
| 30 | |
David Pursell | 5f787ed | 2016-01-27 08:52:53 -0800 | [diff] [blame] | 31 | #include <android-base/errors.h> |
Elliott Hughes | 4f71319 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 32 | #include <android-base/file.h> |
| 33 | #include <android-base/logging.h> |
| 34 | #include <android-base/stringprintf.h> |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 35 | |
| 36 | #include "adb.h" |
| 37 | #include "adb_auth.h" |
| 38 | #include "adb_listeners.h" |
Josh Gao | 7d58607 | 2015-11-20 15:37:31 -0800 | [diff] [blame] | 39 | #include "adb_utils.h" |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 40 | #include "transport.h" |
| 41 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 42 | #if defined(_WIN32) |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 43 | static BOOL WINAPI ctrlc_handler(DWORD type) { |
Spencer Low | 2122c7a | 2015-08-26 18:46:09 -0700 | [diff] [blame] | 44 | // TODO: Consider trying to kill a starting up adb server (if we're in |
| 45 | // launch_server) by calling GenerateConsoleCtrlEvent(). |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 46 | exit(STATUS_CONTROL_C_EXIT); |
| 47 | return TRUE; |
| 48 | } |
| 49 | |
| 50 | static std::string GetLogFilePath() { |
| 51 | const char log_name[] = "adb.log"; |
Spencer Low | cf4ff64 | 2015-05-11 01:08:48 -0700 | [diff] [blame] | 52 | WCHAR temp_path[MAX_PATH]; |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 53 | |
| 54 | // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364992%28v=vs.85%29.aspx |
Spencer Low | cf4ff64 | 2015-05-11 01:08:48 -0700 | [diff] [blame] | 55 | DWORD nchars = GetTempPathW(arraysize(temp_path), temp_path); |
| 56 | if ((nchars >= arraysize(temp_path)) || (nchars == 0)) { |
| 57 | // If string truncation or some other error. |
Spencer Low | 155159c | 2015-08-11 16:08:43 -0700 | [diff] [blame] | 58 | fatal("cannot retrieve temporary file path: %s\n", |
David Pursell | 5f787ed | 2016-01-27 08:52:53 -0800 | [diff] [blame] | 59 | android::base::SystemErrorCodeToString(GetLastError()).c_str()); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 60 | } |
| 61 | |
Spencer Low | d21dc82 | 2015-11-12 15:20:15 -0800 | [diff] [blame] | 62 | std::string temp_path_utf8; |
| 63 | if (!android::base::WideToUTF8(temp_path, &temp_path_utf8)) { |
| 64 | fatal_errno("cannot convert temporary file path from UTF-16 to UTF-8"); |
| 65 | } |
| 66 | |
| 67 | return temp_path_utf8 + log_name; |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 68 | } |
| 69 | #else |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 70 | static std::string GetLogFilePath() { |
| 71 | return std::string("/tmp/adb.log"); |
| 72 | } |
| 73 | #endif |
| 74 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 75 | static void setup_daemon_logging(void) { |
Spencer Low | 155159c | 2015-08-11 16:08:43 -0700 | [diff] [blame] | 76 | const std::string log_file_path(GetLogFilePath()); |
Elliott Hughes | 65433da | 2015-11-18 18:07:48 -0800 | [diff] [blame] | 77 | int fd = unix_open(log_file_path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0640); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 78 | if (fd == -1) { |
Spencer Low | 155159c | 2015-08-11 16:08:43 -0700 | [diff] [blame] | 79 | fatal("cannot open '%s': %s", log_file_path.c_str(), strerror(errno)); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 80 | } |
Spencer Low | 155159c | 2015-08-11 16:08:43 -0700 | [diff] [blame] | 81 | if (dup2(fd, STDOUT_FILENO) == -1) { |
| 82 | fatal("cannot redirect stdout: %s", strerror(errno)); |
| 83 | } |
| 84 | if (dup2(fd, STDERR_FILENO) == -1) { |
| 85 | fatal("cannot redirect stderr: %s", strerror(errno)); |
| 86 | } |
Spencer Low | d0f66c3 | 2015-05-20 23:17:26 -0700 | [diff] [blame] | 87 | unix_close(fd); |
| 88 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 89 | fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid()); |
Siva Velusamy | 743883b | 2015-08-18 17:53:16 -0700 | [diff] [blame] | 90 | LOG(INFO) << adb_version(); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Elliott Hughes | 65433da | 2015-11-18 18:07:48 -0800 | [diff] [blame] | 93 | int adb_server_main(int is_daemon, int server_port, int ack_reply_fd) { |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 94 | #if defined(_WIN32) |
Spencer Low | 2122c7a | 2015-08-26 18:46:09 -0700 | [diff] [blame] | 95 | // adb start-server starts us up with stdout and stderr hooked up to |
Elliott Hughes | 65433da | 2015-11-18 18:07:48 -0800 | [diff] [blame] | 96 | // anonymous pipes. When the C Runtime sees this, it makes stderr and |
Spencer Low | 2122c7a | 2015-08-26 18:46:09 -0700 | [diff] [blame] | 97 | // stdout buffered, but to improve the chance that error output is seen, |
| 98 | // unbuffer stdout and stderr just like if we were run at the console. |
| 99 | // This also keeps stderr unbuffered when it is redirected to adb.log. |
| 100 | if (is_daemon) { |
| 101 | if (setvbuf(stdout, NULL, _IONBF, 0) == -1) { |
| 102 | fatal("cannot make stdout unbuffered: %s", strerror(errno)); |
| 103 | } |
| 104 | if (setvbuf(stderr, NULL, _IONBF, 0) == -1) { |
| 105 | fatal("cannot make stderr unbuffered: %s", strerror(errno)); |
| 106 | } |
| 107 | } |
| 108 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 109 | SetConsoleCtrlHandler(ctrlc_handler, TRUE); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 110 | #endif |
| 111 | |
| 112 | init_transport_registration(); |
| 113 | |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 114 | usb_init(); |
| 115 | local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT); |
| 116 | adb_auth_init(); |
| 117 | |
Spencer Low | 5200c66 | 2015-07-30 23:07:55 -0700 | [diff] [blame] | 118 | std::string error; |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 119 | std::string local_name = android::base::StringPrintf("tcp:%d", server_port); |
Spencer Low | 5200c66 | 2015-07-30 23:07:55 -0700 | [diff] [blame] | 120 | if (install_listener(local_name, "*smartsocket*", nullptr, 0, &error)) { |
Spencer Low | bf7c605 | 2015-08-11 16:45:32 -0700 | [diff] [blame] | 121 | fatal("could not install *smartsocket* listener: %s", error.c_str()); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 122 | } |
| 123 | |
Siva Velusamy | 9f2d1a9 | 2015-08-07 10:10:29 -0700 | [diff] [blame] | 124 | // Inform our parent that we are up and running. |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 125 | if (is_daemon) { |
Spencer Low | 2122c7a | 2015-08-26 18:46:09 -0700 | [diff] [blame] | 126 | close_stdin(); |
| 127 | setup_daemon_logging(); |
| 128 | |
Josh Gao | 9ad736a | 2016-02-04 11:59:12 -0800 | [diff] [blame] | 129 | #if !defined(_WIN32) |
Yabin Cui | 65f7080 | 2016-02-08 22:36:42 -0800 | [diff] [blame] | 130 | // Start a new session for the daemon. Do this here instead of after the fork so |
| 131 | // that a ctrl-c between the "starting server" and "done starting server" messages |
| 132 | // gets a chance to terminate the server. |
| 133 | if (setsid() == -1) { |
| 134 | fatal("setsid() failed: %s", strerror(errno)); |
| 135 | } |
Josh Gao | 9ad736a | 2016-02-04 11:59:12 -0800 | [diff] [blame] | 136 | #endif |
| 137 | |
Spencer Low | 2122c7a | 2015-08-26 18:46:09 -0700 | [diff] [blame] | 138 | // Any error output written to stderr now goes to adb.log. We could |
| 139 | // keep around a copy of the stderr fd and use that to write any errors |
| 140 | // encountered by the following code, but that is probably overkill. |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 141 | #if defined(_WIN32) |
Spencer Low | 5c398d2 | 2015-08-08 15:07:07 -0700 | [diff] [blame] | 142 | const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); |
| 143 | const CHAR ack[] = "OK\n"; |
| 144 | const DWORD bytes_to_write = arraysize(ack) - 1; |
| 145 | DWORD written = 0; |
| 146 | if (!WriteFile(ack_reply_handle, ack, bytes_to_write, &written, NULL)) { |
| 147 | fatal("adb: cannot write ACK to handle 0x%p: %s", ack_reply_handle, |
David Pursell | 5f787ed | 2016-01-27 08:52:53 -0800 | [diff] [blame] | 148 | android::base::SystemErrorCodeToString(GetLastError()).c_str()); |
Spencer Low | 5c398d2 | 2015-08-08 15:07:07 -0700 | [diff] [blame] | 149 | } |
| 150 | if (written != bytes_to_write) { |
| 151 | fatal("adb: cannot write %lu bytes of ACK: only wrote %lu bytes", |
| 152 | bytes_to_write, written); |
| 153 | } |
| 154 | CloseHandle(ack_reply_handle); |
| 155 | #else |
Siva Velusamy | 9f2d1a9 | 2015-08-07 10:10:29 -0700 | [diff] [blame] | 156 | // TODO(danalbert): Can't use SendOkay because we're sending "OK\n", not |
| 157 | // "OKAY". |
Spencer Low | f18fc08 | 2015-08-11 17:05:02 -0700 | [diff] [blame] | 158 | if (!android::base::WriteStringToFd("OK\n", ack_reply_fd)) { |
| 159 | fatal_errno("error writing ACK to fd %d", ack_reply_fd); |
| 160 | } |
Spencer Low | 5c398d2 | 2015-08-08 15:07:07 -0700 | [diff] [blame] | 161 | unix_close(ack_reply_fd); |
Siva Velusamy | 9f2d1a9 | 2015-08-07 10:10:29 -0700 | [diff] [blame] | 162 | #endif |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Yabin Cui | 7a3f8d6 | 2015-09-02 17:44:28 -0700 | [diff] [blame] | 165 | D("Event loop starting"); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 166 | fdevent_loop(); |
| 167 | |
| 168 | return 0; |
| 169 | } |
| 170 | |
| 171 | int main(int argc, char** argv) { |
| 172 | adb_sysdeps_init(); |
Dan Albert | 9313c0d | 2015-05-21 13:58:50 -0700 | [diff] [blame] | 173 | adb_trace_init(argv); |
Dan Albert | c89e0cc | 2015-05-08 16:13:53 -0700 | [diff] [blame] | 174 | return adb_commandline(argc - 1, const_cast<const char**>(argv + 1)); |
| 175 | } |