blob: de433b7f255f20aa49ed00de4096cd793e24b1a4 [file] [log] [blame]
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -05001/*
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 Ramachandran72604072014-05-21 13:19:43 -070017// 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 Jakubczaka0efaec2014-02-14 17:09:43 -050032
33#include "NetworkController.h"
34
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070035#include "PermissionsController.h"
36#include "RouteController.h"
37
Sreeram Ramachandran72604072014-05-21 13:19:43 -070038#define LOG_TAG "NetworkController"
Paul Jensen6ff16782014-06-11 10:58:16 -040039
40#include <sys/socket.h>
41#include <linux/if.h>
42
Sreeram Ramachandran72604072014-05-21 13:19:43 -070043#include "cutils/log.h"
44#include "resolv_netid.h"
45
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070046namespace {
47
48// Keep these in sync with ConnectivityService.java.
49const unsigned int MIN_NET_ID = 10;
50const unsigned int MAX_NET_ID = 65535;
51
52} // namespace
53
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070054NetworkController::NetworkController(PermissionsController* permissionsController,
55 RouteController* routeController)
Sreeram Ramachandran574e6332014-05-14 08:31:55 -070056 : mDefaultNetId(NETID_UNSET),
57 mPermissionsController(permissionsController),
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070058 mRouteController(routeController) {
59}
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050060
61void NetworkController::clearNetworkPreference() {
62 android::RWLock::AutoWLock lock(mRWLock);
63 mUidMap.clear();
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050064}
65
66unsigned NetworkController::getDefaultNetwork() const {
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070067 android::RWLock::AutoRLock lock(mRWLock);
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050068 return mDefaultNetId;
69}
70
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070071bool NetworkController::setDefaultNetwork(unsigned newNetId) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -070072 // 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 Colittice8f5832014-05-29 12:20:55 +090076 errno = EINVAL;
Sreeram Ramachandran72604072014-05-21 13:19:43 -070077 return false;
78 }
79
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070080 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 Ramachandran72604072014-05-21 13:19:43 -070092 Permission permission;
93 InterfaceRange range;
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070094
95 // Add default network rules for the new netId.
Sreeram Ramachandran72604072014-05-21 13:19:43 -070096 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 Ramachandran9c0d3132014-04-10 20:35:04 -0700102 }
103 }
104
105 // Remove the old default network rules.
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700106 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 Ramachandran9c0d3132014-04-10 20:35:04 -0700113 }
114 }
115
116 return status;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500117}
118
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500119bool NetworkController::setNetworkForUidRange(int uid_start, int uid_end, unsigned netId,
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700120 bool forward_dns) {
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900121 if (uid_start > uid_end || !isValidNetwork(netId)) {
122 errno = EINVAL;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500123 return false;
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900124 }
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500125
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700126 android::RWLock::AutoWLock lock(mRWLock);
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500127 for (std::list<UidEntry>::iterator it = mUidMap.begin(); it != mUidMap.end(); ++it) {
Paul Jensen5b49ab92014-04-03 19:06:00 -0400128 if (it->uid_start != uid_start || it->uid_end != uid_end || it->netId != netId)
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500129 continue;
Paul Jensen5b49ab92014-04-03 19:06:00 -0400130 it->forward_dns = forward_dns;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500131 return true;
132 }
133
Paul Jensen5b49ab92014-04-03 19:06:00 -0400134 mUidMap.push_front(UidEntry(uid_start, uid_end, netId, forward_dns));
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500135 return true;
136}
137
Paul Jensen5b49ab92014-04-03 19:06:00 -0400138bool NetworkController::clearNetworkForUidRange(int uid_start, int uid_end, unsigned netId) {
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900139 if (uid_start > uid_end || !isValidNetwork(netId)) {
140 errno = EINVAL;
Paul Jensen5b49ab92014-04-03 19:06:00 -0400141 return false;
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900142 }
Paul Jensen5b49ab92014-04-03 19:06:00 -0400143
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700144 android::RWLock::AutoWLock lock(mRWLock);
Paul Jensen5b49ab92014-04-03 19:06:00 -0400145 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 Colittice8f5832014-05-29 12:20:55 +0900151
152 errno = ENOENT;
Paul Jensen5b49ab92014-04-03 19:06:00 -0400153 return false;
154}
155
Paul Jensen35c77e32014-04-10 14:57:54 -0400156unsigned NetworkController::getNetwork(int uid, unsigned requested_netId, bool for_dns) const {
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500157 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 Ramachandran72604072014-05-21 13:19:43 -0700165 if (mValidNetworks.find(requested_netId) != mValidNetworks.end())
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500166 return requested_netId;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500167 return mDefaultNetId;
168}
169
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700170unsigned 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 Jensen35c77e32014-04-10 14:57:54 -0400177 return NETID_UNSET;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500178}
179
Paul Jensenae37e8a2014-04-28 10:35:51 -0400180bool NetworkController::createNetwork(unsigned netId, Permission permission) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700181 if (netId < MIN_NET_ID || netId > MAX_NET_ID) {
Paul Jensenae37e8a2014-04-28 10:35:51 -0400182 ALOGE("invalid netId %u", netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900183 errno = EINVAL;
Paul Jensenae37e8a2014-04-28 10:35:51 -0400184 return false;
185 }
186
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700187 {
188 android::RWLock::AutoWLock lock(mRWLock);
189 if (!mValidNetworks.insert(netId).second) {
190 ALOGE("duplicate netId %u", netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900191 errno = EEXIST;
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700192 return false;
193 }
194 }
195
Paul Jensenae37e8a2014-04-28 10:35:51 -0400196 mPermissionsController->setPermissionForNetwork(permission, netId);
197 return true;
198}
199
200bool NetworkController::addInterfaceToNetwork(unsigned netId, const char* interface) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700201 if (!isValidNetwork(netId) || !interface) {
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700202 ALOGE("invalid netId %u or interface null", netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900203 errno = EINVAL;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700204 return false;
205 }
206
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700207 unsigned existingNetId = getNetworkId(interface);
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700208 if (existingNetId != NETID_UNSET) {
209 ALOGE("interface %s already assigned to netId %u", interface, existingNetId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900210 errno = EBUSY;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700211 return false;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700212 }
213
Paul Jensenae37e8a2014-04-28 10:35:51 -0400214 Permission permission = mPermissionsController->getPermissionForNetwork(netId);
215 if (!mRouteController->addInterfaceToNetwork(netId, interface, permission)) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700216 ALOGE("failed to add interface %s to netId %u", interface, netId);
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700217 return false;
218 }
219
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700220 mNetIdToInterfaces.insert(std::pair<unsigned, std::string>(netId, interface));
Paul Jensenae37e8a2014-04-28 10:35:51 -0400221
222 if (netId == getDefaultNetwork() &&
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700223 !mRouteController->addToDefaultNetwork(interface, permission)) {
224 ALOGE("failed to add interface %s to default netId %u", interface, netId);
Paul Jensenae37e8a2014-04-28 10:35:51 -0400225 return false;
226 }
227
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700228 return true;
229}
230
Paul Jensenae37e8a2014-04-28 10:35:51 -0400231bool NetworkController::removeInterfaceFromNetwork(unsigned netId, const char* interface) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700232 if (!isValidNetwork(netId) || !interface) {
Paul Jensenae37e8a2014-04-28 10:35:51 -0400233 ALOGE("invalid netId %u or interface null", netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900234 errno = EINVAL;
Paul Jensenae37e8a2014-04-28 10:35:51 -0400235 return false;
236 }
237
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700238 bool status = false;
239 InterfaceRange range = mNetIdToInterfaces.equal_range(netId);
Paul Jensenae37e8a2014-04-28 10:35:51 -0400240 for (InterfaceIterator iter = range.first; iter != range.second; ++iter) {
241 if (iter->second == interface) {
242 mNetIdToInterfaces.erase(iter);
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700243 status = true;
Paul Jensenae37e8a2014-04-28 10:35:51 -0400244 break;
245 }
246 }
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700247 if (!status) {
248 ALOGE("interface %s not assigned to netId %u", interface, netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900249 errno = ENOENT;
Paul Jensenae37e8a2014-04-28 10:35:51 -0400250 }
251
252 Permission permission = mPermissionsController->getPermissionForNetwork(netId);
Paul Jensenae37e8a2014-04-28 10:35:51 -0400253 if (netId == getDefaultNetwork() &&
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700254 !mRouteController->removeFromDefaultNetwork(interface, permission)) {
255 ALOGE("failed to remove interface %s from default netId %u", interface, netId);
Paul Jensenae37e8a2014-04-28 10:35:51 -0400256 status = false;
257 }
258
Paul Jensena561e122014-06-12 16:46:37 -0400259 if (!mRouteController->removeInterfaceFromNetwork(netId, interface, permission)) {
260 ALOGE("failed to remove interface %s from netId %u", interface, netId);
261 status = false;
262 }
263
Paul Jensenae37e8a2014-04-28 10:35:51 -0400264 return status;
265}
266
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700267bool NetworkController::destroyNetwork(unsigned netId) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700268 if (!isValidNetwork(netId)) {
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700269 ALOGE("invalid netId %u", netId);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900270 errno = EINVAL;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700271 return false;
272 }
273
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700274 // TODO: ioctl(SIOCKILLADDR, ...) to kill all sockets on the old network.
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700275
276 bool status = true;
277
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700278 InterfaceRange range = mNetIdToInterfaces.equal_range(netId);
279 for (InterfaceIteratorConst iter = range.first; iter != range.second; ) {
Paul Jensen6ff16782014-06-11 10:58:16 -0400280 char interface[IFNAMSIZ];
281 strncpy(interface, iter->second.c_str(), sizeof(interface));
282 interface[sizeof(interface) - 1] = 0;
Paul Jensenae37e8a2014-04-28 10:35:51 -0400283 ++iter;
Paul Jensen6ff16782014-06-11 10:58:16 -0400284 if (!removeInterfaceFromNetwork(netId, interface)) {
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700285 status = false;
286 }
287 }
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700288
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -0700289 if (netId == getDefaultNetwork()) {
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -0700290 setDefaultNetwork(NETID_UNSET);
291 }
292
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700293 {
294 android::RWLock::AutoWLock lock(mRWLock);
295 mValidNetworks.erase(netId);
296 }
297
Sreeram Ramachandrana79f6182014-04-24 15:55:26 -0700298 mPermissionsController->setPermissionForNetwork(PERMISSION_NONE, netId);
Sreeram Ramachandrana79f6182014-04-24 15:55:26 -0700299
Sreeram Ramachandran3ced0692014-04-18 09:49:13 -0700300 _resolv_delete_cache_for_net(netId);
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700301 return status;
302}
303
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700304bool NetworkController::setPermissionForUser(Permission permission,
305 const std::vector<unsigned>& uid) {
306 for (size_t i = 0; i < uid.size(); ++i) {
307 mPermissionsController->setPermissionForUser(permission, uid[i]);
308 }
309 return true;
310}
311
312bool NetworkController::setPermissionForNetwork(Permission newPermission,
313 const std::vector<unsigned>& netId) {
314 bool status = true;
315
316 for (size_t i = 0; i < netId.size(); ++i) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700317 if (!isValidNetwork(netId[i])) {
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700318 ALOGE("invalid netId %u", netId[i]);
Lorenzo Colittice8f5832014-05-29 12:20:55 +0900319 errno = EINVAL;
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700320 status = false;
321 continue;
322 }
323
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700324 Permission oldPermission = mPermissionsController->getPermissionForNetwork(netId[i]);
325 if (oldPermission == newPermission) {
326 continue;
327 }
328
329 // TODO: ioctl(SIOCKILLADDR, ...) to kill sockets on the network that don't have
330 // newPermission.
331
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700332 InterfaceRange range = mNetIdToInterfaces.equal_range(netId[i]);
333 for (InterfaceIteratorConst iter = range.first; iter != range.second; ++iter) {
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700334 if (!mRouteController->modifyNetworkPermission(netId[i], iter->second.c_str(),
335 oldPermission, newPermission)) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700336 ALOGE("failed to change permission on interface %s of netId %u from %x to %x",
337 iter->second.c_str(), netId[i], oldPermission, newPermission);
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700338 status = false;
339 }
340 }
341
342 mPermissionsController->setPermissionForNetwork(newPermission, netId[i]);
343 }
344
345 return status;
346}
347
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900348int NetworkController::addRoute(unsigned netId, const char* interface, const char* destination,
349 const char* nexthop, bool legacy, unsigned uid) {
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700350 return modifyRoute(netId, interface, destination, nexthop, true, legacy, uid);
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700351}
352
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900353int NetworkController::removeRoute(unsigned netId, const char* interface, const char* destination,
354 const char* nexthop, bool legacy, unsigned uid) {
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700355 return modifyRoute(netId, interface, destination, nexthop, false, legacy, uid);
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700356}
357
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700358bool NetworkController::isValidNetwork(unsigned netId) const {
359 if (netId == NETID_UNSET) {
360 return false;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700361 }
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700362
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700363 android::RWLock::AutoRLock lock(mRWLock);
364 return mValidNetworks.find(netId) != mValidNetworks.end();
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700365}
366
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900367int NetworkController::modifyRoute(unsigned netId, const char* interface, const char* destination,
368 const char* nexthop, bool add, bool legacy, unsigned uid) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700369 if (!isValidNetwork(netId)) {
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700370 ALOGE("invalid netId %u", netId);
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900371 return -EINVAL;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700372 }
373
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700374 if (getNetworkId(interface) != netId) {
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700375 ALOGE("netId %u has no such interface %s", netId, interface);
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900376 return -ENOENT;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700377 }
378
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700379 RouteController::TableType tableType;
380 if (legacy) {
381 if (mPermissionsController->getPermissionForUser(uid) & PERMISSION_CONNECTIVITY_INTERNAL) {
382 tableType = RouteController::PRIVILEGED_LEGACY;
383 } else {
384 tableType = RouteController::LEGACY;
385 }
386 } else {
387 tableType = RouteController::INTERFACE;
388 }
389
390 return add ? mRouteController->addRoute(interface, destination, nexthop, tableType, uid) :
391 mRouteController->removeRoute(interface, destination, nexthop, tableType, uid);
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700392}
393
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700394NetworkController::UidEntry::UidEntry(int start, int end, unsigned netId, bool forward_dns)
395 : uid_start(start), uid_end(end), netId(netId), forward_dns(forward_dns) {
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500396}