2 * Copyright (C) 2011 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #ifndef _BANDWIDTH_CONTROLLER_H
17 #define _BANDWIDTH_CONTROLLER_H
21 #include <utility> // for pair
23 #include <sysutils/SocketClient.h>
25 class BandwidthController {
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. */
40 /* External interface. Same as NatController's notion. */
42 int64_t rxBytes, rxPackets;
43 int64_t txBytes, txPackets;
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.
49 char *getStatsLine(void) const;
52 BandwidthController();
54 int setupIptablesHooks(void);
56 int enableBandwidthControl(bool force);
57 int disableBandwidthControl(void);
59 int setInterfaceSharedQuota(const char *iface, int64_t bytes);
60 int getInterfaceSharedQuota(int64_t *bytes);
61 int removeInterfaceSharedQuota(const char *iface);
63 int setInterfaceQuota(const char *iface, int64_t bytes);
64 int getInterfaceQuota(const char *iface, int64_t *bytes);
65 int removeInterfaceQuota(const char *iface);
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[]);
74 int setGlobalAlert(int64_t bytes);
75 int removeGlobalAlert(void);
76 int setGlobalAlertInForwardChain(void);
77 int removeGlobalAlertInForwardChain(void);
79 int setSharedAlert(int64_t bytes);
80 int removeSharedAlert(void);
82 int setInterfaceAlert(const char *iface, int64_t bytes);
83 int removeInterfaceAlert(const char *iface);
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.
93 int getTetherStats(SocketClient *cli, TetherStats &stats, std::string &extraProcessingInfo);
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;
104 QuotaInfo(std::string ifn, int64_t q, int64_t a)
105 : ifaceName(ifn), quota(q), alert(a) {};
106 std::string ifaceName;
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 };
118 enum IptFailureLog { IptFailShow, IptFailHide };
120 enum IptFailureLog { IptFailShow, IptFailHide = IptFailShow };
123 int manipulateSpecialApps(int numUids, char *appStrUids[],
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);
130 int prepCostlyIface(const char *ifn, QuotaType quotaType);
131 int cleanupCostlyIface(const char *ifn, QuotaType quotaType);
133 std::string makeIptablesSpecialAppCmd(IptOp op, int uid, const char *chain);
134 std::string makeIptablesQuotaCmd(IptOp op, const char *costName, int64_t quota);
136 int runIptablesAlertCmd(IptOp op, const char *alertName, int64_t bytes);
137 int runIptablesAlertFwdCmd(IptOp op, const char *alertName, int64_t bytes);
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);
148 // Provides strncpy() + check overflow.
149 static int StrncpyAndCheck(char *buffer, const char *src, size_t buffSize);
151 int updateQuota(const char *alertName, int64_t bytes);
153 int setCostlyAlert(const char *costName, int64_t bytes, int64_t *alertBytes);
154 int removeCostlyAlert(const char *costName, int64_t *alertBytes);
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.
165 static int parseForwardChainStats(SocketClient *cli, const TetherStats filter, FILE *fp,
166 std::string &extraProcessingInfo);
169 * Attempt to find the bw_costly_* tables that need flushing,
171 * If doClean then remove the tables also.
172 * Deals with both ip4 and ip6 tables.
174 void flushExistingCostlyTables(bool doClean);
175 static void parseAndFlushCostlyTables(FILE *fp, bool doRemove);
178 * Attempt to flush our tables.
179 * If doClean then remove them also.
180 * Deals with both ip4 and ip6 tables.
182 void flushCleanTables(bool doClean);
184 /*------------------*/
186 std::list<std::string> sharedQuotaIfaces;
187 int64_t sharedQuotaBytes;
188 int64_t sharedAlertBytes;
189 int64_t globalAlertBytes;
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.
198 int globalAlertTetherCount;
200 std::list<QuotaInfo> quotaIfaces;
201 std::list<int /*appUid*/> naughtyAppUids;
202 std::list<int /*appUid*/> niceAppUids;
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[];
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;