server/BandwidthController.h

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