Home | History | Annotate | Download | only in netd 
      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 class BandwidthController {
     24 public:
     25     class TetherStats {
     26     public:
     27         TetherStats(void)
     28                 : rxBytes(-1), rxPackets(-1),
     29                     txBytes(-1), txPackets(-1) {};
     30         TetherStats(std::string ifnIn, std::string ifnOut,
     31                 int64_t rxB, int64_t rxP,
     32                 int64_t txB, int64_t txP)
     33                         : ifaceIn(ifnIn), ifaceOut(ifnOut),
     34                             rxBytes(rxB), rxPackets(rxP),
     35                     txBytes(txB), txPackets(txP) {};
     36         std::string ifaceIn;
     37         std::string ifaceOut;
     38         int64_t rxBytes, rxPackets;
     39         int64_t txBytes, txPackets;
     40         /*
     41          * Allocates a new string representing this:
     42          * ifaceIn ifaceOut rx_bytes rx_packets tx_bytes tx_packets
     43          * The caller is responsible for free()'ing the returned ptr.
     44          */
     45         char *getStatsLine(void);
     46     };
     47 
     48     BandwidthController();
     49 
     50     int setupIptablesHooks(void);
     51 
     52     int enableBandwidthControl(bool force);
     53     int disableBandwidthControl(void);
     54 
     55     int setInterfaceSharedQuota(const char *iface, int64_t bytes);
     56     int getInterfaceSharedQuota(int64_t *bytes);
     57     int removeInterfaceSharedQuota(const char *iface);
     58 
     59     int setInterfaceQuota(const char *iface, int64_t bytes);
     60     int getInterfaceQuota(const char *iface, int64_t *bytes);
     61     int removeInterfaceQuota(const char *iface);
     62 
     63     int addNaughtyApps(int numUids, char *appUids[]);
     64     int removeNaughtyApps(int numUids, char *appUids[]);
     65 
     66     int setGlobalAlert(int64_t bytes);
     67     int removeGlobalAlert(void);
     68     int setGlobalAlertInForwardChain(void);
     69     int removeGlobalAlertInForwardChain(void);
     70 
     71     int setSharedAlert(int64_t bytes);
     72     int removeSharedAlert(void);
     73 
     74     int setInterfaceAlert(const char *iface, int64_t bytes);
     75     int removeInterfaceAlert(const char *iface);
     76 
     77     /*
     78      * stats should have ifaceIn and ifaceOut initialized.
     79      * Byte counts should be left to the default (-1).
     80      */
     81     int getTetherStats(TetherStats &stats, std::string &extraProcessingInfo);
     82 
     83     static const char* LOCAL_INPUT;
     84     static const char* LOCAL_FORWARD;
     85     static const char* LOCAL_OUTPUT;
     86     static const char* LOCAL_RAW_PREROUTING;
     87     static const char* LOCAL_MANGLE_POSTROUTING;
     88 
     89 protected:
     90     class QuotaInfo {
     91     public:
     92       QuotaInfo(std::string ifn, int64_t q, int64_t a)
     93               : ifaceName(ifn), quota(q), alert(a) {};
     94         std::string ifaceName;
     95         int64_t quota;
     96         int64_t alert;
     97     };
     98 
     99     enum IptIpVer { IptIpV4, IptIpV6 };
    100     enum IptOp { IptOpInsert, IptOpReplace, IptOpDelete, IptOpAppend };
    101     enum IptRejectOp { IptRejectAdd, IptRejectNoAdd };
    102     enum NaughtyAppOp { NaughtyAppOpAdd, NaughtyAppOpRemove };
    103     enum QuotaType { QuotaUnique, QuotaShared };
    104     enum RunCmdErrHandling { RunCmdFailureBad, RunCmdFailureOk };
    105 #if LOG_NDEBUG
    106     enum IptFailureLog { IptFailShow, IptFailHide };
    107 #else
    108     enum IptFailureLog { IptFailShow, IptFailHide = IptFailShow };
    109 #endif
    110     int maninpulateNaughtyApps(int numUids, char *appStrUids[], NaughtyAppOp appOp);
    111 
    112     int prepCostlyIface(const char *ifn, QuotaType quotaType);
    113     int cleanupCostlyIface(const char *ifn, QuotaType quotaType);
    114 
    115     std::string makeIptablesNaughtyCmd(IptOp op, int uid);
    116     std::string makeIptablesQuotaCmd(IptOp op, const char *costName, int64_t quota);
    117 
    118     int runIptablesAlertCmd(IptOp op, const char *alertName, int64_t bytes);
    119     int runIptablesAlertFwdCmd(IptOp op, const char *alertName, int64_t bytes);
    120 
    121     /* Runs for both ipv4 and ipv6 iptables */
    122     int runCommands(int numCommands, const char *commands[], RunCmdErrHandling cmdErrHandling);
    123     /* Runs for both ipv4 and ipv6 iptables, appends -j REJECT --reject-with ...  */
    124     static int runIpxtablesCmd(const char *cmd, IptRejectOp rejectHandling,
    125                                IptFailureLog failureHandling = IptFailShow);
    126     static int runIptablesCmd(const char *cmd, IptRejectOp rejectHandling, IptIpVer iptIpVer,
    127                               IptFailureLog failureHandling = IptFailShow);
    128 
    129 
    130     // Provides strncpy() + check overflow.
    131     static int StrncpyAndCheck(char *buffer, const char *src, size_t buffSize);
    132 
    133     int updateQuota(const char *alertName, int64_t bytes);
    134 
    135     int setCostlyAlert(const char *costName, int64_t bytes, int64_t *alertBytes);
    136     int removeCostlyAlert(const char *costName, int64_t *alertBytes);
    137 
    138     /*
    139      * stats should have ifaceIn and ifaceOut initialized.
    140      * fp should be a file to the FORWARD rules of iptables.
    141      * extraProcessingInfo: contains raw parsed data, and error info.
    142      */
    143     static int parseForwardChainStats(TetherStats &stats, FILE *fp,
    144                                       std::string &extraProcessingInfo);
    145 
    146     /*------------------*/
    147 
    148     std::list<std::string> sharedQuotaIfaces;
    149     int64_t sharedQuotaBytes;
    150     int64_t sharedAlertBytes;
    151     int64_t globalAlertBytes;
    152     /*
    153      * This tracks the number of tethers setup.
    154      * The FORWARD chain is updated in the following cases:
    155      *  - The 1st time a globalAlert is setup and there are tethers setup.
    156      *  - Anytime a globalAlert is removed and there are tethers setup.
    157      *  - The 1st tether is setup and there is a globalAlert active.
    158      *  - The last tether is removed and there is a globalAlert active.
    159      */
    160     int globalAlertTetherCount;
    161 
    162     std::list<QuotaInfo> quotaIfaces;
    163     std::list<int /*appUid*/> naughtyAppUids;
    164 
    165 private:
    166     static const char *IPT_FLUSH_COMMANDS[];
    167     static const char *IPT_CLEANUP_COMMANDS[];
    168     static const char *IPT_SETUP_COMMANDS[];
    169     static const char *IPT_BASIC_ACCOUNTING_COMMANDS[];
    170 
    171     /* Alphabetical */
    172     static const char ALERT_GLOBAL_NAME[];
    173     static const int  MAX_CMD_ARGS;
    174     static const int  MAX_CMD_LEN;
    175     static const int  MAX_IFACENAME_LEN;
    176     static const int  MAX_IPT_OUTPUT_LINE_LEN;
    177 };
    178 
    179 #endif
    180