Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 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 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 17 | // THREAD-SAFETY |
| 18 | // ------------- |
| 19 | // The methods in this file are called from multiple threads (from CommandListener, FwmarkServer |
| 20 | // and DnsProxyListener). So, all accesses to shared state are guarded by a lock. |
| 21 | // |
| 22 | // In some cases, a single non-const method acquires and releases the lock several times, like so: |
| 23 | // if (isValidNetwork(...)) { // isValidNetwork() acquires and releases the lock. |
| 24 | // setDefaultNetwork(...); // setDefaultNetwork() also acquires and releases the lock. |
| 25 | // |
| 26 | // It might seem that this allows races where the state changes between the two statements, but in |
| 27 | // fact there are no races because: |
| 28 | // 1. This pattern only occurs in non-const methods (i.e., those that mutate state). |
| 29 | // 2. Only CommandListener calls these non-const methods. The others call only const methods. |
| 30 | // 3. CommandListener only processes one command at a time. I.e., it's serialized. |
| 31 | // Thus, no other mutation can occur in between the two statements above. |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 32 | |
| 33 | #include "NetworkController.h" |
| 34 | |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 35 | #include "PermissionsController.h" |
| 36 | #include "RouteController.h" |
| 37 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 38 | #define LOG_TAG "NetworkController" |
Paul Jensen | 6ff1678 | 2014-06-11 10:58:16 -0400 | [diff] [blame] | 39 | |
| 40 | #include <sys/socket.h> |
| 41 | #include <linux/if.h> |
| 42 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 43 | #include "cutils/log.h" |
| 44 | #include "resolv_netid.h" |
| 45 | |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 46 | namespace { |
| 47 | |
| 48 | // Keep these in sync with ConnectivityService.java. |
| 49 | const unsigned int MIN_NET_ID = 10; |
| 50 | const unsigned int MAX_NET_ID = 65535; |
| 51 | |
| 52 | } // namespace |
| 53 | |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 54 | NetworkController::NetworkController(PermissionsController* permissionsController, |
| 55 | RouteController* routeController) |
Sreeram Ramachandran | 574e633 | 2014-05-14 08:31:55 -0700 | [diff] [blame] | 56 | : mDefaultNetId(NETID_UNSET), |
| 57 | mPermissionsController(permissionsController), |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 58 | mRouteController(routeController) { |
| 59 | } |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 60 | |
| 61 | void NetworkController::clearNetworkPreference() { |
| 62 | android::RWLock::AutoWLock lock(mRWLock); |
| 63 | mUidMap.clear(); |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 64 | } |
| 65 | |
| 66 | unsigned NetworkController::getDefaultNetwork() const { |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 67 | android::RWLock::AutoRLock lock(mRWLock); |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 68 | return mDefaultNetId; |
| 69 | } |
| 70 | |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 71 | bool NetworkController::setDefaultNetwork(unsigned newNetId) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 72 | // newNetId must be either NETID_UNSET or a valid network. If it's NETID_UNSET, the caller is |
| 73 | // asking for there to be no default network, which is a request we support. |
| 74 | if (newNetId != NETID_UNSET && !isValidNetwork(newNetId)) { |
| 75 | ALOGE("invalid netId %u", newNetId); |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 76 | errno = EINVAL; |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 77 | return false; |
| 78 | } |
| 79 | |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 80 | unsigned oldNetId; |
| 81 | { |
| 82 | android::RWLock::AutoWLock lock(mRWLock); |
| 83 | oldNetId = mDefaultNetId; |
| 84 | mDefaultNetId = newNetId; |
| 85 | } |
| 86 | |
| 87 | if (oldNetId == newNetId) { |
| 88 | return true; |
| 89 | } |
| 90 | |
| 91 | bool status = true; |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 92 | Permission permission; |
| 93 | InterfaceRange range; |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 94 | |
| 95 | // Add default network rules for the new netId. |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 96 | permission = mPermissionsController->getPermissionForNetwork(newNetId); |
| 97 | range = mNetIdToInterfaces.equal_range(newNetId); |
| 98 | for (InterfaceIteratorConst iter = range.first; iter != range.second; ++iter) { |
| 99 | if (!mRouteController->addToDefaultNetwork(iter->second.c_str(), permission)) { |
| 100 | ALOGE("failed to add interface %s to default netId %u", iter->second.c_str(), newNetId); |
| 101 | status = false; |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 102 | } |
| 103 | } |
| 104 | |
| 105 | // Remove the old default network rules. |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 106 | permission = mPermissionsController->getPermissionForNetwork(oldNetId); |
| 107 | range = mNetIdToInterfaces.equal_range(oldNetId); |
| 108 | for (InterfaceIteratorConst iter = range.first; iter != range.second; ++iter) { |
| 109 | if (!mRouteController->removeFromDefaultNetwork(iter->second.c_str(), permission)) { |
| 110 | ALOGE("failed to remove interface %s from default netId %u", iter->second.c_str(), |
| 111 | oldNetId); |
| 112 | status = false; |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 113 | } |
| 114 | } |
| 115 | |
| 116 | return status; |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 117 | } |
| 118 | |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 119 | bool NetworkController::setNetworkForUidRange(int uid_start, int uid_end, unsigned netId, |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 120 | bool forward_dns) { |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 121 | if (uid_start > uid_end || !isValidNetwork(netId)) { |
| 122 | errno = EINVAL; |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 123 | return false; |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 124 | } |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 125 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 126 | android::RWLock::AutoWLock lock(mRWLock); |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 127 | for (std::list<UidEntry>::iterator it = mUidMap.begin(); it != mUidMap.end(); ++it) { |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 128 | if (it->uid_start != uid_start || it->uid_end != uid_end || it->netId != netId) |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 129 | continue; |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 130 | it->forward_dns = forward_dns; |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 131 | return true; |
| 132 | } |
| 133 | |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 134 | mUidMap.push_front(UidEntry(uid_start, uid_end, netId, forward_dns)); |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 135 | return true; |
| 136 | } |
| 137 | |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 138 | bool NetworkController::clearNetworkForUidRange(int uid_start, int uid_end, unsigned netId) { |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 139 | if (uid_start > uid_end || !isValidNetwork(netId)) { |
| 140 | errno = EINVAL; |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 141 | return false; |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 142 | } |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 143 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 144 | android::RWLock::AutoWLock lock(mRWLock); |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 145 | for (std::list<UidEntry>::iterator it = mUidMap.begin(); it != mUidMap.end(); ++it) { |
| 146 | if (it->uid_start != uid_start || it->uid_end != uid_end || it->netId != netId) |
| 147 | continue; |
| 148 | mUidMap.erase(it); |
| 149 | return true; |
| 150 | } |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 151 | |
| 152 | errno = ENOENT; |
Paul Jensen | 5b49ab9 | 2014-04-03 19:06:00 -0400 | [diff] [blame] | 153 | return false; |
| 154 | } |
| 155 | |
Paul Jensen | 35c77e3 | 2014-04-10 14:57:54 -0400 | [diff] [blame] | 156 | unsigned NetworkController::getNetwork(int uid, unsigned requested_netId, bool for_dns) const { |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 157 | android::RWLock::AutoRLock lock(mRWLock); |
| 158 | for (std::list<UidEntry>::const_iterator it = mUidMap.begin(); it != mUidMap.end(); ++it) { |
| 159 | if (uid < it->uid_start || it->uid_end < uid) |
| 160 | continue; |
| 161 | if (for_dns && !it->forward_dns) |
| 162 | break; |
| 163 | return it->netId; |
| 164 | } |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 165 | if (mValidNetworks.find(requested_netId) != mValidNetworks.end()) |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 166 | return requested_netId; |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 167 | return mDefaultNetId; |
| 168 | } |
| 169 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 170 | unsigned NetworkController::getNetworkId(const char* interface) const { |
| 171 | for (InterfaceIteratorConst iter = mNetIdToInterfaces.begin(); iter != mNetIdToInterfaces.end(); |
| 172 | ++iter) { |
| 173 | if (iter->second == interface) { |
| 174 | return iter->first; |
| 175 | } |
| 176 | } |
Paul Jensen | 35c77e3 | 2014-04-10 14:57:54 -0400 | [diff] [blame] | 177 | return NETID_UNSET; |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 178 | } |
| 179 | |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 180 | bool NetworkController::createNetwork(unsigned netId, Permission permission) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 181 | if (netId < MIN_NET_ID || netId > MAX_NET_ID) { |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 182 | ALOGE("invalid netId %u", netId); |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 183 | errno = EINVAL; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 184 | return false; |
| 185 | } |
| 186 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 187 | { |
| 188 | android::RWLock::AutoWLock lock(mRWLock); |
| 189 | if (!mValidNetworks.insert(netId).second) { |
| 190 | ALOGE("duplicate netId %u", netId); |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 191 | errno = EEXIST; |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 192 | return false; |
| 193 | } |
| 194 | } |
| 195 | |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 196 | mPermissionsController->setPermissionForNetwork(permission, netId); |
| 197 | return true; |
| 198 | } |
| 199 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 200 | int NetworkController::addInterfaceToNetwork(unsigned netId, const char* interface) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 201 | if (!isValidNetwork(netId) || !interface) { |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 202 | ALOGE("invalid netId %u or interface null", netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 203 | return -EINVAL; |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 204 | } |
| 205 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 206 | unsigned existingNetId = getNetworkId(interface); |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 207 | if (existingNetId != NETID_UNSET) { |
| 208 | ALOGE("interface %s already assigned to netId %u", interface, existingNetId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 209 | return -EBUSY; |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 210 | } |
| 211 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 212 | int ret; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 213 | Permission permission = mPermissionsController->getPermissionForNetwork(netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 214 | if ((ret = mRouteController->addInterfaceToNetwork(netId, interface, permission)) != 0) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 215 | ALOGE("failed to add interface %s to netId %u", interface, netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 216 | return ret; |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 217 | } |
| 218 | |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 219 | mNetIdToInterfaces.insert(std::pair<unsigned, std::string>(netId, interface)); |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 220 | |
| 221 | if (netId == getDefaultNetwork() && |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 222 | (ret = mRouteController->addToDefaultNetwork(interface, permission)) != 0) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 223 | ALOGE("failed to add interface %s to default netId %u", interface, netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 224 | return ret; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 225 | } |
| 226 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 227 | return 0; |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 228 | } |
| 229 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 230 | int NetworkController::removeInterfaceFromNetwork(unsigned netId, const char* interface) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 231 | if (!isValidNetwork(netId) || !interface) { |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 232 | ALOGE("invalid netId %u or interface null", netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 233 | return -EINVAL; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 234 | } |
| 235 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 236 | int ret = -ENOENT; |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 237 | InterfaceRange range = mNetIdToInterfaces.equal_range(netId); |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 238 | for (InterfaceIterator iter = range.first; iter != range.second; ++iter) { |
| 239 | if (iter->second == interface) { |
| 240 | mNetIdToInterfaces.erase(iter); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 241 | ret = 0; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 242 | break; |
| 243 | } |
| 244 | } |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 245 | |
| 246 | if (ret) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 247 | ALOGE("interface %s not assigned to netId %u", interface, netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 248 | return ret; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | Permission permission = mPermissionsController->getPermissionForNetwork(netId); |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 252 | if (netId == getDefaultNetwork() && |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 253 | (ret = mRouteController->removeFromDefaultNetwork(interface, permission)) != 0) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 254 | ALOGE("failed to remove interface %s from default netId %u", interface, netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 255 | return ret; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 256 | } |
| 257 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 258 | if ((ret = mRouteController->removeInterfaceFromNetwork(netId, interface, permission)) != 0) { |
Paul Jensen | a561e12 | 2014-06-12 16:46:37 -0400 | [diff] [blame] | 259 | ALOGE("failed to remove interface %s from netId %u", interface, netId); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 260 | return ret; |
Paul Jensen | a561e12 | 2014-06-12 16:46:37 -0400 | [diff] [blame] | 261 | } |
| 262 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 263 | return 0; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 264 | } |
| 265 | |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 266 | bool NetworkController::destroyNetwork(unsigned netId) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 267 | if (!isValidNetwork(netId)) { |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 268 | ALOGE("invalid netId %u", netId); |
Lorenzo Colitti | ce8f583 | 2014-05-29 12:20:55 +0900 | [diff] [blame] | 269 | errno = EINVAL; |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 270 | return false; |
| 271 | } |
| 272 | |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 273 | // TODO: ioctl(SIOCKILLADDR, ...) to kill all sockets on the old network. |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 274 | |
| 275 | bool status = true; |
| 276 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 277 | InterfaceRange range = mNetIdToInterfaces.equal_range(netId); |
| 278 | for (InterfaceIteratorConst iter = range.first; iter != range.second; ) { |
Paul Jensen | 6ff1678 | 2014-06-11 10:58:16 -0400 | [diff] [blame] | 279 | char interface[IFNAMSIZ]; |
| 280 | strncpy(interface, iter->second.c_str(), sizeof(interface)); |
| 281 | interface[sizeof(interface) - 1] = 0; |
Paul Jensen | ae37e8a | 2014-04-28 10:35:51 -0400 | [diff] [blame] | 282 | ++iter; |
Paul Jensen | 6ff1678 | 2014-06-11 10:58:16 -0400 | [diff] [blame] | 283 | if (!removeInterfaceFromNetwork(netId, interface)) { |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 284 | status = false; |
| 285 | } |
| 286 | } |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 287 | |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 288 | if (netId == getDefaultNetwork()) { |
Sreeram Ramachandran | 9c0d313 | 2014-04-10 20:35:04 -0700 | [diff] [blame] | 289 | setDefaultNetwork(NETID_UNSET); |
| 290 | } |
| 291 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 292 | { |
| 293 | android::RWLock::AutoWLock lock(mRWLock); |
| 294 | mValidNetworks.erase(netId); |
| 295 | } |
| 296 | |
Sreeram Ramachandran | a79f618 | 2014-04-24 15:55:26 -0700 | [diff] [blame] | 297 | mPermissionsController->setPermissionForNetwork(PERMISSION_NONE, netId); |
Sreeram Ramachandran | a79f618 | 2014-04-24 15:55:26 -0700 | [diff] [blame] | 298 | |
Sreeram Ramachandran | 3ced069 | 2014-04-18 09:49:13 -0700 | [diff] [blame] | 299 | _resolv_delete_cache_for_net(netId); |
Sreeram Ramachandran | 5c181bf | 2014-04-07 14:10:04 -0700 | [diff] [blame] | 300 | return status; |
| 301 | } |
| 302 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 303 | void NetworkController::setPermissionForUser(Permission permission, |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 304 | const std::vector<unsigned>& uid) { |
| 305 | for (size_t i = 0; i < uid.size(); ++i) { |
| 306 | mPermissionsController->setPermissionForUser(permission, uid[i]); |
| 307 | } |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 308 | } |
| 309 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 310 | int NetworkController::setPermissionForNetwork(Permission newPermission, |
| 311 | const std::vector<unsigned>& netId) { |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 312 | for (size_t i = 0; i < netId.size(); ++i) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 313 | if (!isValidNetwork(netId[i])) { |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 314 | ALOGE("invalid netId %u", netId[i]); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 315 | return -EINVAL; |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 318 | Permission oldPermission = mPermissionsController->getPermissionForNetwork(netId[i]); |
| 319 | if (oldPermission == newPermission) { |
| 320 | continue; |
| 321 | } |
| 322 | |
| 323 | // TODO: ioctl(SIOCKILLADDR, ...) to kill sockets on the network that don't have |
| 324 | // newPermission. |
| 325 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 326 | InterfaceRange range = mNetIdToInterfaces.equal_range(netId[i]); |
| 327 | for (InterfaceIteratorConst iter = range.first; iter != range.second; ++iter) { |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 328 | int ret = mRouteController->modifyNetworkPermission(netId[i], iter->second.c_str(), |
| 329 | oldPermission, newPermission); |
| 330 | if (ret) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 331 | ALOGE("failed to change permission on interface %s of netId %u from %x to %x", |
| 332 | iter->second.c_str(), netId[i], oldPermission, newPermission); |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 333 | return ret; |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 334 | } |
| 335 | } |
| 336 | |
| 337 | mPermissionsController->setPermissionForNetwork(newPermission, netId[i]); |
| 338 | } |
| 339 | |
Lorenzo Colitti | 96f261e | 2014-06-23 15:09:54 +0900 | [diff] [blame^] | 340 | return 0; |
Sreeram Ramachandran | 379bd33 | 2014-04-10 19:58:06 -0700 | [diff] [blame] | 341 | } |
| 342 | |
Lorenzo Colitti | f7fc8ec | 2014-06-18 00:41:58 +0900 | [diff] [blame] | 343 | int NetworkController::addRoute(unsigned netId, const char* interface, const char* destination, |
| 344 | const char* nexthop, bool legacy, unsigned uid) { |
Sreeram Ramachandran | 38b7af1 | 2014-05-22 14:21:49 -0700 | [diff] [blame] | 345 | return modifyRoute(netId, interface, destination, nexthop, true, legacy, uid); |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 346 | } |
| 347 | |
Lorenzo Colitti | f7fc8ec | 2014-06-18 00:41:58 +0900 | [diff] [blame] | 348 | int NetworkController::removeRoute(unsigned netId, const char* interface, const char* destination, |
| 349 | const char* nexthop, bool legacy, unsigned uid) { |
Sreeram Ramachandran | 38b7af1 | 2014-05-22 14:21:49 -0700 | [diff] [blame] | 350 | return modifyRoute(netId, interface, destination, nexthop, false, legacy, uid); |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 351 | } |
| 352 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 353 | bool NetworkController::isValidNetwork(unsigned netId) const { |
| 354 | if (netId == NETID_UNSET) { |
| 355 | return false; |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 356 | } |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 357 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 358 | android::RWLock::AutoRLock lock(mRWLock); |
| 359 | return mValidNetworks.find(netId) != mValidNetworks.end(); |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 360 | } |
| 361 | |
Lorenzo Colitti | f7fc8ec | 2014-06-18 00:41:58 +0900 | [diff] [blame] | 362 | int NetworkController::modifyRoute(unsigned netId, const char* interface, const char* destination, |
| 363 | const char* nexthop, bool add, bool legacy, unsigned uid) { |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 364 | if (!isValidNetwork(netId)) { |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 365 | ALOGE("invalid netId %u", netId); |
Lorenzo Colitti | f7fc8ec | 2014-06-18 00:41:58 +0900 | [diff] [blame] | 366 | return -EINVAL; |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 367 | } |
| 368 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 369 | if (getNetworkId(interface) != netId) { |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 370 | ALOGE("netId %u has no such interface %s", netId, interface); |
Lorenzo Colitti | f7fc8ec | 2014-06-18 00:41:58 +0900 | [diff] [blame] | 371 | return -ENOENT; |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 372 | } |
| 373 | |
Sreeram Ramachandran | 38b7af1 | 2014-05-22 14:21:49 -0700 | [diff] [blame] | 374 | RouteController::TableType tableType; |
| 375 | if (legacy) { |
| 376 | if (mPermissionsController->getPermissionForUser(uid) & PERMISSION_CONNECTIVITY_INTERNAL) { |
| 377 | tableType = RouteController::PRIVILEGED_LEGACY; |
| 378 | } else { |
| 379 | tableType = RouteController::LEGACY; |
| 380 | } |
| 381 | } else { |
| 382 | tableType = RouteController::INTERFACE; |
| 383 | } |
| 384 | |
| 385 | return add ? mRouteController->addRoute(interface, destination, nexthop, tableType, uid) : |
| 386 | mRouteController->removeRoute(interface, destination, nexthop, tableType, uid); |
Sreeram Ramachandran | 7619e1b | 2014-04-15 14:23:08 -0700 | [diff] [blame] | 387 | } |
| 388 | |
Sreeram Ramachandran | 7260407 | 2014-05-21 13:19:43 -0700 | [diff] [blame] | 389 | NetworkController::UidEntry::UidEntry(int start, int end, unsigned netId, bool forward_dns) |
| 390 | : uid_start(start), uid_end(end), netId(netId), forward_dns(forward_dns) { |
Szymon Jakubczak | a0efaec | 2014-02-14 17:09:43 -0500 | [diff] [blame] | 391 | } |