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
  22 #include "InterfaceController.h"
  23 #include "RouteController.h"
  24
  25 const char ipv6_proc_path[] = "/proc/sys/net/ipv6/conf";
  26
  27 const char sys_net_path[] = "/sys/class/net";
  28
  29 InterfaceController::InterfaceController() {
  30         // Initial IPv6 settings.
  31         // By default, accept_ra is set to 1 (accept RAs unless forwarding is on) on all interfaces.
  32         // This causes RAs to work or not work based on whether forwarding is on, and causes routes
  33         // learned from RAs to go away when forwarding is turned on. Make this behaviour predictable
  34         // by always setting accept_ra to 2.
  35         setAcceptRA("2");
  36
  37         setAcceptRARouteTable(-RouteController::ROUTE_TABLE_OFFSET_FROM_INDEX);
  38 }
  39
  40 InterfaceController::~InterfaceController() {
  41 }
  42
  43 int InterfaceController::writeIPv6ProcPath(const char *interface, const char *setting, const char *value) {
  44         char *path;
  45         if (!isIfaceName(interface)) {
  46                 errno = ENOENT;
  47                 return -1;
  48         }
  49         asprintf(&path, "%s/%s/%s", ipv6_proc_path, interface, setting);
  50         int success = writeFile(path, value, strlen(value));
  51         free(path);
  52         return success;
  53 }
  54
  55 int InterfaceController::setEnableIPv6(const char *interface, const int on) {
  56         // When disable_ipv6 changes from 1 to 0, the kernel starts autoconf.
  57         // When disable_ipv6 changes from 0 to 1, the kernel clears all autoconf
  58         // addresses and routes and disables IPv6 on the interface.
  59         const char *disable_ipv6 = on ? "0" : "1";
  60         return writeIPv6ProcPath(interface, "disable_ipv6", disable_ipv6);
  61 }
  62
  63 int InterfaceController::setIPv6PrivacyExtensions(const char *interface, const int on) {
  64         // 0: disable IPv6 privacy addresses
  65         // 0: enable IPv6 privacy addresses and prefer them over non-privacy ones.
  66         return writeIPv6ProcPath(interface, "use_tempaddr", on ? "2" : "0");
  67 }
  68
  69 int InterfaceController::isInterfaceName(const char *name) {
  70         return strcmp(name, ".") &&
  71                 strcmp(name, "..") &&
  72                 strcmp(name, "default") &&
  73                 strcmp(name, "all");
  74 }
  75
  76 void InterfaceController::setOnAllInterfaces(const char* filename, const char* value) {
  77         // Set the default value, which is used by any interfaces that are created in the future.
  78         writeIPv6ProcPath("default", filename, value);
  79
  80         // Set the value on all the interfaces that currently exist.
  81         DIR* dir = opendir(ipv6_proc_path);
  82         if (!dir) {
  83                 ALOGE("Can't list %s: %s", ipv6_proc_path, strerror(errno));
  84                 return;
  85         }
  86         dirent* d;
  87         while ((d = readdir(dir))) {
  88                 if (d->d_type == DT_DIR && isInterfaceName(d->d_name)) {
  89                         writeIPv6ProcPath(d->d_name, filename, value);
  90                 }
  91         }
  92         closedir(dir);
  93 }
  94
  95 void InterfaceController::setAcceptRA(const char *value) {
  96         setOnAllInterfaces("accept_ra", value);
  97 }
  98
  99 // |tableOrOffset| is interpreted as:
 100 //     If == 0: default. Routes go into RT6_TABLE_MAIN.
 101 //     If > 0: user set. Routes go into the specified table.
 102 //     If < 0: automatic. The absolute value is intepreted as an offset and added to the interface
 103 //             ID to get the table. If it's set to -1000, routes from interface ID 5 will go into
 104 //             table 1005, etc.
 105 void InterfaceController::setAcceptRARouteTable(int tableOrOffset) {
 106         char* value;
 107         asprintf(&value, "%d", tableOrOffset);
 108         setOnAllInterfaces("accept_ra_rt_table", value);
 109         free(value);
 110 }
 111
 112 int InterfaceController::setMtu(const char *interface, const char *mtu)
 113 {
 114         char *path;
 115         if (!isIfaceName(interface)) {
 116                 errno = ENOENT;
 117                 return -1;
 118         }
 119         asprintf(&path, "%s/%s/mtu", sys_net_path, interface);
 120         int success = writeFile(path, mtu, strlen(mtu));
 121         free(path);
 122         return success;
 123 }