blob: 90b76829f980e334dcdf1dbd04e5d1b3520f0b38 [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 Ramachandran6a773532014-07-11 09:10:20 -070035#include "LocalNetwork.h"
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070036#include "PhysicalNetwork.h"
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070037#include "RouteController.h"
Sreeram Ramachandran4043f012014-06-23 12:41:37 -070038#include "VirtualNetwork.h"
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070039
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -070040#include "cutils/misc.h"
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070041#define LOG_TAG "Netd"
42#include "log/log.h"
Sreeram Ramachandran72604072014-05-21 13:19:43 -070043#include "resolv_netid.h"
44
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070045namespace {
46
47// Keep these in sync with ConnectivityService.java.
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070048const unsigned MIN_NET_ID = 10;
49const unsigned MAX_NET_ID = 65535;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -070050
51} // namespace
52
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070053NetworkController::NetworkController() : mDefaultNetId(NETID_UNSET) {
Sreeram Ramachandran87475a12014-07-15 16:20:28 -070054 mNetworks[LOCAL_NET_ID] = new LocalNetwork(LOCAL_NET_ID);
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050055}
56
57unsigned NetworkController::getDefaultNetwork() const {
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070058 android::RWLock::AutoRLock lock(mRWLock);
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050059 return mDefaultNetId;
60}
61
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070062int NetworkController::setDefaultNetwork(unsigned netId) {
63 android::RWLock::AutoWLock lock(mRWLock);
64
65 if (netId == mDefaultNetId) {
66 return 0;
Sreeram Ramachandran72604072014-05-21 13:19:43 -070067 }
68
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070069 if (netId != NETID_UNSET) {
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -070070 Network* network = getNetworkLocked(netId);
71 if (!network || network->getType() != Network::PHYSICAL) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070072 ALOGE("invalid netId %u", netId);
73 return -EINVAL;
74 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -070075 if (int ret = static_cast<PhysicalNetwork*>(network)->addAsDefault()) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070076 return ret;
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070077 }
78 }
79
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070080 if (mDefaultNetId != NETID_UNSET) {
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -070081 Network* network = getNetworkLocked(mDefaultNetId);
82 if (!network || network->getType() != Network::PHYSICAL) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070083 ALOGE("cannot find previously set default network with netId %u", mDefaultNetId);
84 return -ESRCH;
85 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -070086 if (int ret = static_cast<PhysicalNetwork*>(network)->removeAsDefault()) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070087 return ret;
Sreeram Ramachandran9c0d3132014-04-10 20:35:04 -070088 }
89 }
90
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -070091 mDefaultNetId = netId;
92 return 0;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050093}
94
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -070095unsigned NetworkController::getNetworkForUser(uid_t uid, unsigned requestedNetId,
96 bool forDns) const {
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -050097 android::RWLock::AutoRLock lock(mRWLock);
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -070098 VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid);
99 if (virtualNetwork && (!forDns || virtualNetwork->getHasDns())) {
100 return virtualNetwork->getNetId();
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500101 }
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700102 return getNetworkLocked(requestedNetId) ? requestedNetId : mDefaultNetId;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500103}
104
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700105unsigned NetworkController::getNetworkForInterface(const char* interface) const {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700106 android::RWLock::AutoRLock lock(mRWLock);
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700107 for (const auto& entry : mNetworks) {
Sreeram Ramachandran4043f012014-06-23 12:41:37 -0700108 if (entry.second->hasInterface(interface)) {
109 return entry.first;
110 }
111 }
Paul Jensen35c77e32014-04-10 14:57:54 -0400112 return NETID_UNSET;
Szymon Jakubczaka0efaec2014-02-14 17:09:43 -0500113}
114
Sreeram Ramachandran070b2d22014-07-11 17:06:12 -0700115bool NetworkController::isVirtualNetwork(unsigned netId) const {
116 android::RWLock::AutoRLock lock(mRWLock);
117 Network* network = getNetworkLocked(netId);
118 return network && network->getType() == Network::VIRTUAL;
119}
120
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700121int NetworkController::createPhysicalNetwork(unsigned netId, Permission permission) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700122 if (netId < MIN_NET_ID || netId > MAX_NET_ID) {
Paul Jensenae37e8a2014-04-28 10:35:51 -0400123 ALOGE("invalid netId %u", netId);
Lorenzo Colitti96f261e2014-06-23 15:09:54 +0900124 return -EINVAL;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700125 }
126
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700127 if (isValidNetwork(netId)) {
128 ALOGE("duplicate netId %u", netId);
129 return -EEXIST;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700130 }
131
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700132 PhysicalNetwork* physicalNetwork = new PhysicalNetwork(netId);
133 if (int ret = physicalNetwork->setPermission(permission)) {
134 ALOGE("inconceivable! setPermission cannot fail on an empty network");
135 delete physicalNetwork;
Lorenzo Colitti96f261e2014-06-23 15:09:54 +0900136 return ret;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700137 }
138
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700139 android::RWLock::AutoWLock lock(mRWLock);
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700140 mNetworks[netId] = physicalNetwork;
Lorenzo Colitti96f261e2014-06-23 15:09:54 +0900141 return 0;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700142}
143
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700144int NetworkController::createVirtualNetwork(unsigned netId, bool hasDns) {
Sreeram Ramachandran4043f012014-06-23 12:41:37 -0700145 if (netId < MIN_NET_ID || netId > MAX_NET_ID) {
146 ALOGE("invalid netId %u", netId);
147 return -EINVAL;
148 }
149
150 if (isValidNetwork(netId)) {
151 ALOGE("duplicate netId %u", netId);
152 return -EEXIST;
153 }
154
155 android::RWLock::AutoWLock lock(mRWLock);
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700156 mNetworks[netId] = new VirtualNetwork(netId, hasDns);
Sreeram Ramachandran4043f012014-06-23 12:41:37 -0700157 return 0;
158}
159
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700160int NetworkController::destroyNetwork(unsigned netId) {
Sreeram Ramachandran87475a12014-07-15 16:20:28 -0700161 if (netId == LOCAL_NET_ID || !isValidNetwork(netId)) {
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700162 ALOGE("invalid netId %u", netId);
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700163 return -EINVAL;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700164 }
165
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700166 // TODO: ioctl(SIOCKILLADDR, ...) to kill all sockets on the old network.
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700167
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700168 android::RWLock::AutoWLock lock(mRWLock);
169 Network* network = getNetworkLocked(netId);
170 if (int ret = network->clearInterfaces()) {
171 return ret;
172 }
173 if (mDefaultNetId == netId) {
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700174 if (int ret = static_cast<PhysicalNetwork*>(network)->removeAsDefault()) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700175 ALOGE("inconceivable! removeAsDefault cannot fail on an empty network");
176 return ret;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700177 }
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700178 mDefaultNetId = NETID_UNSET;
Sreeram Ramachandran5c181bf2014-04-07 14:10:04 -0700179 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700180 mNetworks.erase(netId);
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700181 delete network;
Sreeram Ramachandran3ced0692014-04-18 09:49:13 -0700182 _resolv_delete_cache_for_net(netId);
Lorenzo Colitti96f261e2014-06-23 15:09:54 +0900183 return 0;
Sreeram Ramachandran379bd332014-04-10 19:58:06 -0700184}
185
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700186int NetworkController::addInterfaceToNetwork(unsigned netId, const char* interface) {
Sreeram Ramachandran72604072014-05-21 13:19:43 -0700187 if (!isValidNetwork(netId)) {
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700188 ALOGE("invalid netId %u", netId);
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900189 return -EINVAL;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700190 }
191
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700192 unsigned existingNetId = getNetworkForInterface(interface);
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700193 if (existingNetId != NETID_UNSET && existingNetId != netId) {
194 ALOGE("interface %s already assigned to netId %u", interface, existingNetId);
195 return -EBUSY;
196 }
197
198 android::RWLock::AutoWLock lock(mRWLock);
199 return getNetworkLocked(netId)->addInterface(interface);
200}
201
202int NetworkController::removeInterfaceFromNetwork(unsigned netId, const char* interface) {
203 if (!isValidNetwork(netId)) {
204 ALOGE("invalid netId %u", netId);
205 return -EINVAL;
206 }
207
208 android::RWLock::AutoWLock lock(mRWLock);
209 return getNetworkLocked(netId)->removeInterface(interface);
210}
211
212Permission NetworkController::getPermissionForUser(uid_t uid) const {
213 android::RWLock::AutoRLock lock(mRWLock);
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -0700214 return getPermissionForUserLocked(uid);
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700215}
216
217void NetworkController::setPermissionForUsers(Permission permission,
218 const std::vector<uid_t>& uids) {
219 android::RWLock::AutoWLock lock(mRWLock);
220 for (uid_t uid : uids) {
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -0700221 mUsers[uid] = permission;
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700222 }
223}
224
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700225bool NetworkController::canUserSelectNetwork(uid_t uid, unsigned netId) const {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700226 android::RWLock::AutoRLock lock(mRWLock);
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700227 Network* network = getNetworkLocked(netId);
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700228 if (!network || uid == INVALID_UID) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700229 return false;
230 }
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -0700231 Permission userPermission = getPermissionForUserLocked(uid);
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700232 if ((userPermission & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) {
233 return true;
234 }
235 if (network->getType() == Network::VIRTUAL) {
236 return static_cast<VirtualNetwork*>(network)->appliesToUser(uid);
237 }
238 VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid);
239 if (virtualNetwork && mProtectableUsers.find(uid) == mProtectableUsers.end()) {
240 return false;
241 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700242 Permission networkPermission = static_cast<PhysicalNetwork*>(network)->getPermission();
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700243 return (userPermission & networkPermission) == networkPermission;
244}
245
246int NetworkController::setPermissionForNetworks(Permission permission,
247 const std::vector<unsigned>& netIds) {
248 android::RWLock::AutoWLock lock(mRWLock);
249 for (unsigned netId : netIds) {
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700250 Network* network = getNetworkLocked(netId);
251 if (!network || network->getType() != Network::PHYSICAL) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700252 ALOGE("invalid netId %u", netId);
253 return -EINVAL;
254 }
255
256 // TODO: ioctl(SIOCKILLADDR, ...) to kill socets on the network that don't have permission.
257
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700258 if (int ret = static_cast<PhysicalNetwork*>(network)->setPermission(permission)) {
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700259 return ret;
260 }
261 }
262 return 0;
263}
264
Sreeram Ramachandranb1425cc2014-06-23 18:54:27 -0700265int NetworkController::addUsersToNetwork(unsigned netId, const UidRanges& uidRanges) {
266 android::RWLock::AutoWLock lock(mRWLock);
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700267 Network* network = getNetworkLocked(netId);
268 if (!network || network->getType() != Network::VIRTUAL) {
Sreeram Ramachandranb1425cc2014-06-23 18:54:27 -0700269 ALOGE("invalid netId %u", netId);
270 return -EINVAL;
271 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700272 if (int ret = static_cast<VirtualNetwork*>(network)->addUsers(uidRanges)) {
Sreeram Ramachandranb1425cc2014-06-23 18:54:27 -0700273 return ret;
274 }
275 return 0;
276}
277
278int NetworkController::removeUsersFromNetwork(unsigned netId, const UidRanges& uidRanges) {
279 android::RWLock::AutoWLock lock(mRWLock);
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700280 Network* network = getNetworkLocked(netId);
281 if (!network || network->getType() != Network::VIRTUAL) {
Sreeram Ramachandranb1425cc2014-06-23 18:54:27 -0700282 ALOGE("invalid netId %u", netId);
283 return -EINVAL;
284 }
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700285 if (int ret = static_cast<VirtualNetwork*>(network)->removeUsers(uidRanges)) {
Sreeram Ramachandranb1425cc2014-06-23 18:54:27 -0700286 return ret;
287 }
288 return 0;
289}
290
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700291int NetworkController::addRoute(unsigned netId, const char* interface, const char* destination,
292 const char* nexthop, bool legacy, uid_t uid) {
293 return modifyRoute(netId, interface, destination, nexthop, true, legacy, uid);
294}
295
296int NetworkController::removeRoute(unsigned netId, const char* interface, const char* destination,
297 const char* nexthop, bool legacy, uid_t uid) {
298 return modifyRoute(netId, interface, destination, nexthop, false, legacy, uid);
299}
300
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700301bool NetworkController::canProtect(uid_t uid) const {
302 android::RWLock::AutoRLock lock(mRWLock);
303 return ((getPermissionForUserLocked(uid) & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) ||
304 mProtectableUsers.find(uid) != mProtectableUsers.end();
305}
306
Sreeram Ramachandran89dad012014-07-02 10:09:49 -0700307void NetworkController::allowProtect(const std::vector<uid_t>& uids) {
308 android::RWLock::AutoWLock lock(mRWLock);
309 mProtectableUsers.insert(uids.begin(), uids.end());
310}
311
312void NetworkController::denyProtect(const std::vector<uid_t>& uids) {
313 android::RWLock::AutoWLock lock(mRWLock);
314 for (uid_t uid : uids) {
315 mProtectableUsers.erase(uid);
316 }
317}
318
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700319bool NetworkController::isValidNetwork(unsigned netId) const {
320 android::RWLock::AutoRLock lock(mRWLock);
321 return getNetworkLocked(netId);
322}
323
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700324Network* NetworkController::getNetworkLocked(unsigned netId) const {
Sreeram Ramachandran36ed53e2014-07-01 19:01:56 -0700325 auto iter = mNetworks.find(netId);
326 return iter == mNetworks.end() ? NULL : iter->second;
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700327}
328
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700329VirtualNetwork* NetworkController::getVirtualNetworkForUserLocked(uid_t uid) const {
330 for (const auto& entry : mNetworks) {
331 if (entry.second->getType() == Network::VIRTUAL) {
332 VirtualNetwork* virtualNetwork = static_cast<VirtualNetwork*>(entry.second);
333 if (virtualNetwork->appliesToUser(uid)) {
334 return virtualNetwork;
335 }
336 }
337 }
338 return NULL;
339}
340
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -0700341Permission NetworkController::getPermissionForUserLocked(uid_t uid) const {
342 auto iter = mUsers.find(uid);
343 if (iter != mUsers.end()) {
344 return iter->second;
345 }
346 return uid < FIRST_APPLICATION_UID ? PERMISSION_SYSTEM : PERMISSION_NONE;
347}
348
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700349int NetworkController::modifyRoute(unsigned netId, const char* interface, const char* destination,
350 const char* nexthop, bool add, bool legacy, uid_t uid) {
Sreeram Ramachandrane09b20a2014-07-05 17:15:14 -0700351 unsigned existingNetId = getNetworkForInterface(interface);
Sreeram Ramachandranf4f6c8d2014-06-23 09:54:06 -0700352 if (netId == NETID_UNSET || existingNetId != netId) {
353 ALOGE("interface %s assigned to netId %u, not %u", interface, existingNetId, netId);
Lorenzo Colittif7fc8ec2014-06-18 00:41:58 +0900354 return -ENOENT;
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700355 }
356
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700357 RouteController::TableType tableType;
Sreeram Ramachandran87475a12014-07-15 16:20:28 -0700358 if (netId == LOCAL_NET_ID) {
359 tableType = RouteController::LOCAL_NETWORK;
360 } else if (legacy) {
Sreeram Ramachandraned4bd1f2014-07-05 12:31:05 -0700361 if ((getPermissionForUser(uid) & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) {
Sreeram Ramachandran5009d5e2014-07-03 12:20:48 -0700362 tableType = RouteController::LEGACY_SYSTEM;
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700363 } else {
Sreeram Ramachandran5009d5e2014-07-03 12:20:48 -0700364 tableType = RouteController::LEGACY_NETWORK;
Sreeram Ramachandran38b7af12014-05-22 14:21:49 -0700365 }
366 } else {
367 tableType = RouteController::INTERFACE;
368 }
369
Sreeram Ramachandraneb27b7e2014-07-01 14:30:30 -0700370 return add ? RouteController::addRoute(interface, destination, nexthop, tableType) :
371 RouteController::removeRoute(interface, destination, nexthop, tableType);
Sreeram Ramachandran7619e1b2014-04-15 14:23:08 -0700372}