1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _TETHER_CONTROLLER_H
#define _TETHER_CONTROLLER_H
#include <list>
#include <set>
#include <string>
#include <netdutils/DumpWriter.h>
#include <netdutils/StatusOr.h>
#include <sysutils/SocketClient.h>
#include "NetdConstants.h"
#include "android-base/result.h"
#include "android/net/TetherOffloadRuleParcel.h"
#include "mainline/XtBpfProgLocations.h"
namespace android {
namespace net {
class TetherController {
private:
struct ForwardingDownstream {
std::string iface;
bool active;
};
std::list<std::string> mInterfaces;
// Map upstream iface -> downstream iface. A pair is in the map if forwarding was enabled at
// some point since the controller was initialized.
std::multimap<std::string, ForwardingDownstream> mFwdIfaces;
bool mIsTetheringStarted = false;
// NetId to use for forwarded DNS queries. This may not be the default
// network, e.g., in the case where we are tethering to a DUN APN.
unsigned mDnsNetId = 0;
std::list<std::string> mDnsForwarders;
pid_t mDaemonPid = 0;
int mDaemonFd = -1;
std::set<std::string> mForwardingRequests;
struct DnsmasqState {
static int sendCmd(int daemonFd, const std::string& cmd);
// List of downstream interfaces on which to serve. The format used is:
// update_ifaces|<ifname1>|<ifname2>|...
std::string update_ifaces_cmd;
// Forwarding (upstream) DNS configuration to use. The format used is:
// update_dns|<hex_socket_mark>|<ip1>|<ip2>|...
std::string update_dns_cmd;
void clear();
int sendAllState(int daemonFd) const;
} mDnsmasqState{};
public:
TetherController();
~TetherController() = default;
bool enableForwarding(const char* requester);
bool disableForwarding(const char* requester);
const std::set<std::string>& getIpfwdRequesterList() const;
//TODO: Clean up the overload function
int startTethering(bool isLegacyDnsProxy, int num_addrs, char** dhcp_ranges);
int startTethering(bool isLegacyDnsProxy, const std::vector<std::string>& dhcpRanges);
int stopTethering();
bool isTetheringStarted();
unsigned getDnsNetId();
int setDnsForwarders(unsigned netId, char **servers, int numServers);
int setDnsForwarders(unsigned netId, const std::vector<std::string>& servers);
const std::list<std::string> &getDnsForwarders() const;
int tetherInterface(const char *interface);
int untetherInterface(const char *interface);
const std::list<std::string> &getTetheredInterfaceList() const;
bool applyDnsInterfaces();
int enableNat(const char* intIface, const char* extIface);
int disableNat(const char* intIface, const char* extIface);
int setupIptablesHooks();
class TetherStats {
public:
TetherStats() = default;
TetherStats(std::string intIfn, std::string extIfn,
int64_t rxB, int64_t rxP,
int64_t txB, int64_t txP)
: intIface(intIfn), extIface(extIfn),
rxBytes(rxB), rxPackets(rxP),
txBytes(txB), txPackets(txP) {};
std::string intIface;
std::string extIface;
int64_t rxBytes = -1;
int64_t rxPackets = -1;
int64_t txBytes = -1;
int64_t txPackets = -1;
bool addStatsIfMatch(const TetherStats& other) {
if (intIface == other.intIface && extIface == other.extIface) {
rxBytes += other.rxBytes;
rxPackets += other.rxPackets;
txBytes += other.txBytes;
txPackets += other.txPackets;
return true;
}
return false;
}
};
typedef std::vector<TetherStats> TetherStatsList;
netdutils::StatusOr<TetherStatsList> getTetherStats();
/*
* extraProcessingInfo: contains raw parsed data, and error info.
* This strongly requires that setup of the rules is in a specific order:
* in:intIface out:extIface
* in:extIface out:intIface
* and the rules are grouped in pairs when more that one tethering was setup.
*/
static int addForwardChainStats(TetherStatsList& statsList, const std::string& iptOutput,
std::string &extraProcessingInfo);
static constexpr const char* LOCAL_FORWARD = "tetherctrl_FORWARD";
static constexpr const char* LOCAL_MANGLE_FORWARD = "tetherctrl_mangle_FORWARD";
static constexpr const char* LOCAL_NAT_POSTROUTING = "tetherctrl_nat_POSTROUTING";
static constexpr const char* LOCAL_RAW_PREROUTING = "tetherctrl_raw_PREROUTING";
static constexpr const char* LOCAL_TETHER_COUNTERS_CHAIN = "tetherctrl_counters";
std::mutex lock;
void dump(netdutils::DumpWriter& dw);
void dumpIfaces(netdutils::DumpWriter& dw);
private:
bool setIpFwdEnabled();
std::vector<char*> toCstrVec(const std::vector<std::string>& addrs);
int setupIPv6CountersChain();
static std::string makeTetherCountingRule(const char *if1, const char *if2);
ForwardingDownstream* findForwardingDownstream(const std::string& intIface,
const std::string& extIface);
void addForwardingPair(const std::string& intIface, const std::string& extIface);
void markForwardingPairDisabled(const std::string& intIface, const std::string& extIface);
bool isForwardingPairEnabled(const std::string& intIface, const std::string& extIface);
bool isAnyForwardingEnabledOnUpstream(const std::string& extIface);
bool isAnyForwardingPairEnabled();
bool tetherCountingRuleExists(const std::string& iface1, const std::string& iface2);
int setDefaults();
int setTetherGlobalAlertRule();
int setForwardRules(bool set, const char *intIface, const char *extIface);
int setTetherCountingRules(bool add, const char *intIface, const char *extIface);
static void addStats(TetherStatsList& statsList, const TetherStats& stats);
// For testing.
friend class TetherControllerTest;
static int (*iptablesRestoreFunction)(IptablesTarget, const std::string&, std::string *);
};
} // namespace net
} // namespace android
#endif
|
