main.cpp revision 7d586073609723cb2f6ed37de0ad1a7996e621ae 
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 <errno.h>
22#include <signal.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <getopt.h>
26#include <sys/prctl.h>
27
28#include "base/logging.h"
29#include "base/stringprintf.h"
30#include "cutils/properties.h"
31#include "private/android_filesystem_config.h"
32#include "selinux/selinux.h"
33
34#include "adb.h"
35#include "adb_auth.h"
36#include "adb_listeners.h"
37#include "adb_utils.h"
38#include "transport.h"
39
40static const char* root_seclabel = nullptr;
41
42static void drop_capabilities_bounding_set_if_needed() {
43#ifdef ALLOW_ADBD_ROOT
44    char value[PROPERTY_VALUE_MAX];
45    property_get("ro.debuggable", value, "");
46    if (strcmp(value, "1") == 0) {
47        return;
48    }
49#endif
50    for (int i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) {
51        if (i == CAP_SETUID || i == CAP_SETGID) {
52            // CAP_SETUID CAP_SETGID needed by /system/bin/run-as
53            continue;
54        }
55
56        int err = prctl(PR_CAPBSET_DROP, i, 0, 0, 0);
57
58        // Some kernels don't have file capabilities compiled in, and
59        // prctl(PR_CAPBSET_DROP) returns EINVAL. Don't automatically
60        // die when we see such misconfigured kernels.
61        if ((err < 0) && (errno != EINVAL)) {
62            PLOG(FATAL) << "Could not drop capabilities";
63        }
64    }
65}
66
67static bool should_drop_privileges() {
68#if defined(ALLOW_ADBD_ROOT)
69    char value[PROPERTY_VALUE_MAX];
70
71    // The properties that affect `adb root` and `adb unroot` are ro.secure and
72    // ro.debuggable. In this context the names don't make the expected behavior
73    // particularly obvious.
74    //
75    // ro.debuggable:
76    //   Allowed to become root, but not necessarily the default. Set to 1 on
77    //   eng and userdebug builds.
78    //
79    // ro.secure:
80    //   Drop privileges by default. Set to 1 on userdebug and user builds.
81    property_get("ro.secure", value, "1");
82    bool ro_secure = (strcmp(value, "1") == 0);
83
84    property_get("ro.debuggable", value, "");
85    bool ro_debuggable = (strcmp(value, "1") == 0);
86
87    // Drop privileges if ro.secure is set...
88    bool drop = ro_secure;
89
90    property_get("service.adb.root", value, "");
91    bool adb_root = (strcmp(value, "1") == 0);
92    bool adb_unroot = (strcmp(value, "0") == 0);
93
94    // ...except "adb root" lets you keep privileges in a debuggable build.
95    if (ro_debuggable && adb_root) {
96        drop = false;
97    }
98
99    // ...and "adb unroot" lets you explicitly drop privileges.
100    if (adb_unroot) {
101        drop = true;
102    }
103
104    return drop;
105#else
106    return true; // "adb root" not allowed, always drop privileges.
107#endif // ALLOW_ADBD_ROOT
108}
109
110int adbd_main(int server_port) {
111    umask(0);
112
113    signal(SIGPIPE, SIG_IGN);
114
115    init_transport_registration();
116
117    // We need to call this even if auth isn't enabled because the file
118    // descriptor will always be open.
119    adbd_cloexec_auth_socket();
120
121    if (ALLOW_ADBD_NO_AUTH && property_get_bool("ro.adb.secure", 0) == 0) {
122        auth_required = false;
123    }
124
125    adbd_auth_init();
126
127    // Our external storage path may be different than apps, since
128    // we aren't able to bind mount after dropping root.
129    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
130    if (adb_external_storage != nullptr) {
131        setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
132    } else {
133        D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"
134          " unchanged.\n");
135    }
136
137    // Add extra groups:
138    // AID_ADB to access the USB driver
139    // AID_LOG to read system logs (adb logcat)
140    // AID_INPUT to diagnose input issues (getevent)
141    // AID_INET to diagnose network issues (ping)
142    // AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
143    // AID_SDCARD_R to allow reading from the SD card
144    // AID_SDCARD_RW to allow writing to the SD card
145    // AID_NET_BW_STATS to read out qtaguid statistics
146    // AID_READPROC for reading /proc entries across UID boundaries
147    gid_t groups[] = {AID_ADB,      AID_LOG,       AID_INPUT,
148                      AID_INET,     AID_NET_BT,    AID_NET_BT_ADMIN,
149                      AID_SDCARD_R, AID_SDCARD_RW, AID_NET_BW_STATS,
150                      AID_READPROC };
151    if (setgroups(sizeof(groups) / sizeof(groups[0]), groups) != 0) {
152        PLOG(FATAL) << "Could not set supplemental groups";
153    }
154
155    /* don't listen on a port (default 5037) if running in secure mode */
156    /* don't run as root if we are running in secure mode */
157    if (should_drop_privileges()) {
158        drop_capabilities_bounding_set_if_needed();
159
160        /* then switch user and group to "shell" */
161        if (setgid(AID_SHELL) != 0) {
162            PLOG(FATAL) << "Could not setgid";
163        }
164        if (setuid(AID_SHELL) != 0) {
165            PLOG(FATAL) << "Could not setuid";
166        }
167
168        D("Local port disabled");
169    } else {
170        if (root_seclabel != nullptr) {
171            if (setcon(root_seclabel) < 0) {
172                LOG(FATAL) << "Could not set SELinux context";
173            }
174        }
175        std::string error;
176        std::string local_name =
177            android::base::StringPrintf("tcp:%d", server_port);
178        if (install_listener(local_name, "*smartsocket*", nullptr, 0,
179                             &error)) {
180            LOG(FATAL) << "Could not install *smartsocket* listener: "
181                << error;
182        }
183    }
184
185    bool is_usb = false;
186    if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
187        // Listen on USB.
188        usb_init();
189        is_usb = true;
190    }
191
192    // If one of these properties is set, also listen on that port.
193    // If one of the properties isn't set and we couldn't listen on usb, listen
194    // on the default port.
195    char prop_port[PROPERTY_VALUE_MAX];
196    property_get("service.adb.tcp.port", prop_port, "");
197    if (prop_port[0] == '\0') {
198        property_get("persist.adb.tcp.port", prop_port, "");
199    }
200
201    int port;
202    if (sscanf(prop_port, "%d", &port) == 1 && port > 0) {
203        D("using port=%d", port);
204        // Listen on TCP port specified by service.adb.tcp.port property.
205        local_init(port);
206    } else if (!is_usb) {
207        // Listen on default port.
208        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
209    }
210
211    D("adbd_main(): pre init_jdwp()");
212    init_jdwp();
213    D("adbd_main(): post init_jdwp()");
214
215    D("Event loop starting");
216    fdevent_loop();
217
218    return 0;
219}
220
221int main(int argc, char** argv) {
222    while (true) {
223        static struct option opts[] = {
224            {"root_seclabel", required_argument, nullptr, 's'},
225            {"device_banner", required_argument, nullptr, 'b'},
226            {"version", no_argument, nullptr, 'v'},
227        };
228
229        int option_index = 0;
230        int c = getopt_long(argc, argv, "", opts, &option_index);
231        if (c == -1) {
232            break;
233        }
234
235        switch (c) {
236        case 's':
237            root_seclabel = optarg;
238            break;
239        case 'b':
240            adb_device_banner = optarg;
241            break;
242        case 'v':
243            printf("Android Debug Bridge Daemon version %d.%d.%d %s\n",
244                   ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
245                   ADB_REVISION);
246            return 0;
247        default:
248            // getopt already prints "adbd: invalid option -- %c" for us.
249            return 1;
250        }
251    }
252
253    close_stdin();
254
255    adb_trace_init(argv);
256
257    D("Handling main()");
258    return adbd_main(DEFAULT_ADB_PORT);
259}
260