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