server/NetworkController.cpp

   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
  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.
  32
  33 #include "NetworkController.h"
  34
  35 #define LOG_TAG "Netd"
  36 #include "log/log.h"
  37
  38 #include "cutils/misc.h"
  39 #include "resolv_netid.h"
  40
  41 #include "Controllers.h"
  42 #include "DummyNetwork.h"
  43 #include "DumpWriter.h"
  44 #include "Fwmark.h"
  45 #include "LocalNetwork.h"
  46 #include "PhysicalNetwork.h"
  47 #include "RouteController.h"
  48 #include "VirtualNetwork.h"
  49
  50 namespace {
  51
  52 // Keep these in sync with ConnectivityService.java.
  53 const unsigned MIN_NET_ID = 100;
  54 const unsigned MAX_NET_ID = 65535;
  55
  56 }  // namespace
  57
  58 const unsigned NetworkController::MIN_OEM_ID   =  1;
  59 const unsigned NetworkController::MAX_OEM_ID   = 50;
  60 const unsigned NetworkController::DUMMY_NET_ID = 51;
  61 // NetIds 52..98 are reserved for future use.
  62 const unsigned NetworkController::LOCAL_NET_ID = 99;
  63
  64 // All calls to methods here are made while holding a write lock on mRWLock.
  65 class NetworkController::DelegateImpl : public PhysicalNetwork::Delegate {
  66 public:
  67     explicit DelegateImpl(NetworkController* networkController);
  68     virtual ~DelegateImpl();
  69
  70     int modifyFallthrough(unsigned vpnNetId, const std::string& physicalInterface,
  71                           Permission permission, bool add) WARN_UNUSED_RESULT;
  72
  73 private:
  74     int addFallthrough(const std::string& physicalInterface,
  75                        Permission permission) override WARN_UNUSED_RESULT;
  76     int removeFallthrough(const std::string& physicalInterface,
  77                           Permission permission) override WARN_UNUSED_RESULT;
  78
  79     int modifyFallthrough(const std::string& physicalInterface, Permission permission,
  80                           bool add) WARN_UNUSED_RESULT;
  81
  82     NetworkController* const mNetworkController;
  83 };
  84
  85 NetworkController::DelegateImpl::DelegateImpl(NetworkController* networkController) :
  86         mNetworkController(networkController) {
  87 }
  88
  89 NetworkController::DelegateImpl::~DelegateImpl() {
  90 }
  91
  92 int NetworkController::DelegateImpl::modifyFallthrough(unsigned vpnNetId,
  93                                                        const std::string& physicalInterface,
  94                                                        Permission permission, bool add) {
  95     if (add) {
  96         if (int ret = RouteController::addVirtualNetworkFallthrough(vpnNetId,
  97                                                                     physicalInterface.c_str(),
  98                                                                     permission)) {
  99             ALOGE("failed to add fallthrough to %s for VPN netId %u", physicalInterface.c_str(),
 100                   vpnNetId);
 101             return ret;
 102         }
 103     } else {
 104         if (int ret = RouteController::removeVirtualNetworkFallthrough(vpnNetId,
 105                                                                        physicalInterface.c_str(),
 106                                                                        permission)) {
 107             ALOGE("failed to remove fallthrough to %s for VPN netId %u", physicalInterface.c_str(),
 108                   vpnNetId);
 109             return ret;
 110         }
 111     }
 112     return 0;
 113 }
 114
 115 int NetworkController::DelegateImpl::addFallthrough(const std::string& physicalInterface,
 116                                                     Permission permission) {
 117     return modifyFallthrough(physicalInterface, permission, true);
 118 }
 119
 120 int NetworkController::DelegateImpl::removeFallthrough(const std::string& physicalInterface,
 121                                                        Permission permission) {
 122     return modifyFallthrough(physicalInterface, permission, false);
 123 }
 124
 125 int NetworkController::DelegateImpl::modifyFallthrough(const std::string& physicalInterface,
 126                                                        Permission permission, bool add) {
 127     for (const auto& entry : mNetworkController->mNetworks) {
 128         if (entry.second->getType() == Network::VIRTUAL) {
 129             if (int ret = modifyFallthrough(entry.first, physicalInterface, permission, add)) {
 130                 return ret;
 131             }
 132         }
 133     }
 134     return 0;
 135 }
 136
 137 NetworkController::NetworkController() :
 138         mDelegateImpl(new NetworkController::DelegateImpl(this)), mDefaultNetId(NETID_UNSET),
 139         mProtectableUsers({AID_VPN}) {
 140     mNetworks[LOCAL_NET_ID] = new LocalNetwork(LOCAL_NET_ID);
 141     mNetworks[DUMMY_NET_ID] = new DummyNetwork(DUMMY_NET_ID);
 142 }
 143
 144 unsigned NetworkController::getDefaultNetwork() const {
 145     android::RWLock::AutoRLock lock(mRWLock);
 146     return mDefaultNetId;
 147 }
 148
 149 int NetworkController::setDefaultNetwork(unsigned netId) {
 150     android::RWLock::AutoWLock lock(mRWLock);
 151
 152     if (netId == mDefaultNetId) {
 153         return 0;
 154     }
 155
 156     if (netId != NETID_UNSET) {
 157         Network* network = getNetworkLocked(netId);
 158         if (!network) {
 159             ALOGE("no such netId %u", netId);
 160             return -ENONET;
 161         }
 162         if (network->getType() != Network::PHYSICAL) {
 163             ALOGE("cannot set default to non-physical network with netId %u", netId);
 164             return -EINVAL;
 165         }
 166         if (int ret = static_cast<PhysicalNetwork*>(network)->addAsDefault()) {
 167             return ret;
 168         }
 169     }
 170
 171     if (mDefaultNetId != NETID_UNSET) {
 172         Network* network = getNetworkLocked(mDefaultNetId);
 173         if (!network || network->getType() != Network::PHYSICAL) {
 174             ALOGE("cannot find previously set default network with netId %u", mDefaultNetId);
 175             return -ESRCH;
 176         }
 177         if (int ret = static_cast<PhysicalNetwork*>(network)->removeAsDefault()) {
 178             return ret;
 179         }
 180     }
 181
 182     mDefaultNetId = netId;
 183     return 0;
 184 }
 185
 186 uint32_t NetworkController::getNetworkForDns(unsigned* netId, uid_t uid) const {
 187     android::RWLock::AutoRLock lock(mRWLock);
 188     Fwmark fwmark;
 189     fwmark.protectedFromVpn = true;
 190     fwmark.permission = PERMISSION_SYSTEM;
 191     if (checkUserNetworkAccessLocked(uid, *netId) == 0) {
 192         // If a non-zero NetId was explicitly specified, and the user has permission for that
 193         // network, use that network's DNS servers. Do not fall through to the default network even
 194         // if the explicitly selected network is a split tunnel VPN: the explicitlySelected bit
 195         // ensures that the VPN fallthrough rule does not match.
 196         fwmark.explicitlySelected = true;
 197
 198         // If the network is a VPN and it doesn't have DNS servers, use the default network's DNS
 199         // servers (through the default network). Otherwise, the query is guaranteed to fail.
 200         // http://b/29498052
 201         Network *network = getNetworkLocked(*netId);
 202         if (network && network->getType() == Network::VIRTUAL &&
 203                 !static_cast<VirtualNetwork *>(network)->getHasDns()) {
 204             *netId = mDefaultNetId;
 205         }
 206     } else {
 207         // If the user is subject to a VPN and the VPN provides DNS servers, use those servers
 208         // (possibly falling through to the default network if the VPN doesn't provide a route to
 209         // them). Otherwise, use the default network's DNS servers.
 210         VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid);
 211         if (virtualNetwork && virtualNetwork->getHasDns()) {
 212             *netId = virtualNetwork->getNetId();
 213         } else {
 214             // TODO: return an error instead of silently doing the DNS lookup on the wrong network.
 215             // http://b/27560555
 216             *netId = mDefaultNetId;
 217         }
 218     }
 219     fwmark.netId = *netId;
 220     return fwmark.intValue;
 221 }
 222
 223 // Returns the NetId that a given UID would use if no network is explicitly selected. Specifically,
 224 // the VPN that applies to the UID if any; otherwise, the default network.
 225 unsigned NetworkController::getNetworkForUser(uid_t uid) const {
 226     android::RWLock::AutoRLock lock(mRWLock);
 227     if (VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid)) {
 228         return virtualNetwork->getNetId();
 229     }
 230     return mDefaultNetId;
 231 }
 232
 233 // Returns the NetId that will be set when a socket connect()s. This is the bypassable VPN that
 234 // applies to the user if any; otherwise, the default network.
 235 //
 236 // In general, we prefer to always set the default network's NetId in connect(), so that if the VPN
 237 // is a split-tunnel and disappears later, the socket continues working (since the default network's
 238 // NetId is still valid). Secure VPNs will correctly grab the socket's traffic since they have a
 239 // high-priority routing rule that doesn't care what NetId the socket has.
 240 //
 241 // But bypassable VPNs have a very low priority rule, so we need to mark the socket with the
 242 // bypassable VPN's NetId if we expect it to get any traffic at all. If the bypassable VPN is a
 243 // split-tunnel, that's okay, because we have fallthrough rules that will direct the fallthrough
 244 // traffic to the default network. But it does mean that if the bypassable VPN goes away (and thus
 245 // the fallthrough rules also go away), the socket that used to fallthrough to the default network
 246 // will stop working.
 247 unsigned NetworkController::getNetworkForConnect(uid_t uid) const {
 248     android::RWLock::AutoRLock lock(mRWLock);
 249     VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid);
 250     if (virtualNetwork && !virtualNetwork->isSecure()) {
 251         return virtualNetwork->getNetId();
 252     }
 253     return mDefaultNetId;
 254 }
 255
 256 void NetworkController::getNetworkContext(
 257         unsigned netId, uid_t uid, struct android_net_context* netcontext) const {
 258     struct android_net_context nc = {
 259             .app_netid = netId,
 260             .app_mark = MARK_UNSET,
 261             .dns_netid = netId,
 262             .dns_mark = MARK_UNSET,
 263             .uid = uid,
 264     };
 265
 266     // |netId| comes directly (via dnsproxyd) from the value returned by netIdForResolv() in the
 267     // client process. This value is nonzero iff.:
 268     //
 269     // 1. The app specified a netid/nethandle to a DNS resolution method such as:
 270     //        - [Java] android.net.Network#getAllByName()
 271     //        - [C/++] android_getaddrinfofornetwork()
 272     // 2. The app specified a netid/nethandle to be used as a process default via:
 273     //        - [Java] android.net.ConnectivityManager#bindProcessToNetwork()
 274     //        - [C/++] android_setprocnetwork()
 275     // 3. The app called android.net.ConnectivityManager#startUsingNetworkFeature().
 276     //
 277     // In all these cases (with the possible exception of #3), the right thing to do is to treat
 278     // such cases as explicitlySelected.
 279     const bool explicitlySelected = (nc.app_netid != NETID_UNSET);
 280     if (!explicitlySelected) {
 281         nc.app_netid = getNetworkForConnect(uid);
 282     }
 283
 284     Fwmark fwmark;
 285     fwmark.netId = nc.app_netid;
 286     fwmark.explicitlySelected = explicitlySelected;
 287     fwmark.protectedFromVpn = canProtect(uid);
 288     fwmark.permission = getPermissionForUser(uid);
 289     nc.app_mark = fwmark.intValue;
 290
 291     nc.dns_mark = getNetworkForDns(&(nc.dns_netid), uid);
 292
 293     if (netcontext) {
 294         *netcontext = nc;
 295     }
 296 }
 297
 298 unsigned NetworkController::getNetworkForInterface(const char* interface) const {
 299     android::RWLock::AutoRLock lock(mRWLock);
 300     for (const auto& entry : mNetworks) {
 301         if (entry.second->hasInterface(interface)) {
 302             return entry.first;
 303         }
 304     }
 305     return NETID_UNSET;
 306 }
 307
 308 bool NetworkController::isVirtualNetwork(unsigned netId) const {
 309     android::RWLock::AutoRLock lock(mRWLock);
 310     Network* network = getNetworkLocked(netId);
 311     return network && network->getType() == Network::VIRTUAL;
 312 }
 313
 314 int NetworkController::createPhysicalNetwork(unsigned netId, Permission permission) {
 315     if (!((MIN_NET_ID <= netId && netId <= MAX_NET_ID) ||
 316           (MIN_OEM_ID <= netId && netId <= MAX_OEM_ID))) {
 317         ALOGE("invalid netId %u", netId);
 318         return -EINVAL;
 319     }
 320
 321     if (isValidNetwork(netId)) {
 322         ALOGE("duplicate netId %u", netId);
 323         return -EEXIST;
 324     }
 325
 326     PhysicalNetwork* physicalNetwork = new PhysicalNetwork(netId, mDelegateImpl);
 327     if (int ret = physicalNetwork->setPermission(permission)) {
 328         ALOGE("inconceivable! setPermission cannot fail on an empty network");
 329         delete physicalNetwork;
 330         return ret;
 331     }
 332
 333     android::RWLock::AutoWLock lock(mRWLock);
 334     mNetworks[netId] = physicalNetwork;
 335     return 0;
 336 }
 337
 338 int NetworkController::createVirtualNetwork(unsigned netId, bool hasDns, bool secure) {
 339     if (!(MIN_NET_ID <= netId && netId <= MAX_NET_ID)) {
 340         ALOGE("invalid netId %u", netId);
 341         return -EINVAL;
 342     }
 343
 344     if (isValidNetwork(netId)) {
 345         ALOGE("duplicate netId %u", netId);
 346         return -EEXIST;
 347     }
 348
 349     android::RWLock::AutoWLock lock(mRWLock);
 350     if (int ret = modifyFallthroughLocked(netId, true)) {
 351         return ret;
 352     }
 353     mNetworks[netId] = new VirtualNetwork(netId, hasDns, secure);
 354     return 0;
 355 }
 356
 357 int NetworkController::destroyNetwork(unsigned netId) {
 358     if (netId == LOCAL_NET_ID) {
 359         ALOGE("cannot destroy local network");
 360         return -EINVAL;
 361     }
 362     if (!isValidNetwork(netId)) {
 363         ALOGE("no such netId %u", netId);
 364         return -ENONET;
 365     }
 366
 367     // TODO: ioctl(SIOCKILLADDR, ...) to kill all sockets on the old network.
 368
 369     android::RWLock::AutoWLock lock(mRWLock);
 370     Network* network = getNetworkLocked(netId);
 371
 372     // If we fail to destroy a network, things will get stuck badly. Therefore, unlike most of the
 373     // other network code, ignore failures and attempt to clear out as much state as possible, even
 374     // if we hit an error on the way. Return the first error that we see.
 375     int ret = network->clearInterfaces();
 376
 377     if (mDefaultNetId == netId) {
 378         if (int err = static_cast<PhysicalNetwork*>(network)->removeAsDefault()) {
 379             ALOGE("inconceivable! removeAsDefault cannot fail on an empty network");
 380             if (!ret) {
 381                 ret = err;
 382             }
 383         }
 384         mDefaultNetId = NETID_UNSET;
 385     } else if (network->getType() == Network::VIRTUAL) {
 386         if (int err = modifyFallthroughLocked(netId, false)) {
 387             if (!ret) {
 388                 ret = err;
 389             }
 390         }
 391     }
 392     mNetworks.erase(netId);
 393     delete network;
 394     _resolv_delete_cache_for_net(netId);
 395     return ret;
 396 }
 397
 398 int NetworkController::addInterfaceToNetwork(unsigned netId, const char* interface) {
 399     if (!isValidNetwork(netId)) {
 400         ALOGE("no such netId %u", netId);
 401         return -ENONET;
 402     }
 403
 404     unsigned existingNetId = getNetworkForInterface(interface);
 405     if (existingNetId != NETID_UNSET && existingNetId != netId) {
 406         ALOGE("interface %s already assigned to netId %u", interface, existingNetId);
 407         return -EBUSY;
 408     }
 409
 410     android::RWLock::AutoWLock lock(mRWLock);
 411     return getNetworkLocked(netId)->addInterface(interface);
 412 }
 413
 414 int NetworkController::removeInterfaceFromNetwork(unsigned netId, const char* interface) {
 415     if (!isValidNetwork(netId)) {
 416         ALOGE("no such netId %u", netId);
 417         return -ENONET;
 418     }
 419
 420     android::RWLock::AutoWLock lock(mRWLock);
 421     return getNetworkLocked(netId)->removeInterface(interface);
 422 }
 423
 424 Permission NetworkController::getPermissionForUser(uid_t uid) const {
 425     android::RWLock::AutoRLock lock(mRWLock);
 426     return getPermissionForUserLocked(uid);
 427 }
 428
 429 void NetworkController::setPermissionForUsers(Permission permission,
 430                                               const std::vector<uid_t>& uids) {
 431     android::RWLock::AutoWLock lock(mRWLock);
 432     for (uid_t uid : uids) {
 433         mUsers[uid] = permission;
 434     }
 435 }
 436
 437 int NetworkController::checkUserNetworkAccess(uid_t uid, unsigned netId) const {
 438     android::RWLock::AutoRLock lock(mRWLock);
 439     return checkUserNetworkAccessLocked(uid, netId);
 440 }
 441
 442 int NetworkController::setPermissionForNetworks(Permission permission,
 443                                                 const std::vector<unsigned>& netIds) {
 444     android::RWLock::AutoWLock lock(mRWLock);
 445     for (unsigned netId : netIds) {
 446         Network* network = getNetworkLocked(netId);
 447         if (!network) {
 448             ALOGE("no such netId %u", netId);
 449             return -ENONET;
 450         }
 451         if (network->getType() != Network::PHYSICAL) {
 452             ALOGE("cannot set permissions on non-physical network with netId %u", netId);
 453             return -EINVAL;
 454         }
 455
 456         if (int ret = static_cast<PhysicalNetwork*>(network)->setPermission(permission)) {
 457             return ret;
 458         }
 459     }
 460     return 0;
 461 }
 462
 463 int NetworkController::addUsersToNetwork(unsigned netId, const UidRanges& uidRanges) {
 464     android::RWLock::AutoWLock lock(mRWLock);
 465     Network* network = getNetworkLocked(netId);
 466     if (!network) {
 467         ALOGE("no such netId %u", netId);
 468         return -ENONET;
 469     }
 470     if (network->getType() != Network::VIRTUAL) {
 471         ALOGE("cannot add users to non-virtual network with netId %u", netId);
 472         return -EINVAL;
 473     }
 474     if (int ret = static_cast<VirtualNetwork*>(network)->addUsers(uidRanges, mProtectableUsers)) {
 475         return ret;
 476     }
 477     return 0;
 478 }
 479
 480 int NetworkController::removeUsersFromNetwork(unsigned netId, const UidRanges& uidRanges) {
 481     android::RWLock::AutoWLock lock(mRWLock);
 482     Network* network = getNetworkLocked(netId);
 483     if (!network) {
 484         ALOGE("no such netId %u", netId);
 485         return -ENONET;
 486     }
 487     if (network->getType() != Network::VIRTUAL) {
 488         ALOGE("cannot remove users from non-virtual network with netId %u", netId);
 489         return -EINVAL;
 490     }
 491     if (int ret = static_cast<VirtualNetwork*>(network)->removeUsers(uidRanges,
 492                                                                      mProtectableUsers)) {
 493         return ret;
 494     }
 495     return 0;
 496 }
 497
 498 int NetworkController::addRoute(unsigned netId, const char* interface, const char* destination,
 499                                 const char* nexthop, bool legacy, uid_t uid) {
 500     return modifyRoute(netId, interface, destination, nexthop, true, legacy, uid);
 501 }
 502
 503 int NetworkController::removeRoute(unsigned netId, const char* interface, const char* destination,
 504                                    const char* nexthop, bool legacy, uid_t uid) {
 505     return modifyRoute(netId, interface, destination, nexthop, false, legacy, uid);
 506 }
 507
 508 bool NetworkController::canProtect(uid_t uid) const {
 509     android::RWLock::AutoRLock lock(mRWLock);
 510     return ((getPermissionForUserLocked(uid) & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) ||
 511            mProtectableUsers.find(uid) != mProtectableUsers.end();
 512 }
 513
 514 void NetworkController::allowProtect(const std::vector<uid_t>& uids) {
 515     android::RWLock::AutoWLock lock(mRWLock);
 516     mProtectableUsers.insert(uids.begin(), uids.end());
 517 }
 518
 519 void NetworkController::denyProtect(const std::vector<uid_t>& uids) {
 520     android::RWLock::AutoWLock lock(mRWLock);
 521     for (uid_t uid : uids) {
 522         mProtectableUsers.erase(uid);
 523     }
 524 }
 525
 526 void NetworkController::dump(DumpWriter& dw) {
 527     android::RWLock::AutoRLock lock(mRWLock);
 528
 529     dw.incIndent();
 530     dw.println("NetworkController");
 531
 532     dw.incIndent();
 533     dw.println("Default network: %u", mDefaultNetId);
 534
 535     dw.blankline();
 536     dw.println("Networks:");
 537     dw.incIndent();
 538     for (const auto& i : mNetworks) {
 539         Network* network = i.second;
 540         dw.println(network->toString().c_str());
 541         if (network->getType() == Network::PHYSICAL) {
 542             dw.incIndent();
 543             Permission permission = reinterpret_cast<PhysicalNetwork*>(network)->getPermission();
 544             dw.println("Required permission: %s", permissionToName(permission));
 545             dw.decIndent();
 546         }
 547         android::net::gCtls->resolverCtrl.dump(dw, i.first);
 548         dw.blankline();
 549     }
 550     dw.decIndent();
 551
 552     dw.decIndent();
 553
 554     dw.decIndent();
 555 }
 556
 557 bool NetworkController::isValidNetwork(unsigned netId) const {
 558     android::RWLock::AutoRLock lock(mRWLock);
 559     return getNetworkLocked(netId);
 560 }
 561
 562 Network* NetworkController::getNetworkLocked(unsigned netId) const {
 563     auto iter = mNetworks.find(netId);
 564     return iter == mNetworks.end() ? NULL : iter->second;
 565 }
 566
 567 VirtualNetwork* NetworkController::getVirtualNetworkForUserLocked(uid_t uid) const {
 568     for (const auto& entry : mNetworks) {
 569         if (entry.second->getType() == Network::VIRTUAL) {
 570             VirtualNetwork* virtualNetwork = static_cast<VirtualNetwork*>(entry.second);
 571             if (virtualNetwork->appliesToUser(uid)) {
 572                 return virtualNetwork;
 573             }
 574         }
 575     }
 576     return NULL;
 577 }
 578
 579 Permission NetworkController::getPermissionForUserLocked(uid_t uid) const {
 580     auto iter = mUsers.find(uid);
 581     if (iter != mUsers.end()) {
 582         return iter->second;
 583     }
 584     return uid < FIRST_APPLICATION_UID ? PERMISSION_SYSTEM : PERMISSION_NONE;
 585 }
 586
 587 int NetworkController::checkUserNetworkAccessLocked(uid_t uid, unsigned netId) const {
 588     Network* network = getNetworkLocked(netId);
 589     if (!network) {
 590         return -ENONET;
 591     }
 592
 593     // If uid is INVALID_UID, this likely means that we were unable to retrieve the UID of the peer
 594     // (using SO_PEERCRED). Be safe and deny access to the network, even if it's valid.
 595     if (uid == INVALID_UID) {
 596         return -EREMOTEIO;
 597     }
 598     Permission userPermission = getPermissionForUserLocked(uid);
 599     if ((userPermission & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) {
 600         return 0;
 601     }
 602     if (network->getType() == Network::VIRTUAL) {
 603         return static_cast<VirtualNetwork*>(network)->appliesToUser(uid) ? 0 : -EPERM;
 604     }
 605     VirtualNetwork* virtualNetwork = getVirtualNetworkForUserLocked(uid);
 606     if (virtualNetwork && virtualNetwork->isSecure() &&
 607             mProtectableUsers.find(uid) == mProtectableUsers.end()) {
 608         return -EPERM;
 609     }
 610     Permission networkPermission = static_cast<PhysicalNetwork*>(network)->getPermission();
 611     return ((userPermission & networkPermission) == networkPermission) ? 0 : -EACCES;
 612 }
 613
 614 int NetworkController::modifyRoute(unsigned netId, const char* interface, const char* destination,
 615                                    const char* nexthop, bool add, bool legacy, uid_t uid) {
 616     if (!isValidNetwork(netId)) {
 617         ALOGE("no such netId %u", netId);
 618         return -ENONET;
 619     }
 620     unsigned existingNetId = getNetworkForInterface(interface);
 621     if (existingNetId == NETID_UNSET) {
 622         ALOGE("interface %s not assigned to any netId", interface);
 623         return -ENODEV;
 624     }
 625     if (existingNetId != netId) {
 626         ALOGE("interface %s assigned to netId %u, not %u", interface, existingNetId, netId);
 627         return -ENOENT;
 628     }
 629
 630     RouteController::TableType tableType;
 631     if (netId == LOCAL_NET_ID) {
 632         tableType = RouteController::LOCAL_NETWORK;
 633     } else if (legacy) {
 634         if ((getPermissionForUser(uid) & PERMISSION_SYSTEM) == PERMISSION_SYSTEM) {
 635             tableType = RouteController::LEGACY_SYSTEM;
 636         } else {
 637             tableType = RouteController::LEGACY_NETWORK;
 638         }
 639     } else {
 640         tableType = RouteController::INTERFACE;
 641     }
 642
 643     return add ? RouteController::addRoute(interface, destination, nexthop, tableType) :
 644                  RouteController::removeRoute(interface, destination, nexthop, tableType);
 645 }
 646
 647 int NetworkController::modifyFallthroughLocked(unsigned vpnNetId, bool add) {
 648     if (mDefaultNetId == NETID_UNSET) {
 649         return 0;
 650     }
 651     Network* network = getNetworkLocked(mDefaultNetId);
 652     if (!network) {
 653         ALOGE("cannot find previously set default network with netId %u", mDefaultNetId);
 654         return -ESRCH;
 655     }
 656     if (network->getType() != Network::PHYSICAL) {
 657         ALOGE("inconceivable! default network must be a physical network");
 658         return -EINVAL;
 659     }
 660     Permission permission = static_cast<PhysicalNetwork*>(network)->getPermission();
 661     for (const auto& physicalInterface : network->getInterfaces()) {
 662         if (int ret = mDelegateImpl->modifyFallthrough(vpnNetId, physicalInterface, permission,
 663                                                        add)) {
 664             return ret;
 665         }
 666     }
 667     return 0;
 668 }
 669
 670 int NetworkController::setMetricsReportingLevel(const int level) {
 671     if (level < 0 || level > 1) {
 672         ALOGE("Invalid reporting level %d", level);
 673         return -EINVAL;
 674     }
 675     mReportingLevel = level;
 676     return 0;
 677 }
 678
 679 int NetworkController::getMetricsReportingLevel() const {
 680     return mReportingLevel;
 681 }