Add a binder IPC to close socket connections.

[android-x86/system-netd.git] / server / NetlinkHandler.cpp

diff --git a/server/NetlinkHandler.cpp b/server/NetlinkHandler.cpp
index 6c81c18..ed21bff 100644 (file)
--- a/server/NetlinkHandler.cpp
+++ b/server/NetlinkHandler.cpp
@@ -29,6 +29,7 @@
 #include "NetlinkHandler.h"
 #include "NetlinkManager.h"
 #include "ResponseCode.h"
+#include "SockDiag.h"
 
 static const char *kUpdated = "updated";
 static const char *kRemoved = "removed";
@@ -58,44 +59,55 @@ void NetlinkHandler::onEvent(NetlinkEvent *evt) {
     }
 
     if (!strcmp(subsys, "net")) {
-        int action = evt->getAction();
+        NetlinkEvent::Action action = evt->getAction();
         const char *iface = evt->findParam("INTERFACE");
 
-        if (action == evt->NlActionAdd) {
+        if (action == NetlinkEvent::Action::kAdd) {
             notifyInterfaceAdded(iface);
-        } else if (action == evt->NlActionRemove) {
+        } else if (action == NetlinkEvent::Action::kRemove) {
             notifyInterfaceRemoved(iface);
-        } else if (action == evt->NlActionChange) {
+        } else if (action == NetlinkEvent::Action::kChange) {
             evt->dump();
             notifyInterfaceChanged("nana", true);
-        } else if (action == evt->NlActionLinkUp) {
+        } else if (action == NetlinkEvent::Action::kLinkUp) {
             notifyInterfaceLinkChanged(iface, true);
-        } else if (action == evt->NlActionLinkDown) {
+        } else if (action == NetlinkEvent::Action::kLinkDown) {
             notifyInterfaceLinkChanged(iface, false);
-        } else if (action == evt->NlActionAddressUpdated ||
-                   action == evt->NlActionAddressRemoved) {
+        } else if (action == NetlinkEvent::Action::kAddressUpdated ||
+                   action == NetlinkEvent::Action::kAddressRemoved) {
             const char *address = evt->findParam("ADDRESS");
             const char *flags = evt->findParam("FLAGS");
             const char *scope = evt->findParam("SCOPE");
-            if (action == evt->NlActionAddressRemoved && iface && address) {
-                int resetMask = strchr(address, ':') ? RESET_IPV6_ADDRESSES : RESET_IPV4_ADDRESSES;
-                resetMask |= RESET_IGNORE_INTERFACE_ADDRESS;
-                if (int ret = ifc_reset_connections(iface, resetMask)) {
-                    ALOGE("ifc_reset_connections failed on iface %s for address %s (%s)", iface,
-                          address, strerror(ret));
+            if (action == NetlinkEvent::Action::kAddressRemoved && iface && address) {
+                // Note: if this interface was deleted, iface is "" and we don't notify.
+                SockDiag sd;
+                if (sd.open()) {
+                    char addrstr[INET6_ADDRSTRLEN];
+                    strncpy(addrstr, address, sizeof(addrstr));
+                    char *slash = strchr(addrstr, '/');
+                    if (slash) {
+                        *slash = '\0';
+                    }
+
+                    int ret = sd.destroySockets(addrstr);
+                    if (ret < 0) {
+                        ALOGE("Error destroying sockets: %s", strerror(ret));
+                    }
+                } else {
+                    ALOGE("Error opening NETLINK_SOCK_DIAG socket: %s", strerror(errno));
                 }
             }
-            if (iface && flags && scope) {
+            if (iface && iface[0] && address && flags && scope) {
                 notifyAddressChanged(action, address, iface, flags, scope);
             }
-        } else if (action == evt->NlActionRdnss) {
+        } else if (action == NetlinkEvent::Action::kRdnss) {
             const char *lifetime = evt->findParam("LIFETIME");
             const char *servers = evt->findParam("SERVERS");
             if (lifetime && servers) {
                 notifyInterfaceDnsServers(iface, lifetime, servers);
             }
-        } else if (action == evt->NlActionRouteUpdated ||
-                   action == evt->NlActionRouteRemoved) {
+        } else if (action == NetlinkEvent::Action::kRouteUpdated ||
+                   action == NetlinkEvent::Action::kRouteRemoved) {
             const char *route = evt->findParam("ROUTE");
             const char *gateway = evt->findParam("GATEWAY");
             const char *iface = evt->findParam("INTERFACE");
@@ -109,12 +121,19 @@ void NetlinkHandler::onEvent(NetlinkEvent *evt) {
         const char *iface = evt->findParam("INTERFACE");
         notifyQuotaLimitReached(alertName, iface);
 
+    } else if (!strcmp(subsys, "strict")) {
+        const char *uid = evt->findParam("UID");
+        const char *hex = evt->findParam("HEX");
+        notifyStrictCleartext(uid, hex);
+
     } else if (!strcmp(subsys, "xt_idletimer")) {
         const char *label = evt->findParam("INTERFACE");
         const char *state = evt->findParam("STATE");
         const char *timestamp = evt->findParam("TIME_NS");
+        const char *uid = evt->findParam("UID");
         if (state)
-            notifyInterfaceClassActivity(label, !strcmp("active", state), timestamp);
+            notifyInterfaceClassActivity(label, !strcmp("active", state),
+                                         timestamp, uid);
 
 #if !LOG_NDEBUG
     } else if (strcmp(subsys, "platform") && strcmp(subsys, "backlight")) {
@@ -160,21 +179,26 @@ void NetlinkHandler::notifyQuotaLimitReached(const char *name, const char *iface
 }
 
 void NetlinkHandler::notifyInterfaceClassActivity(const char *name,
-                                                  bool isActive, const char *timestamp) {
+                                                  bool isActive,
+                                                  const char *timestamp,
+                                                  const char *uid) {
     if (timestamp == NULL)
         notify(ResponseCode::InterfaceClassActivity,
            "IfaceClass %s %s", isActive ? "active" : "idle", name);
+    else if (uid != NULL && isActive)
+        notify(ResponseCode::InterfaceClassActivity,
+           "IfaceClass active %s %s %s", name, timestamp, uid);
     else
         notify(ResponseCode::InterfaceClassActivity,
            "IfaceClass %s %s %s", isActive ? "active" : "idle", name, timestamp);
 }
 
-void NetlinkHandler::notifyAddressChanged(int action, const char *addr,
+void NetlinkHandler::notifyAddressChanged(NetlinkEvent::Action action, const char *addr,
                                           const char *iface, const char *flags,
                                           const char *scope) {
     notify(ResponseCode::InterfaceAddressChange,
            "Address %s %s %s %s %s",
-           (action == NetlinkEvent::NlActionAddressUpdated) ? kUpdated : kRemoved,
+           (action == NetlinkEvent::Action::kAddressUpdated) ? kUpdated : kRemoved,
            addr, iface, flags, scope);
 }
 
@@ -185,14 +209,18 @@ void NetlinkHandler::notifyInterfaceDnsServers(const char *iface,
            iface, lifetime, servers);
 }
 
-void NetlinkHandler::notifyRouteChange(int action, const char *route,
+void NetlinkHandler::notifyRouteChange(NetlinkEvent::Action action, const char *route,
                                        const char *gateway, const char *iface) {
     notify(ResponseCode::RouteChange,
            "Route %s %s%s%s%s%s",
-           (action == NetlinkEvent::NlActionRouteUpdated) ? kUpdated : kRemoved,
+           (action == NetlinkEvent::Action::kRouteUpdated) ? kUpdated : kRemoved,
            route,
            *gateway ? " via " : "",
            gateway,
            *iface ? " dev " : "",
            iface);
 }
+
+void NetlinkHandler::notifyStrictCleartext(const char* uid, const char* hex) {
+    notify(ResponseCode::StrictCleartext, "%s %s", uid, hex);
+}