Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c89e0ccd authored by Dan Albert's avatar Dan Albert
Browse files

Revert "Revert "Split adb_main.cpp into client and daemon."" 

This reverts commit 218dbcce.

Change-Id: I74088db34983dc99e316a07c6ddc294340e0eb71
parent 8398386a

adb/Android.mk

+2 −2
Original line number Diff line number Diff line
@@ -175,7 +175,7 @@ endif 
LOCAL_CLANG := $(adb_host_clang)



LOCAL_SRC_FILES := \

    adb_main.cpp \

    client/main.cpp \

    console.cpp \

    commandline.cpp \

    adb_client.cpp \
@@ -227,7 +227,7 @@ include $(CLEAR_VARS) 
LOCAL_CLANG := true



LOCAL_SRC_FILES := \

    adb_main.cpp \

    daemon/main.cpp \

    services.cpp \

    file_sync_service.cpp \

    framebuffer_service.cpp \

adb/adb.cpp

+4 −5
Original line number Diff line number Diff line
@@ -796,13 +796,12 @@ int handle_forward_request(const char* service, TransportType type, const char* 
    return 0;

}



int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket *s)

{

    if(!strcmp(service, "kill")) {

int handle_host_request(const char* service, TransportType type,

                        const char* serial, int reply_fd, asocket* s) {

    if (strcmp(service, "kill") == 0) {

        fprintf(stderr, "adb server killed by remote request\n");

        fflush(stdout);

        SendOkay(reply_fd);

        usb_cleanup();

        exit(0);

    }

adb/adb.h

+0 −1
Original line number Diff line number Diff line
@@ -324,7 +324,6 @@ int local_connect_arbitrary_ports(int console_port, int adb_port); 


/* usb host/client interface */

void usb_init();

void usb_cleanup();

int usb_write(usb_handle *h, const void *data, int len);

int usb_read(usb_handle *h, void *data, int len);

int usb_close(usb_handle *h);

adb/client/main.cpp

0 → 100644
+180 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define TRACE_TAG TRACE_ADB



#include "sysdeps.h"



#include <signal.h>

#include <stdio.h>

#include <stdlib.h>



// We only build the affinity WAR code for Linux.

#if defined(__linux__)

#include <sched.h>

#endif



#include "base/file.h"

#include "base/logging.h"

#include "base/stringprintf.h"



#include "adb.h"

#include "adb_auth.h"

#include "adb_listeners.h"

#include "transport.h"



#if defined(WORKAROUND_BUG6558362) && defined(__linux__)

static const bool kWorkaroundBug6558362 = true;

#else

static const bool kWorkaroundBug6558362 = false;

#endif



static void adb_workaround_affinity(void) {

#if defined(__linux__)

    const char affinity_env[] = "ADB_CPU_AFFINITY_BUG6558362";

    const char* cpunum_str = getenv(affinity_env);

    if (cpunum_str == nullptr || *cpunum_str == '\0') {

        return;

    }



    char* strtol_res;

    int cpu_num = strtol(cpunum_str, &strtol_res, 0);

    if (*strtol_res != '\0') {

        fatal("bad number (%s) in env var %s. Expecting 0..n.\n", cpunum_str,

              affinity_env);

    }



    cpu_set_t cpu_set;

    sched_getaffinity(0, sizeof(cpu_set), &cpu_set);

    D("orig cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]);



    CPU_ZERO(&cpu_set);

    CPU_SET(cpu_num, &cpu_set);

    sched_setaffinity(0, sizeof(cpu_set), &cpu_set);



    sched_getaffinity(0, sizeof(cpu_set), &cpu_set);

    D("new cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]);

#else

    // No workaround was ever implemented for the other platforms.

#endif

}



#if defined(_WIN32)

static const char kNullFileName[] = "NUL";



static BOOL WINAPI ctrlc_handler(DWORD type) {

    exit(STATUS_CONTROL_C_EXIT);

    return TRUE;

}



static std::string GetLogFilePath() {

    const char log_name[] = "adb.log";

    char temp_path[MAX_PATH - sizeof(log_name) + 1];



    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364992%28v=vs.85%29.aspx

    DWORD nchars = GetTempPath(sizeof(temp_path), temp_path);

    CHECK_LE(nchars, sizeof(temp_path));

    if (nchars == 0) {

        // TODO(danalbert): Log the error message from FormatError().

        // Windows unfortunately has two errnos, errno and GetLastError(), so

        // I'm not sure what to do about PLOG here. Probably better to just

        // ignore it and add a simplified version of FormatError() for use in

        // log messages.

        LOG(ERROR) << "Error creating log file";

    }



    return std::string(temp_path) + log_name;

}

#else

static const char kNullFileName[] = "/dev/null";



static std::string GetLogFilePath() {

    return std::string("/tmp/adb.log");

}

#endif



static void close_stdin() {

    int fd = unix_open(kNullFileName, O_RDONLY);

    CHECK_NE(fd, -1);

    dup2(fd, STDIN_FILENO);

    adb_close(fd);

}



static void setup_daemon_logging(void) {

    int fd = unix_open(GetLogFilePath().c_str(), O_WRONLY | O_CREAT | O_APPEND,

                       0640);

    if (fd == -1) {

        fd = unix_open(kNullFileName, O_WRONLY);

    }

    dup2(fd, STDOUT_FILENO);

    dup2(fd, STDERR_FILENO);

    adb_close(fd);

    fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid());

}



int adb_main(int is_daemon, int server_port) {

    HOST = 1;



#if defined(_WIN32)

    SetConsoleCtrlHandler(ctrlc_handler, TRUE);

#else

    signal(SIGPIPE, SIG_IGN);

#endif



    init_transport_registration();



    if (kWorkaroundBug6558362 && is_daemon) {

        adb_workaround_affinity();

    }



    usb_init();

    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);

    adb_auth_init();



    std::string local_name = android::base::StringPrintf("tcp:%d", server_port);

    if (install_listener(local_name, "*smartsocket*", nullptr, 0)) {

        LOG(FATAL) << "Could not install *smartsocket* listener";

    }



    if (is_daemon) {

        // Inform our parent that we are up and running.

        // TODO(danalbert): Can't use SendOkay because we're sending "OK\n", not

        // "OKAY".

        // TODO(danalbert): Why do we use stdout for Windows?

#if defined(_WIN32)

        int reply_fd = STDOUT_FILENO;

#else

        int reply_fd = STDERR_FILENO;

#endif

        android::base::WriteStringToFd("OK\n", reply_fd);

        close_stdin();

        setup_daemon_logging();

    }



    D("Event loop starting\n");

    fdevent_loop();



    return 0;

}



int main(int argc, char** argv) {

    adb_sysdeps_init();



    android::base::InitLogging(argv);

    adb_trace_init();

    D("Handling commandline()\n");

    return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));

}

adb/adb_main.cpp→adb/daemon/main.cpp

+69 −203
Original line number Diff line number Diff line
@@ -22,66 +22,22 @@ 
#include <signal.h>

#include <stdio.h>

#include <stdlib.h>



#include "adb.h"

#include "adb_auth.h"

#include "adb_listeners.h"

#include "transport.h"



#include <base/stringprintf.h>



#if !ADB_HOST

#include <getopt.h>

#include <sys/prctl.h>



#include "base/logging.h"

#include "base/stringprintf.h"

#include "cutils/properties.h"

#include "private/android_filesystem_config.h"

#include "selinux/selinux.h"



#include "adb.h"

#include "adb_auth.h"

#include "adb_listeners.h"

#include "transport.h"

#include "qemu_tracing.h"

#endif



static void adb_cleanup(void)

{

    usb_cleanup();

}



#if defined(_WIN32)

static BOOL WINAPI ctrlc_handler(DWORD type)

{

    exit(STATUS_CONTROL_C_EXIT);

    return TRUE;

}

#endif



#if ADB_HOST

#ifdef WORKAROUND_BUG6558362

#include <sched.h>

#define AFFINITY_ENVVAR "ADB_CPU_AFFINITY_BUG6558362"

void adb_set_affinity(void)

{

   cpu_set_t cpu_set;

   const char* cpunum_str = getenv(AFFINITY_ENVVAR);

   char* strtol_res;

   int cpu_num;



   if (!cpunum_str || !*cpunum_str)

       return;

   cpu_num = strtol(cpunum_str, &strtol_res, 0);

   if (*strtol_res != '\0')

     fatal("bad number (%s) in env var %s. Expecting 0..n.\n", cpunum_str, AFFINITY_ENVVAR);



   sched_getaffinity(0, sizeof(cpu_set), &cpu_set);

   D("orig cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]);

   CPU_ZERO(&cpu_set);

   CPU_SET(cpu_num, &cpu_set);

   sched_setaffinity(0, sizeof(cpu_set), &cpu_set);

   sched_getaffinity(0, sizeof(cpu_set), &cpu_set);

   D("new cpu_set[0]=0x%08lx\n", cpu_set.__bits[0]);

}

#endif

#else /* ADB_HOST */

static const char *root_seclabel = NULL;

static const char* root_seclabel = nullptr;



static void drop_capabilities_bounding_set_if_needed() {

#ifdef ALLOW_ADBD_ROOT
@@ -91,19 +47,19 @@ static void drop_capabilities_bounding_set_if_needed() { 
        return;

    }

#endif

    int i;

    for (i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) {

    for (int i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) {

        if (i == CAP_SETUID || i == CAP_SETGID) {

            // CAP_SETUID CAP_SETGID needed by /system/bin/run-as

            continue;

        }



        int err = prctl(PR_CAPBSET_DROP, i, 0, 0, 0);



        // Some kernels don't have file capabilities compiled in, and

        // prctl(PR_CAPBSET_DROP) returns EINVAL. Don't automatically

        // die when we see such misconfigured kernels.

        if ((err < 0) && (errno != EINVAL)) {

            exit(1);

            PLOG(FATAL) << "Could not drop capabilities";

        }

    }

}
@@ -155,120 +111,49 @@ static bool should_drop_privileges() { 
    return drop;

#else

    return true; // "adb root" not allowed, always drop privileges.

#endif /* ALLOW_ADBD_ROOT */

}

#endif /* ADB_HOST */



void start_logging(void)

{

#if defined(_WIN32)

    char    temp[ MAX_PATH ];

    FILE*   fnul;

    FILE*   flog;



    GetTempPath( sizeof(temp) - 8, temp );

    strcat( temp, "adb.log" );



    /* Win32 specific redirections */

    fnul = fopen( "NUL", "rt" );

    if (fnul != NULL)

        stdin[0] = fnul[0];



    flog = fopen( temp, "at" );

    if (flog == NULL)

        flog = fnul;



    setvbuf( flog, NULL, _IONBF, 0 );



    stdout[0] = flog[0];

    stderr[0] = flog[0];

    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());

#else

    int fd;



    fd = unix_open("/dev/null", O_RDONLY);

    dup2(fd, 0);

    adb_close(fd);



    fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);

    if(fd < 0) {

        fd = unix_open("/dev/null", O_WRONLY);

    }

    dup2(fd, 1);

    dup2(fd, 2);

    adb_close(fd);

    fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());

#endif

#endif // ALLOW_ADBD_ROOT

}



int adb_main(int is_daemon, int server_port)

{

#if !ADB_HOST

    int port;

    char value[PROPERTY_VALUE_MAX];

int adbd_main(int server_port) {

    umask(0);



    umask(000);

#endif



    atexit(adb_cleanup);

#if defined(_WIN32)

    SetConsoleCtrlHandler( ctrlc_handler, TRUE );

#else

    // No SIGCHLD. Let the service subproc handle its children.

    signal(SIGPIPE, SIG_IGN);

#endif



    init_transport_registration();



#if ADB_HOST

    HOST = 1;



#ifdef WORKAROUND_BUG6558362

    if(is_daemon) adb_set_affinity();

#endif

    usb_init();

    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);

    adb_auth_init();



    std::string local_name = android::base::StringPrintf("tcp:%d", server_port);

    if (install_listener(local_name, "*smartsocket*", NULL, 0)) {

        exit(1);

    }

#else

    // We need to call this even if auth isn't enabled because the file

    // descriptor will always be open.

    adbd_cloexec_auth_socket();



    property_get("ro.adb.secure", value, "0");

    auth_enabled = !strcmp(value, "1");

    if (auth_enabled)

    auth_enabled = property_get_bool("ro.adb.secure", 0) != 0;

    if (auth_enabled) {

        adbd_auth_init();

    }



    // Our external storage path may be different than apps, since

    // we aren't able to bind mount after dropping root.

    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");

    if (NULL != adb_external_storage) {

    if (adb_external_storage != nullptr) {

        setenv("EXTERNAL_STORAGE", adb_external_storage, 1);

    } else {

        D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"

          " unchanged.\n");

    }



    /* add extra groups:

    ** AID_ADB to access the USB driver

    ** AID_LOG to read system logs (adb logcat)

    ** AID_INPUT to diagnose input issues (getevent)

    ** AID_INET to diagnose network issues (ping)

    ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)

    ** AID_SDCARD_R to allow reading from the SD card

    ** AID_SDCARD_RW to allow writing to the SD card

    ** AID_NET_BW_STATS to read out qtaguid statistics

    */

    gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_NET_BT,

                       AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,

                       AID_NET_BW_STATS };

    // Add extra groups:

    // AID_ADB to access the USB driver

    // AID_LOG to read system logs (adb logcat)

    // AID_INPUT to diagnose input issues (getevent)

    // AID_INET to diagnose network issues (ping)

    // AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)

    // AID_SDCARD_R to allow reading from the SD card

    // AID_SDCARD_RW to allow writing to the SD card

    // AID_NET_BW_STATS to read out qtaguid statistics

    gid_t groups[] = {AID_ADB,      AID_LOG,       AID_INPUT,

                      AID_INET,     AID_NET_BT,    AID_NET_BT_ADMIN,

                      AID_SDCARD_R, AID_SDCARD_RW, AID_NET_BW_STATS};

    if (setgroups(sizeof(groups) / sizeof(groups[0]), groups) != 0) {

        exit(1);

        PLOG(FATAL) << "Could not set supplental groups";

    }



    /* don't listen on a port (default 5037) if running in secure mode */
@@ -278,96 +163,75 @@ int adb_main(int is_daemon, int server_port) 


        /* then switch user and group to "shell" */

        if (setgid(AID_SHELL) != 0) {

            exit(1);

            PLOG(FATAL) << "Could not setgid";

        }

        if (setuid(AID_SHELL) != 0) {

            exit(1);

            PLOG(FATAL) << "Could not setuid";

        }



        D("Local port disabled\n");

    } else {

        if ((root_seclabel != NULL) && (is_selinux_enabled() > 0)) {

            // b/12587913: fix setcon to allow const pointers

            if (setcon((char *)root_seclabel) < 0) {

                exit(1);

        if ((root_seclabel != nullptr) && (is_selinux_enabled() > 0)) {

            if (setcon(root_seclabel) < 0) {

                LOG(FATAL) << "Could not set selinux context";

            }

        }

        std::string local_name = android::base::StringPrintf("tcp:%d", server_port);

        if (install_listener(local_name, "*smartsocket*", NULL, 0)) {

            exit(1);

        std::string local_name =

            android::base::StringPrintf("tcp:%d", server_port);

        if (install_listener(local_name, "*smartsocket*", nullptr, 0)) {

            LOG(FATAL) << "Could not install *smartsocket* listener";

        }

    }



    int usb = 0;

    bool is_usb = false;

    if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {

        // listen on USB

        // Listen on USB.

        usb_init();

        usb = 1;

        is_usb = true;

    }



    // If one of these properties is set, also listen on that port

    // If one of the properties isn't set and we couldn't listen on usb,

    // listen on the default port.

    property_get("service.adb.tcp.port", value, "");

    if (!value[0]) {

        property_get("persist.adb.tcp.port", value, "");

    // If one of these properties is set, also listen on that port.

    // If one of the properties isn't set and we couldn't listen on usb, listen

    // on the default port.

    char prop_port[PROPERTY_VALUE_MAX];

    property_get("service.adb.tcp.port", prop_port, "");

    if (prop_port[0] == '\0') {

        property_get("persist.adb.tcp.port", prop_port, "");

    }

    if (sscanf(value, "%d", &port) == 1 && port > 0) {



    int port;

    if (sscanf(prop_port, "%d", &port) == 1 && port > 0) {

        printf("using port=%d\n", port);

        // listen on TCP port specified by service.adb.tcp.port property

        // Listen on TCP port specified by service.adb.tcp.port property.

        local_init(port);

    } else if (!usb) {

        // listen on default port

    } else if (!is_usb) {

        // Listen on default port.

        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);

    }



    D("adb_main(): pre init_jdwp()\n");

    D("adbd_main(): pre init_jdwp()\n");

    init_jdwp();

    D("adb_main(): post init_jdwp()\n");

#endif

    D("adbd_main(): post init_jdwp()\n");



    if (is_daemon)

    {

        // inform our parent that we are up and running.

#if defined(_WIN32)

        DWORD  count;

        WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );

#else

        fprintf(stderr, "OK\n");

#endif

        start_logging();

    }

    D("Event loop starting\n");



    fdevent_loop();



    usb_cleanup();



    return 0;

}



#if !ADB_HOST

void close_stdin() {

static void close_stdin() {

    int fd = unix_open("/dev/null", O_RDONLY);

    if (fd == -1) {

        perror("failed to open /dev/null, stdin will remain open");

        return;

    }

    dup2(fd, 0);

    dup2(fd, STDIN_FILENO);

    adb_close(fd);

}

#endif



// TODO(danalbert): Split this file up into adb_main.cpp and adbd_main.cpp.

int main(int argc, char** argv) {

#if ADB_HOST

    // adb client/server

    adb_sysdeps_init();

    adb_trace_init();

    D("Handling commandline()\n");

    return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));

#else

    // adbd

    android::base::InitLogging(argv);



    while (true) {

        static struct option opts[] = {

            {"root_seclabel", required_argument, nullptr, 's'},
@@ -377,8 +241,10 @@ int main(int argc, char **argv) { 


        int option_index = 0;

        int c = getopt_long(argc, argv, "", opts, &option_index);

        if (c == -1)

        if (c == -1) {

            break;

        }



        switch (c) {

        case 's':

            root_seclabel = optarg;
@@ -392,7 +258,8 @@ int main(int argc, char **argv) { 
                   ADB_REVISION);

            return 0;

        default:

            break;

            // getopt already prints "adbd: invalid option -- %c" for us.

            return 1;

        }

    }
@@ -405,6 +272,5 @@ int main(int argc, char **argv) { 
    adb_qemu_trace_init();



    D("Handling main()\n");

    return adb_main(0, DEFAULT_ADB_PORT);

#endif

    return adbd_main(DEFAULT_ADB_PORT);

}