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