server/InterfaceController.cpp

   1 /*
   2  * Copyright (C) 2012 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 #include <dirent.h>
  18 #include <errno.h>
  19 #include <malloc.h>
  20
  21 #define LOG_TAG "InterfaceController"
  22 #include <android-base/file.h>
  23 #include <android-base/stringprintf.h>
  24 #include <cutils/log.h>
  25 #include <logwrap/logwrap.h>
  26
  27 #include "InterfaceController.h"
  28 #include "RouteController.h"
  29
  30 using android::base::StringPrintf;
  31 using android::base::WriteStringToFile;
  32
  33 namespace {
  34
  35 const char ipv6_proc_path[] = "/proc/sys/net/ipv6/conf";
  36
  37 const char ipv4_neigh_conf_dir[] = "/proc/sys/net/ipv4/neigh";
  38
  39 const char ipv6_neigh_conf_dir[] = "/proc/sys/net/ipv6/neigh";
  40
  41 const char sys_net_path[] = "/sys/class/net";
  42
  43 const char wl_util_path[] = "/vendor/xbin/wlutil";
  44
  45 bool isInterfaceName(const char *name) {
  46     return strcmp(name, ".") &&
  47             strcmp(name, "..") &&
  48             strcmp(name, "default") &&
  49             strcmp(name, "all");
  50 }
  51
  52 int writeValueToPath(
  53         const char* dirname, const char* subdirname, const char* basename,
  54         const char* value) {
  55     std::string path(StringPrintf("%s/%s/%s", dirname, subdirname, basename));
  56     return WriteStringToFile(value, path) ? 0 : -1;
  57 }
  58
  59 void setOnAllInterfaces(const char* dirname, const char* basename, const char* value) {
  60     // Set the default value, which is used by any interfaces that are created in the future.
  61     writeValueToPath(dirname, "default", basename, value);
  62
  63     // Set the value on all the interfaces that currently exist.
  64     DIR* dir = opendir(dirname);
  65     if (!dir) {
  66         ALOGE("Can't list %s: %s", dirname, strerror(errno));
  67         return;
  68     }
  69     dirent* d;
  70     while ((d = readdir(dir))) {
  71         if ((d->d_type != DT_DIR) || !isInterfaceName(d->d_name)) {
  72             continue;
  73         }
  74         writeValueToPath(dirname, d->d_name, basename, value);
  75     }
  76     closedir(dir);
  77 }
  78
  79 void setIPv6UseOutgoingInterfaceAddrsOnly(const char *value) {
  80     setOnAllInterfaces(ipv6_proc_path, "use_oif_addrs_only", value);
  81 }
  82
  83 }  // namespace
  84
  85 InterfaceController::InterfaceController() {
  86         // Initial IPv6 settings.
  87         // By default, accept_ra is set to 1 (accept RAs unless forwarding is on) on all interfaces.
  88         // This causes RAs to work or not work based on whether forwarding is on, and causes routes
  89         // learned from RAs to go away when forwarding is turned on. Make this behaviour predictable
  90         // by always setting accept_ra to 2.
  91         setAcceptRA("2");
  92
  93         setAcceptRARouteTable(-RouteController::ROUTE_TABLE_OFFSET_FROM_INDEX);
  94
  95         // Enable optimistic DAD for IPv6 addresses on all interfaces.
  96         setIPv6OptimisticMode("1");
  97
  98         // Reduce the ARP/ND base reachable time from the default (30sec) to 15sec.
  99         setBaseReachableTimeMs(15 * 1000);
 100
 101         // When sending traffic via a given interface use only addresses configured
 102         // on that interface as possible source addresses.
 103         setIPv6UseOutgoingInterfaceAddrsOnly("1");
 104 }
 105
 106 InterfaceController::~InterfaceController() {
 107 }
 108
 109 int InterfaceController::setEnableIPv6(const char *interface, const int on) {
 110     if (!isIfaceName(interface)) {
 111         errno = ENOENT;
 112         return -1;
 113     }
 114     // When disable_ipv6 changes from 1 to 0, the kernel starts autoconf.
 115     // When disable_ipv6 changes from 0 to 1, the kernel clears all autoconf
 116     // addresses and routes and disables IPv6 on the interface.
 117     const char *disable_ipv6 = on ? "0" : "1";
 118     return writeValueToPath(ipv6_proc_path, interface, "disable_ipv6", disable_ipv6);
 119 }
 120
 121 int InterfaceController::setIPv6PrivacyExtensions(const char *interface, const int on) {
 122     if (!isIfaceName(interface)) {
 123         errno = ENOENT;
 124         return -1;
 125     }
 126     // 0: disable IPv6 privacy addresses
 127     // 0: enable IPv6 privacy addresses and prefer them over non-privacy ones.
 128     return writeValueToPath(ipv6_proc_path, interface, "use_tempaddr", on ? "2" : "0");
 129 }
 130
 131 // Enables or disables IPv6 ND offload. This is useful for 464xlat on wifi, IPv6 tethering, and
 132 // generally implementing IPv6 neighbour discovery and duplicate address detection properly.
 133 // TODO: This should be implemented in wpa_supplicant via driver commands instead.
 134 int InterfaceController::setIPv6NdOffload(char* interface, const int on) {
 135     // Only supported on Broadcom chipsets via wlutil for now.
 136     if (access(wl_util_path, X_OK) == 0) {
 137         const char *argv[] = {
 138             wl_util_path,
 139             "-a",
 140             interface,
 141             "ndoe",
 142             on ? "1" : "0"
 143         };
 144         int ret = android_fork_execvp(ARRAY_SIZE(argv), const_cast<char**>(argv), NULL,
 145                                       false, false);
 146         ALOGD("%s ND offload on %s: %d (%s)",
 147               (on ? "enabling" : "disabling"), interface, ret, strerror(errno));
 148         return ret;
 149     } else {
 150         return 0;
 151     }
 152 }
 153
 154 void InterfaceController::setAcceptRA(const char *value) {
 155     setOnAllInterfaces(ipv6_proc_path, "accept_ra", value);
 156 }
 157
 158 // |tableOrOffset| is interpreted as:
 159 //     If == 0: default. Routes go into RT6_TABLE_MAIN.
 160 //     If > 0: user set. Routes go into the specified table.
 161 //     If < 0: automatic. The absolute value is intepreted as an offset and added to the interface
 162 //             ID to get the table. If it's set to -1000, routes from interface ID 5 will go into
 163 //             table 1005, etc.
 164 void InterfaceController::setAcceptRARouteTable(int tableOrOffset) {
 165     std::string value(StringPrintf("%d", tableOrOffset));
 166     setOnAllInterfaces(ipv6_proc_path, "accept_ra_rt_table", value.c_str());
 167 }
 168
 169 int InterfaceController::setMtu(const char *interface, const char *mtu)
 170 {
 171     if (!isIfaceName(interface)) {
 172         errno = ENOENT;
 173         return -1;
 174     }
 175     return writeValueToPath(sys_net_path, interface, "mtu", mtu);
 176 }
 177
 178 void InterfaceController::setBaseReachableTimeMs(unsigned int millis) {
 179     std::string value(StringPrintf("%u", millis));
 180     setOnAllInterfaces(ipv4_neigh_conf_dir, "base_reachable_time_ms", value.c_str());
 181     setOnAllInterfaces(ipv6_neigh_conf_dir, "base_reachable_time_ms", value.c_str());
 182 }
 183
 184 void InterfaceController::setIPv6OptimisticMode(const char *value) {
 185     setOnAllInterfaces(ipv6_proc_path, "optimistic_dad", value);
 186     setOnAllInterfaces(ipv6_proc_path, "use_optimistic", value);
 187 }