1 /* 2 * Copyright (C) 2011 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 #ifndef _BANDWIDTH_CONTROLLER_H 17 #define _BANDWIDTH_CONTROLLER_H 18 19 #include <list> 20 #include <string> 21 #include <utility> // for pair 22 23 #include <sysutils/SocketClient.h> 24 25 class BandwidthController { 26 public: 27 class TetherStats { 28 public: 29 TetherStats(void) 30 : rxBytes(-1), rxPackets(-1), 31 txBytes(-1), txPackets(-1) {}; 32 TetherStats(std::string intIfn, std::string extIfn, 33 int64_t rxB, int64_t rxP, 34 int64_t txB, int64_t txP) 35 : intIface(intIfn), extIface(extIfn), 36 rxBytes(rxB), rxPackets(rxP), 37 txBytes(txB), txPackets(txP) {}; 38 /* Internal interface. Same as NatController's notion. */ 39 std::string intIface; 40 /* External interface. Same as NatController's notion. */ 41 std::string extIface; 42 int64_t rxBytes, rxPackets; 43 int64_t txBytes, txPackets; 44 /* 45 * Allocates a new string representing this: 46 * intIface extIface rx_bytes rx_packets tx_bytes tx_packets 47 * The caller is responsible for free()'ing the returned ptr. 48 */ 49 char *getStatsLine(void) const; 50 }; 51 52 BandwidthController(); 53 54 int setupIptablesHooks(void); 55 56 int enableBandwidthControl(bool force); 57 int disableBandwidthControl(void); 58 59 int setInterfaceSharedQuota(const char *iface, int64_t bytes); 60 int getInterfaceSharedQuota(int64_t *bytes); 61 int removeInterfaceSharedQuota(const char *iface); 62 63 int setInterfaceQuota(const char *iface, int64_t bytes); 64 int getInterfaceQuota(const char *iface, int64_t *bytes); 65 int removeInterfaceQuota(const char *iface); 66 67 int enableHappyBox(void); 68 int disableHappyBox(void); 69 int addNaughtyApps(int numUids, char *appUids[]); 70 int removeNaughtyApps(int numUids, char *appUids[]); 71 int addNiceApps(int numUids, char *appUids[]); 72 int removeNiceApps(int numUids, char *appUids[]); 73 74 int setGlobalAlert(int64_t bytes); 75 int removeGlobalAlert(void); 76 int setGlobalAlertInForwardChain(void); 77 int removeGlobalAlertInForwardChain(void); 78 79 int setSharedAlert(int64_t bytes); 80 int removeSharedAlert(void); 81 82 int setInterfaceAlert(const char *iface, int64_t bytes); 83 int removeInterfaceAlert(const char *iface); 84 85 /* 86 * For single pair of ifaces, stats should have ifaceIn and ifaceOut initialized. 87 * For all pairs, stats should have ifaceIn=ifaceOut="". 88 * Sends out to the cli the single stat (TetheringStatsReluts) or a list of stats 89 * (TetheringStatsListResult+CommandOkay). 90 * Error is to be handled on the outside. 91 * It results in an error if invoked and no tethering counter rules exist. 92 */ 93 int getTetherStats(SocketClient *cli, TetherStats &stats, std::string &extraProcessingInfo); 94 95 static const char* LOCAL_INPUT; 96 static const char* LOCAL_FORWARD; 97 static const char* LOCAL_OUTPUT; 98 static const char* LOCAL_RAW_PREROUTING; 99 static const char* LOCAL_MANGLE_POSTROUTING; 100 101 protected: 102 class QuotaInfo { 103 public: 104 QuotaInfo(std::string ifn, int64_t q, int64_t a) 105 : ifaceName(ifn), quota(q), alert(a) {}; 106 std::string ifaceName; 107 int64_t quota; 108 int64_t alert; 109 }; 110 111 enum IptIpVer { IptIpV4, IptIpV6 }; 112 enum IptOp { IptOpInsert, IptOpReplace, IptOpDelete, IptOpAppend }; 113 enum IptJumpOp { IptJumpReject, IptJumpReturn, IptJumpNoAdd }; 114 enum SpecialAppOp { SpecialAppOpAdd, SpecialAppOpRemove }; 115 enum QuotaType { QuotaUnique, QuotaShared }; 116 enum RunCmdErrHandling { RunCmdFailureBad, RunCmdFailureOk }; 117 #if LOG_NDEBUG 118 enum IptFailureLog { IptFailShow, IptFailHide }; 119 #else 120 enum IptFailureLog { IptFailShow, IptFailHide = IptFailShow }; 121 #endif 122 123 int manipulateSpecialApps(int numUids, char *appStrUids[], 124 const char *chain, 125 std::list<int /*appUid*/> &specialAppUids, 126 IptJumpOp jumpHandling, SpecialAppOp appOp); 127 int manipulateNaughtyApps(int numUids, char *appStrUids[], SpecialAppOp appOp); 128 int manipulateNiceApps(int numUids, char *appStrUids[], SpecialAppOp appOp); 129 130 int prepCostlyIface(const char *ifn, QuotaType quotaType); 131 int cleanupCostlyIface(const char *ifn, QuotaType quotaType); 132 133 std::string makeIptablesSpecialAppCmd(IptOp op, int uid, const char *chain); 134 std::string makeIptablesQuotaCmd(IptOp op, const char *costName, int64_t quota); 135 136 int runIptablesAlertCmd(IptOp op, const char *alertName, int64_t bytes); 137 int runIptablesAlertFwdCmd(IptOp op, const char *alertName, int64_t bytes); 138 139 /* Runs for both ipv4 and ipv6 iptables */ 140 int runCommands(int numCommands, const char *commands[], RunCmdErrHandling cmdErrHandling); 141 /* Runs for both ipv4 and ipv6 iptables, appends -j REJECT --reject-with ... */ 142 static int runIpxtablesCmd(const char *cmd, IptJumpOp jumpHandling, 143 IptFailureLog failureHandling = IptFailShow); 144 static int runIptablesCmd(const char *cmd, IptJumpOp jumpHandling, IptIpVer iptIpVer, 145 IptFailureLog failureHandling = IptFailShow); 146 147 148 // Provides strncpy() + check overflow. 149 static int StrncpyAndCheck(char *buffer, const char *src, size_t buffSize); 150 151 int updateQuota(const char *alertName, int64_t bytes); 152 153 int setCostlyAlert(const char *costName, int64_t bytes, int64_t *alertBytes); 154 int removeCostlyAlert(const char *costName, int64_t *alertBytes); 155 156 /* 157 * stats should never have only intIface initialized. Other 3 combos are ok. 158 * fp should be a file to the apropriate FORWARD chain of iptables rules. 159 * extraProcessingInfo: contains raw parsed data, and error info. 160 * This strongly requires that setup of the rules is in a specific order: 161 * in:intIface out:extIface 162 * in:extIface out:intIface 163 * and the rules are grouped in pairs when more that one tethering was setup. 164 */ 165 static int parseForwardChainStats(SocketClient *cli, const TetherStats filter, FILE *fp, 166 std::string &extraProcessingInfo); 167 168 /* 169 * Attempt to find the bw_costly_* tables that need flushing, 170 * and flush them. 171 * If doClean then remove the tables also. 172 * Deals with both ip4 and ip6 tables. 173 */ 174 void flushExistingCostlyTables(bool doClean); 175 static void parseAndFlushCostlyTables(FILE *fp, bool doRemove); 176 177 /* 178 * Attempt to flush our tables. 179 * If doClean then remove them also. 180 * Deals with both ip4 and ip6 tables. 181 */ 182 void flushCleanTables(bool doClean); 183 184 /*------------------*/ 185 186 std::list<std::string> sharedQuotaIfaces; 187 int64_t sharedQuotaBytes; 188 int64_t sharedAlertBytes; 189 int64_t globalAlertBytes; 190 /* 191 * This tracks the number of tethers setup. 192 * The FORWARD chain is updated in the following cases: 193 * - The 1st time a globalAlert is setup and there are tethers setup. 194 * - Anytime a globalAlert is removed and there are tethers setup. 195 * - The 1st tether is setup and there is a globalAlert active. 196 * - The last tether is removed and there is a globalAlert active. 197 */ 198 int globalAlertTetherCount; 199 200 std::list<QuotaInfo> quotaIfaces; 201 std::list<int /*appUid*/> naughtyAppUids; 202 std::list<int /*appUid*/> niceAppUids; 203 204 private: 205 static const char *IPT_FLUSH_COMMANDS[]; 206 static const char *IPT_CLEANUP_COMMANDS[]; 207 static const char *IPT_SETUP_COMMANDS[]; 208 static const char *IPT_BASIC_ACCOUNTING_COMMANDS[]; 209 210 /* Alphabetical */ 211 static const char ALERT_GLOBAL_NAME[]; 212 static const int MAX_CMD_ARGS; 213 static const int MAX_CMD_LEN; 214 static const int MAX_IFACENAME_LEN; 215 static const int MAX_IPT_OUTPUT_LINE_LEN; 216 }; 217 218 #endif 219
