Merge tag 'LA.UM.5.5.r1-00900-8x96.0' of git://codeaurora.org/platfor…

…m/system/netd into cm-14.0

"LA.UM.5.5.r1-00900-8x96.0"

Change-Id: Idfef34bc8e563459a5194ef63a7b6715ebfdb4c5

server/Android.mk

@@ -123,6 +123,12 @@ ifeq ($(BOARD_HAS_QCOM_WLAN), true)
 endif
 endif
 
+ifdef WPA_SUPPLICANT_VERSION
+  LOCAL_CFLAGS += -DLIBWPA_CLIENT_EXISTS
+  LOCAL_SHARED_LIBRARIES += libwpa_client
+  LOCAL_C_INCLUDES += external/wpa_supplicant_8/src/common
+endif
+
 include $(BUILD_EXECUTABLE)
 
 

server/BandwidthController.cpp

@@ -296,6 +296,9 @@ int BandwidthController::enableBandwidthControl(bool force) {
     globalAlertTetherCount = 0;
     sharedQuotaBytes = sharedAlertBytes = 0;
 
+    restrictAppUidsOnData.clear();
+    restrictAppUidsOnWlan.clear();
+
     flushCleanTables(false);
     std::string commands = android::base::Join(IPT_BASIC_ACCOUNTING_COMMANDS, '\n');
     return iptablesRestoreFunction(V4V6, commands);
@@ -380,6 +383,116 @@ int BandwidthController::manipulateNiceApps(int numUids, char *appStrUids[], Spe
     return manipulateSpecialApps(numUids, appStrUids, "bw_happy_box", IptJumpReturn, appOp);
 }
 
+int BandwidthController::manipulateRestrictAppsOnData(int numUids, char *appUids[],
+        RestrictAppOp appOp) {
+    int ret = manipulateRestrictApps(numUids, appUids, "INPUT -i rmnet_data0",
+            restrictAppUidsOnData, appOp);
+    if (ret != 0) {
+        return ret;
+    } else {
+        return manipulateRestrictApps(numUids, appUids, "OUTPUT -o rmnet_data0",
+                restrictAppUidsOnData, appOp);
+    }
+}
+
+int BandwidthController::manipulateRestrictAppsOnWlan(int numUids, char *appUids[],
+        RestrictAppOp appOp) {
+    int ret = manipulateRestrictApps(numUids, appUids,"INPUT -i wlan0",
+            restrictAppUidsOnWlan, appOp);
+    if (ret != 0) {
+        return ret;
+    } else {
+        return manipulateRestrictApps(numUids, appUids,"OUTPUT -o wlan0",
+                restrictAppUidsOnWlan, appOp);
+    }
+}
+int BandwidthController::addRestrictAppsOnData(int numUids, char *appUids[]) {
+    return manipulateRestrictAppsOnData(numUids, appUids, RestrictAppOpAdd);
+}
+
+int BandwidthController::removeRestrictAppsOnData(int numUids, char *appUids[]) {
+    return manipulateRestrictAppsOnData(numUids, appUids, RestrictAppOpRemove);
+}
+
+int BandwidthController::addRestrictAppsOnWlan(int numUids, char *appUids[]) {
+    return manipulateRestrictAppsOnWlan(numUids, appUids, RestrictAppOpAdd);
+}
+
+int BandwidthController::removeRestrictAppsOnWlan(int numUids, char *appUids[]) {
+    return manipulateRestrictAppsOnWlan(numUids, appUids, RestrictAppOpRemove);
+}
+
+
+int BandwidthController::manipulateRestrictApps(int numUids, char *appStrUids[],
+                                               const char *chain,
+                                               std::list<int /*appUid*/> &restrictAppUids,
+                                               RestrictAppOp appOp) {
+    int uidNum;
+    const char *failLogTemplate;
+    IptOp op;
+    int appUids[numUids];
+    std::string iptCmd;
+    std::list<int /*uid*/>::iterator it;
+    bool isOutputChain = !strncmp(chain, "OUTPUT", strlen("OUTPUT"));
+    switch (appOp) {
+        case RestrictAppOpAdd:
+            op = IptOpInsert;
+            failLogTemplate = "Failed to add app uid %s(%d) to %s.";
+            break;
+        case RestrictAppOpRemove:
+            op = IptOpDelete;
+            failLogTemplate = "Failed to delete app uid %s(%d) from %s box.";
+            break;
+        default:
+            ALOGE("Unexpected app Op %d", appOp);
+            return -1;
+    }
+    for (uidNum = 0; uidNum < numUids; uidNum++) {
+        char *end;
+        appUids[uidNum] = strtoul(appStrUids[uidNum], &end, 0);
+        if (*end || !*appStrUids[uidNum]) {
+            ALOGE(failLogTemplate, appStrUids[uidNum], appUids[uidNum], chain);
+            goto fail_parse;
+        }
+    }
+
+    for (uidNum = 0; uidNum < numUids; uidNum++) {
+        int uid = appUids[uidNum];
+        for (it = restrictAppUids.begin(); it != restrictAppUids.end(); it++) {
+            if (*it == uid)
+                break;
+        }
+        bool found = (it != restrictAppUids.end());
+
+        if (appOp == RestrictAppOpRemove) {
+            if (!found) {
+                ALOGE("No such appUid %d to remove", uid);
+                return -1;
+            }
+            restrictAppUids.erase(it);
+        } else {
+            if (found && !isOutputChain) {
+                ALOGE("appUid %d exists already", uid);
+                return -1;
+            }
+            restrictAppUids.push_front(uid);
+        }
+
+        iptCmd = makeIptablesSpecialAppCmd(op, uid, chain);
+        if (runIpxtablesCmd(iptCmd.c_str(), IptJumpReject)) {
+            ALOGE(failLogTemplate, appStrUids[uidNum], uid, chain);
+            goto fail_with_uidNum;
+        }
+    }
+    return 0;
+
+fail_with_uidNum:
+    /* Try to remove the uid that failed in any case*/
+    iptCmd = makeIptablesSpecialAppCmd(IptOpDelete, appUids[uidNum], chain);
+    runIpxtablesCmd(iptCmd.c_str(), IptJumpReject);
+fail_parse:
+    return -1;
+}
 
 int BandwidthController::manipulateSpecialApps(int numUids, char *appStrUids[],
                                                const char *chain,

server/BandwidthController.h

@@ -86,6 +86,12 @@ class BandwidthController {
     int setInterfaceAlert(const char *iface, int64_t bytes);
     int removeInterfaceAlert(const char *iface);
 
+    int addRestrictAppsOnData(int numUids, char *appUids[]);
+    int removeRestrictAppsOnData(int numUids, char *appUids[]);
+
+    int addRestrictAppsOnWlan(int numUids, char *appUids[]);
+    int removeRestrictAppsOnWlan(int numUids, char *appUids[]);
+
     /*
      * For single pair of ifaces, stats should have ifaceIn and ifaceOut initialized.
      * For all pairs, stats should have ifaceIn=ifaceOut="".
@@ -116,6 +122,7 @@ class BandwidthController {
     enum IptOp { IptOpInsert, IptOpReplace, IptOpDelete, IptOpAppend };
     enum IptJumpOp { IptJumpReject, IptJumpReturn, IptJumpNoAdd };
     enum SpecialAppOp { SpecialAppOpAdd, SpecialAppOpRemove };
+    enum RestrictAppOp { RestrictAppOpAdd, RestrictAppOpRemove};
     enum QuotaType { QuotaUnique, QuotaShared };
     enum RunCmdErrHandling { RunCmdFailureBad, RunCmdFailureOk };
 #if LOG_NDEBUG
@@ -130,6 +137,13 @@ class BandwidthController {
     int manipulateNaughtyApps(int numUids, char *appStrUids[], SpecialAppOp appOp);
     int manipulateNiceApps(int numUids, char *appStrUids[], SpecialAppOp appOp);
 
+    int manipulateRestrictAppsOnData(int numUids, char* appStrUids[], RestrictAppOp appOp);
+    int manipulateRestrictAppsOnWlan(int numUids, char* appStrUids[], RestrictAppOp appOp);
+    int manipulateRestrictApps(int numUids, char *appStrUids[],
+                               const char *chain,
+                               std::list<int /*appUid*/> &restrictAppUids,
+                               RestrictAppOp appOp);
+
     int prepCostlyIface(const char *ifn, QuotaType quotaType);
     int cleanupCostlyIface(const char *ifn, QuotaType quotaType);
 
@@ -207,6 +221,9 @@ class BandwidthController {
     static int (*execFunction)(int, char **, int *, bool, bool);
     static FILE *(*popenFunction)(const char *, const char *);
     static int (*iptablesRestoreFunction)(IptablesTarget, const std::string&);
+
+    std::list<int /*appUid*/> restrictAppUidsOnData;
+    std::list<int /*appUid*/> restrictAppUidsOnWlan;
 };
 
 #endif

server/CommandListener.cpp

@@ -790,7 +790,7 @@ int CommandListener::SoftapCmd::runCommand(SocketClient *cli,
     else if (!strcmp(argv[1], "startap")) {
         rc = qsap_prepare_softap();
         if (!rc) {
-            rc = gCtls->softapCtrl.startSoftap(qsap_is_fst_enabled());
+            rc = gCtls->softapCtrl.startSoftap(qsap_is_fst_enabled(), cli);
             if (rc != ResponseCode::SoftapStatusResult) {
                 ALOGE("failed to start SoftAP ResponseCode : %d", rc);
                 qsap_unprepare_softap();
@@ -804,7 +804,7 @@ int CommandListener::SoftapCmd::runCommand(SocketClient *cli,
         qsap_unprepare_softap();
 #else
     if (!strcmp(argv[1], "startap")) {
-        rc = gCtls->softapCtrl.startSoftap();
+        rc = gCtls->softapCtrl.startSoftap(false, cli);
     } else if (!strcmp(argv[1], "stopap")) {
         rc = gCtls->softapCtrl.stopSoftap();
 #endif
@@ -1232,6 +1232,7 @@ int CommandListener::BandwidthControlCmd::runCommand(SocketClient *cli, int argc
         return 0;
 
     }
+
     if (!strcmp(argv[1], "blockAllData")) {
         if (argc < 2) {
             sendGenericSyntaxError(cli, "zerobalanceblock");
@@ -1251,6 +1252,63 @@ int CommandListener::BandwidthControlCmd::runCommand(SocketClient *cli, int argc
         return 0;
     }
 
+    if (!strcmp(argv[1], "enableMms")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "enableMms input parameter error");
+            return 0;
+        }
+        bool rc = enableMms(argv[2]);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+
+    if (!strcmp(argv[1], "enableData")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "enableData input parameter error");
+            return 0;
+        }
+        bool rc = enableData(argv[2]);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+
+    if (!strcmp(argv[1], "addrestrictappsondata")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "addrestrictappsondata <appUid> ...");
+            return 0;
+        }
+        int rc = gCtls->bandwidthCtrl.addRestrictAppsOnData(argc - 2, argv + 2);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+    if (!strcmp(argv[1], "removerestrictappsondata")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "removerestrictappsondata <appUid> ...");
+            return 0;
+        }
+        int rc = gCtls->bandwidthCtrl.removeRestrictAppsOnData(argc - 2, argv + 2);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+    if (!strcmp(argv[1], "addrestrictappsonwlan")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "addrestrictappsonwlan <appUid> ...");
+            return 0;
+        }
+        int rc = gCtls->bandwidthCtrl.addRestrictAppsOnWlan(argc - 2, argv + 2);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+    if (!strcmp(argv[1], "removerestrictappsonwlan")) {
+        if (argc < 3) {
+            sendGenericSyntaxError(cli, "removerestrictappsonwlan <appUid> ...");
+            return 0;
+        }
+        int rc = gCtls->bandwidthCtrl.removeRestrictAppsOnWlan(argc - 2, argv + 2);
+        sendGenericOkFail(cli, rc);
+        return 0;
+    }
+
     cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown bandwidth cmd", false);
     return 0;
 }

server/QtiDataController.cpp

@@ -44,6 +44,11 @@ int (*_blockAllData) () = NULL;
 int (*_unblockAllData) () = NULL;
 unsigned (*_checkAppInWhitelist) (SocketClient *cli) = NULL;
 
+void *_libCsmDataHandle = NULL;
+void (*_initCsmDataCtl) () = NULL;
+bool (*_enableMms)(char *uids) = NULL;
+bool (*_enableData)(char *uids) = NULL;
+
 void initDataControllerLibrary() {
     if (!_libDataHandle) {
         _libDataHandle = dlopen("libdatactrl.so", RTLD_NOW);
@@ -62,12 +67,30 @@ void initDataControllerLibrary() {
                     "some features may not be present.");
         }
     }
+
+    /**csm data*/
+    if (!_libCsmDataHandle) {
+        _libCsmDataHandle = dlopen("libcsm_data.so", RTLD_NOW);
+        if (_libCsmDataHandle) {
+            *(void **)&_initCsmDataCtl =
+                    dlsym(_libCsmDataHandle, "initCsmDataCtl");
+            *(void **)&_enableMms =
+                    dlsym(_libCsmDataHandle, "enableMms");
+            *(void **)&_enableData =
+                    dlsym(_libCsmDataHandle, "enableData");
+            ALOGI("Successfully loaded %s", "libCsmDataHandle");
+        } else {
+            ALOGE("Failed to open libcsm_data, "
+                    "some features may not be present.");
+        }
+    }
 }
 
 
 void initializeDataControllerLib() {
     initDataControllerLibrary();
     if (_initDataController) _initDataController();
+    if (_initCsmDataCtl) _initCsmDataCtl();
 }
 
 int blockAllData() {
@@ -85,3 +108,12 @@ unsigned checkAppInWhitelist(SocketClient *cli) {
     return 0;
 }
 
+bool enableMms(char *uids) {
+    if (_enableMms) return _enableMms(uids);
+    return -1;
+}
+
+bool enableData(char *uids) {
+    if (_enableData) return _enableData(uids);
+    return -1;
+}

server/QtiDataController.h

@@ -40,4 +40,7 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  int unblockAllData();
  unsigned checkAppInWhitelist(SocketClient *cli);
 
+ bool enableMms(char* uids);
+ bool enableData(char* uids);
+
 #endif

server/ResponseCode.h

@@ -78,5 +78,6 @@ class ResponseCode {
     static const int InterfaceDnsInfo               = 615;
     static const int RouteChange                    = 616;
     static const int StrictCleartext                = 617;
+    static const int InterfaceMessage               = 618;
 };
 #endif