1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "conn_manager.h"
17
18 #include "bpf_def.h"
19 #include "bpf_mapper.h"
20 #include "bpf_path.h"
21 #include "local_network.h"
22 #include "net_manager_constants.h"
23 #include "netnative_log_wrapper.h"
24 #include "physical_network.h"
25 #include "virtual_network.h"
26
27 namespace OHOS {
28 namespace nmd {
29 using namespace NetManagerStandard;
30 namespace {
31 constexpr int32_t INTERFACE_UNSET = -1;
32 constexpr int32_t LOCAL_NET_ID = 99;
33 } // namespace
34
ConnManager()35 ConnManager::ConnManager()
36 {
37 networks_[LOCAL_NET_ID] = std::make_shared<LocalNetwork>(LOCAL_NET_ID);
38 defaultNetId_ = 0;
39 needReinitRouteFlag_ = false;
40 }
41
~ConnManager()42 ConnManager::~ConnManager()
43 {
44 networks_.clear();
45 }
46
SetInternetPermission(uint32_t uid,uint8_t allow)47 int32_t ConnManager::SetInternetPermission(uint32_t uid, uint8_t allow)
48 {
49 // 0 means root
50 if (uid == 0) {
51 return NETMANAGER_ERROR;
52 }
53
54 BpfMapper<sock_permission_key, sock_permission_value> permissionMap(SOCKET_PERMISSION_MAP_PATH, BPF_F_WRONLY);
55 if (!permissionMap.IsValid()) {
56 return NETMANAGER_ERROR;
57 }
58
59 // 0 means no permission
60 if (permissionMap.Write(uid, allow, 0) != 0) {
61 return NETMANAGER_ERROR;
62 }
63
64 return NETMANAGER_SUCCESS;
65 }
66
CreatePhysicalNetwork(uint16_t netId,NetworkPermission permission)67 int32_t ConnManager::CreatePhysicalNetwork(uint16_t netId, NetworkPermission permission)
68 {
69 if (needReinitRouteFlag_) {
70 std::set<int32_t> netIds;
71 for (const auto &iter : networks_) {
72 if (iter.first == LOCAL_NET_ID || iter.second == nullptr) {
73 continue;
74 }
75 netIds.insert(iter.second->GetNetId());
76 }
77 for (auto netId : netIds) {
78 std::string interfaceName;
79 {
80 std::lock_guard<std::mutex> lock(interfaceNameMutex_);
81 interfaceName = physicalInterfaceName_[netId];
82 }
83 RemoveInterfaceFromNetwork(netId, interfaceName);
84 DestroyNetwork(netId);
85 }
86 needReinitRouteFlag_ = false;
87 }
88 std::shared_ptr<NetsysNetwork> network = std::make_shared<PhysicalNetwork>(netId, permission);
89 networks_[netId] = network;
90 return NETMANAGER_SUCCESS;
91 }
92
CreateVirtualNetwork(uint16_t netId,bool hasDns)93 int32_t ConnManager::CreateVirtualNetwork(uint16_t netId, bool hasDns)
94 {
95 networks_[netId] = std::make_shared<VirtualNetwork>(netId, hasDns);
96 return NETMANAGER_SUCCESS;
97 }
98
DestroyNetwork(int32_t netId)99 int32_t ConnManager::DestroyNetwork(int32_t netId)
100 {
101 if (netId == LOCAL_NET_ID) {
102 NETNATIVE_LOGE("Cannot destroy local network");
103 return NETMANAGER_ERROR;
104 }
105 const auto &net = FindNetworkById(netId);
106 if (std::get<0>(net)) {
107 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
108 if (defaultNetId_ == netId) {
109 if (nw->IsPhysical()) {
110 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
111 }
112 defaultNetId_ = 0;
113 }
114 nw->ClearInterfaces();
115 }
116 networks_.erase(netId);
117 return NETMANAGER_SUCCESS;
118 }
119
SetDefaultNetwork(int32_t netId)120 int32_t ConnManager::SetDefaultNetwork(int32_t netId)
121 {
122 if (defaultNetId_ == netId) {
123 return NETMANAGER_SUCCESS;
124 }
125
126 // check if this network exists
127 const auto &net = FindNetworkById(netId);
128 if (std::get<0>(net)) {
129 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
130 if (!nw->IsPhysical()) {
131 NETNATIVE_LOGE("SetDefaultNetwork fail, network :%{public}d is not physical ", netId);
132 return NETMANAGER_ERROR;
133 }
134 static_cast<PhysicalNetwork *>(nw.get())->AddDefault();
135 }
136
137 if (defaultNetId_ != 0) {
138 const auto &defaultNet = FindNetworkById(defaultNetId_);
139 if (std::get<0>(defaultNet)) {
140 std::shared_ptr<NetsysNetwork> nw = std::get<1>(defaultNet);
141 if (!nw->IsPhysical()) {
142 NETNATIVE_LOGE("SetDefaultNetwork fail, defaultNetId_ :%{public}d is not physical", defaultNetId_);
143 return NETMANAGER_ERROR;
144 }
145 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
146 }
147 }
148 defaultNetId_ = netId;
149 return NETMANAGER_SUCCESS;
150 }
151
ClearDefaultNetwork()152 int32_t ConnManager::ClearDefaultNetwork()
153 {
154 if (defaultNetId_ != 0) {
155 const auto &net = FindNetworkById(defaultNetId_);
156 if (std::get<0>(net)) {
157 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
158 if (!nw->IsPhysical()) {
159 NETNATIVE_LOGE("ClearDefaultNetwork fail, defaultNetId_ :%{public}d is not physical", defaultNetId_);
160 return NETMANAGER_ERROR;
161 }
162 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
163 }
164 }
165 defaultNetId_ = 0;
166 return NETMANAGER_SUCCESS;
167 }
168
FindNetworkById(int32_t netId)169 std::tuple<bool, std::shared_ptr<NetsysNetwork>> ConnManager::FindNetworkById(int32_t netId)
170 {
171 NETNATIVE_LOG_D("Entry ConnManager::FindNetworkById netId:%{public}d", netId);
172 std::map<int32_t, std::shared_ptr<NetsysNetwork>>::iterator it;
173 for (it = networks_.begin(); it != networks_.end(); ++it) {
174 if (netId == it->first) {
175 return std::make_tuple(true, it->second);
176 }
177 }
178 return std::make_tuple<bool, std::shared_ptr<NetsysNetwork>>(false, nullptr);
179 }
180
GetDefaultNetwork() const181 int32_t ConnManager::GetDefaultNetwork() const
182 {
183 return defaultNetId_;
184 }
185
GetNetworkForInterface(std::string & interfaceName)186 int32_t ConnManager::GetNetworkForInterface(std::string &interfaceName)
187 {
188 NETNATIVE_LOG_D("Entry ConnManager::GetNetworkForInterface interfaceName:%{public}s", interfaceName.c_str());
189 std::map<int32_t, std::shared_ptr<NetsysNetwork>>::iterator it;
190 for (it = networks_.begin(); it != networks_.end(); ++it) {
191 if (it->second->ExistInterface(interfaceName)) {
192 return it->first;
193 }
194 }
195 return INTERFACE_UNSET;
196 }
197
AddInterfaceToNetwork(int32_t netId,std::string & interfaceName)198 int32_t ConnManager::AddInterfaceToNetwork(int32_t netId, std::string &interfaceName)
199 {
200 NETNATIVE_LOG_D("Entry ConnManager::AddInterfaceToNetwork netId:%{public}d, interfaceName:%{public}s", netId,
201 interfaceName.c_str());
202 int32_t alreadySetNetId = GetNetworkForInterface(interfaceName);
203 if ((alreadySetNetId != netId) && (alreadySetNetId != INTERFACE_UNSET)) {
204 NETNATIVE_LOGE("AddInterfaceToNetwork failed alreadySetNetId:%{public}d", alreadySetNetId);
205 return NETMANAGER_ERROR;
206 }
207
208 const auto &net = FindNetworkById(netId);
209 if (std::get<0>(net)) {
210 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
211 if (nw->IsPhysical()) {
212 std::lock_guard<std::mutex> lock(interfaceNameMutex_);
213 physicalInterfaceName_[netId] = interfaceName;
214 }
215 return nw->AddInterface(interfaceName);
216 }
217 return NETMANAGER_ERROR;
218 }
219
RemoveInterfaceFromNetwork(int32_t netId,std::string & interfaceName)220 int32_t ConnManager::RemoveInterfaceFromNetwork(int32_t netId, std::string &interfaceName)
221 {
222 int32_t alreadySetNetId = GetNetworkForInterface(interfaceName);
223 if ((alreadySetNetId != netId) || (alreadySetNetId == INTERFACE_UNSET)) {
224 return NETMANAGER_SUCCESS;
225 } else if (alreadySetNetId == netId) {
226 const auto &net = FindNetworkById(netId);
227 if (std::get<0>(net)) {
228 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
229 int32_t ret = nw->RemoveInterface(interfaceName);
230 if (nw->IsPhysical()) {
231 std::lock_guard<std::mutex> lock(interfaceNameMutex_);
232 physicalInterfaceName_.erase(netId);
233 }
234 return ret;
235 }
236 }
237 return NETMANAGER_SUCCESS;
238 }
239
ReinitRoute()240 int32_t ConnManager::ReinitRoute()
241 {
242 NETNATIVE_LOG_D("ConnManager::ReInitRoute");
243 needReinitRouteFlag_ = true;
244 return NETMANAGER_SUCCESS;
245 }
246
AddRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)247 int32_t ConnManager::AddRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
248 {
249 return RouteManager::AddRoute(GetTableType(netId), interfaceName, destination, nextHop);
250 }
251
RemoveRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)252 int32_t ConnManager::RemoveRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
253 {
254 return RouteManager::RemoveRoute(GetTableType(netId), interfaceName, destination, nextHop);
255 }
256
UpdateRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)257 int32_t ConnManager::UpdateRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
258 {
259 return RouteManager::UpdateRoute(GetTableType(netId), interfaceName, destination, nextHop);
260 }
261
GetTableType(int32_t netId)262 RouteManager::TableType ConnManager::GetTableType(int32_t netId)
263 {
264 if (netId == LOCAL_NET_ID) {
265 return RouteManager::LOCAL_NETWORK;
266 } else if (FindVirtualNetwork(netId) != nullptr) {
267 return RouteManager::VPN_NETWORK;
268 } else {
269 return RouteManager::INTERFACE;
270 }
271 }
272
GetFwmarkForNetwork(int32_t netId)273 int32_t ConnManager::GetFwmarkForNetwork(int32_t netId)
274 {
275 return NETMANAGER_ERROR;
276 }
277
SetPermissionForNetwork(int32_t netId,NetworkPermission permission)278 int32_t ConnManager::SetPermissionForNetwork(int32_t netId, NetworkPermission permission)
279 {
280 return NETMANAGER_ERROR;
281 }
282
FindVirtualNetwork(int32_t netId)283 std::shared_ptr<NetsysNetwork> ConnManager::FindVirtualNetwork(int32_t netId)
284 {
285 if (netId == LOCAL_NET_ID) {
286 return nullptr;
287 }
288 auto iter = networks_.find(netId);
289 if (iter == networks_.end() || iter->second == nullptr) {
290 NETNATIVE_LOGE("invalid netId:%{public}d or nw is null.", netId);
291 return nullptr;
292 }
293 if (iter->second->IsPhysical()) {
294 return nullptr;
295 }
296 return iter->second;
297 }
298
AddUidsToNetwork(int32_t netId,const std::vector<NetManagerStandard::UidRange> & uidRanges)299 int32_t ConnManager::AddUidsToNetwork(int32_t netId, const std::vector<NetManagerStandard::UidRange> &uidRanges)
300 {
301 auto netsysNetwork = FindVirtualNetwork(netId);
302 if (netsysNetwork == nullptr) {
303 NETNATIVE_LOGE("cannot add uids to non-virtual network with netId:%{public}d", netId);
304 return NETMANAGER_ERROR;
305 }
306 return static_cast<VirtualNetwork *>(netsysNetwork.get())->AddUids(uidRanges);
307 }
308
RemoveUidsFromNetwork(int32_t netId,const std::vector<NetManagerStandard::UidRange> & uidRanges)309 int32_t ConnManager::RemoveUidsFromNetwork(int32_t netId, const std::vector<NetManagerStandard::UidRange> &uidRanges)
310 {
311 auto netsysNetwork = FindVirtualNetwork(netId);
312 if (netsysNetwork == nullptr) {
313 NETNATIVE_LOGE("cannot remove uids from non-virtual network with netId:%{public}d", netId);
314 return NETMANAGER_ERROR;
315 }
316 return static_cast<VirtualNetwork *>(netsysNetwork.get())->RemoveUids(uidRanges);
317 }
318
GetDumpInfos(std::string & infos)319 void ConnManager::GetDumpInfos(std::string &infos)
320 {
321 static const std::string TAB = " ";
322 infos.append("Netsys connect manager :\n");
323 infos.append(TAB + "default NetId: " + std::to_string(defaultNetId_) + "\n");
324 std::for_each(networks_.begin(), networks_.end(), [&infos](const auto &network) {
325 infos.append(TAB + "NetId:" + std::to_string(network.first));
326 std::string interfaces = TAB + "interfaces: {";
327 for (const auto &interface : network.second->GetAllInterface()) {
328 interfaces.append(interface + ", ");
329 }
330 infos.append(interfaces + "}\n");
331 });
332 }
333 } // namespace nmd
334 } // namespace OHOS
335