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
25class BandwidthController {
26public:
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
101protected:
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
204private:
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