blob: f129335a438ccb39d87b3aaaffb7489d04538f21 [file] [log] [blame]
San Mehat9d10b342010-01-18 09:51:02 -08001/*
2 * Copyright (C) 2008 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
17#ifndef _TETHER_CONTROLLER_H
18#define _TETHER_CONTROLLER_H
19
Erik Kline70c03662016-03-31 11:39:53 +090020#include <list>
Lorenzo Colitti799625c2015-02-25 12:52:00 +090021#include <set>
22#include <string>
San Mehat9d10b342010-01-18 09:51:02 -080023
Lorenzo Colitti52db3912020-02-17 23:59:45 +090024#include <netdutils/DumpWriter.h>
Lorenzo Colitti9a8a9ff2017-01-31 19:06:59 +090025#include <netdutils/StatusOr.h>
Lorenzo Colittia93126d2017-08-24 13:28:19 +090026#include <sysutils/SocketClient.h>
27
28#include "NetdConstants.h"
29
Luke Huangd1ee4622018-06-29 13:49:58 +080030
Lorenzo Colittie20a5262017-05-09 18:30:44 +090031namespace android {
32namespace net {
San Mehat9d10b342010-01-18 09:51:02 -080033
34class TetherController {
waynema71a0b592018-11-21 13:31:34 +080035 private:
Remi NGUYEN VAN3b47c792018-03-20 14:44:12 +090036 struct ForwardingDownstream {
37 std::string iface;
38 bool active;
39 };
40
Erik Kline2c5aaa12016-06-08 13:24:45 +090041 std::list<std::string> mInterfaces;
Lorenzo Colittia93126d2017-08-24 13:28:19 +090042
Remi NGUYEN VAN3b47c792018-03-20 14:44:12 +090043 // Map upstream iface -> downstream iface. A pair is in the map if forwarding was enabled at
44 // some point since the controller was initialized.
45 std::multimap<std::string, ForwardingDownstream> mFwdIfaces;
46
Luke Huang91bd3e12019-08-20 11:33:52 +080047 bool mIsTetheringStarted = false;
48
Lorenzo Colitti667c4772014-08-26 14:13:07 -070049 // NetId to use for forwarded DNS queries. This may not be the default
50 // network, e.g., in the case where we are tethering to a DUN APN.
Remi NGUYEN VAN7d9bebf2018-03-29 11:32:29 +090051 unsigned mDnsNetId = 0;
Erik Kline2c5aaa12016-06-08 13:24:45 +090052 std::list<std::string> mDnsForwarders;
Remi NGUYEN VAN7d9bebf2018-03-29 11:32:29 +090053 pid_t mDaemonPid = 0;
54 int mDaemonFd = -1;
Erik Kline2c5aaa12016-06-08 13:24:45 +090055 std::set<std::string> mForwardingRequests;
San Mehat9d10b342010-01-18 09:51:02 -080056
Erik Kline15079dd2018-05-18 23:10:56 +090057 struct DnsmasqState {
58 static int sendCmd(int daemonFd, const std::string& cmd);
59
60 // List of downstream interfaces on which to serve. The format used is:
61 // update_ifaces|<ifname1>|<ifname2>|...
62 std::string update_ifaces_cmd;
63 // Forwarding (upstream) DNS configuration to use. The format used is:
64 // update_dns|<hex_socket_mark>|<ip1>|<ip2>|...
65 std::string update_dns_cmd;
66
67 void clear();
68 int sendAllState(int daemonFd) const;
69 } mDnsmasqState{};
70
Erik Klineb31fd692018-06-06 20:50:11 +090071 public:
Sreeram Ramachandran87475a12014-07-15 16:20:28 -070072 TetherController();
Remi NGUYEN VAN7d9bebf2018-03-29 11:32:29 +090073 ~TetherController() = default;
San Mehat9d10b342010-01-18 09:51:02 -080074
Lorenzo Colitti799625c2015-02-25 12:52:00 +090075 bool enableForwarding(const char* requester);
76 bool disableForwarding(const char* requester);
Luke Huang728cf4c2019-03-14 19:43:02 +080077 const std::set<std::string>& getIpfwdRequesterList() const;
San Mehat9d10b342010-01-18 09:51:02 -080078
Luke Huang91bd3e12019-08-20 11:33:52 +080079 //TODO: Clean up the overload function
80 int startTethering(bool isLegacyDnsProxy, int num_addrs, char** dhcp_ranges);
81 int startTethering(bool isLegacyDnsProxy, const std::vector<std::string>& dhcpRanges);
San Mehat9d10b342010-01-18 09:51:02 -080082 int stopTethering();
83 bool isTetheringStarted();
84
Lorenzo Colitti667c4772014-08-26 14:13:07 -070085 unsigned getDnsNetId();
86 int setDnsForwarders(unsigned netId, char **servers, int numServers);
Luke Huangb5733d72018-08-21 17:17:19 +080087 int setDnsForwarders(unsigned netId, const std::vector<std::string>& servers);
Erik Kline2c5aaa12016-06-08 13:24:45 +090088 const std::list<std::string> &getDnsForwarders() const;
San Mehat9d10b342010-01-18 09:51:02 -080089
90 int tetherInterface(const char *interface);
91 int untetherInterface(const char *interface);
Erik Kline2c5aaa12016-06-08 13:24:45 +090092 const std::list<std::string> &getTetheredInterfaceList() const;
Erik Kline212c4052016-07-18 04:02:07 +090093 bool applyDnsInterfaces();
Robert Greenwalt3d4c7582012-12-11 12:33:37 -080094
Lorenzo Colittia93126d2017-08-24 13:28:19 +090095 int enableNat(const char* intIface, const char* extIface);
96 int disableNat(const char* intIface, const char* extIface);
97 int setupIptablesHooks();
98
99 class TetherStats {
waynema71a0b592018-11-21 13:31:34 +0800100 public:
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900101 TetherStats() = default;
102 TetherStats(std::string intIfn, std::string extIfn,
103 int64_t rxB, int64_t rxP,
104 int64_t txB, int64_t txP)
105 : intIface(intIfn), extIface(extIfn),
106 rxBytes(rxB), rxPackets(rxP),
107 txBytes(txB), txPackets(txP) {};
108 std::string intIface;
109 std::string extIface;
110 int64_t rxBytes = -1;
111 int64_t rxPackets = -1;
112 int64_t txBytes = -1;
113 int64_t txPackets = -1;
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900114
115 bool addStatsIfMatch(const TetherStats& other) {
116 if (intIface == other.intIface && extIface == other.extIface) {
117 rxBytes += other.rxBytes;
118 rxPackets += other.rxPackets;
119 txBytes += other.txBytes;
120 txPackets += other.txPackets;
121 return true;
122 }
123 return false;
124 }
125 };
126
Lorenzo Colitti9a8a9ff2017-01-31 19:06:59 +0900127 typedef std::vector<TetherStats> TetherStatsList;
128
Erik Klineb31fd692018-06-06 20:50:11 +0900129 netdutils::StatusOr<TetherStatsList> getTetherStats();
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900130
131 /*
Lorenzo Colitti09353392017-08-24 14:20:32 +0900132 * extraProcessingInfo: contains raw parsed data, and error info.
133 * This strongly requires that setup of the rules is in a specific order:
134 * in:intIface out:extIface
135 * in:extIface out:intIface
136 * and the rules are grouped in pairs when more that one tethering was setup.
137 */
138 static int addForwardChainStats(TetherStatsList& statsList, const std::string& iptOutput,
139 std::string &extraProcessingInfo);
140
Lorenzo Colitti4604b4a2017-08-24 19:21:50 +0900141 static constexpr const char* LOCAL_FORWARD = "tetherctrl_FORWARD";
142 static constexpr const char* LOCAL_MANGLE_FORWARD = "tetherctrl_mangle_FORWARD";
143 static constexpr const char* LOCAL_NAT_POSTROUTING = "tetherctrl_nat_POSTROUTING";
144 static constexpr const char* LOCAL_RAW_PREROUTING = "tetherctrl_raw_PREROUTING";
145 static constexpr const char* LOCAL_TETHER_COUNTERS_CHAIN = "tetherctrl_counters";
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900146
Luke Huangd1ee4622018-06-29 13:49:58 +0800147 std::mutex lock;
Lorenzo Colitti9a8a9ff2017-01-31 19:06:59 +0900148
Lorenzo Colitti52db3912020-02-17 23:59:45 +0900149 void dump(netdutils::DumpWriter& dw);
150 void dumpIfaces(netdutils::DumpWriter& dw);
151
waynema71a0b592018-11-21 13:31:34 +0800152 private:
Lorenzo Colitti799625c2015-02-25 12:52:00 +0900153 bool setIpFwdEnabled();
Luke Huangb5733d72018-08-21 17:17:19 +0800154 std::vector<char*> toCstrVec(const std::vector<std::string>& addrs);
Remi NGUYEN VAN3b47c792018-03-20 14:44:12 +0900155 int setupIPv6CountersChain();
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900156 static std::string makeTetherCountingRule(const char *if1, const char *if2);
Remi NGUYEN VAN3b47c792018-03-20 14:44:12 +0900157 ForwardingDownstream* findForwardingDownstream(const std::string& intIface,
158 const std::string& extIface);
159 void addForwardingPair(const std::string& intIface, const std::string& extIface);
160 void markForwardingPairDisabled(const std::string& intIface, const std::string& extIface);
161
162 bool isForwardingPairEnabled(const std::string& intIface, const std::string& extIface);
163 bool isAnyForwardingEnabledOnUpstream(const std::string& extIface);
164 bool isAnyForwardingPairEnabled();
165 bool tetherCountingRuleExists(const std::string& iface1, const std::string& iface2);
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900166
167 int setDefaults();
Luke Huangae038f82018-11-05 11:17:31 +0900168 int setTetherGlobalAlertRule();
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900169 int setForwardRules(bool set, const char *intIface, const char *extIface);
170 int setTetherCountingRules(bool add, const char *intIface, const char *extIface);
171
Hungming Chen1da90082020-02-14 20:24:16 +0800172 void maybeStartBpf(const char* extIface);
173 void maybeStopBpf(const char* extIface);
174
Lorenzo Colitti9a8a9ff2017-01-31 19:06:59 +0900175 static void addStats(TetherStatsList& statsList, const TetherStats& stats);
176
Lorenzo Colittia93126d2017-08-24 13:28:19 +0900177 // For testing.
178 friend class TetherControllerTest;
179 static int (*iptablesRestoreFunction)(IptablesTarget, const std::string&, std::string *);
San Mehat9d10b342010-01-18 09:51:02 -0800180};
181
Lorenzo Colittie20a5262017-05-09 18:30:44 +0900182} // namespace net
183} // namespace android
184
San Mehat9d10b342010-01-18 09:51:02 -0800185#endif