Home | History | Annotate | Download | only in client 
      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 
     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)
     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 
     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 
     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 
    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