1 /*
2 * Copyright (c) 2021-2022 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 "local_network.h"
19 #include "net_manager_constants.h"
20 #include "netnative_log_wrapper.h"
21 #include "physical_network.h"
22
23 namespace OHOS {
24 namespace nmd {
25 using namespace NetManagerStandard;
26 namespace {
27 constexpr int32_t INTERFACE_UNSET = -1;
28 constexpr int32_t LOCAL_NET_ID = 99;
29 } // namespace
30
ConnManager()31 ConnManager::ConnManager()
32 {
33 networks_[LOCAL_NET_ID] = std::make_shared<LocalNetwork>(LOCAL_NET_ID);
34 defaultNetId_ = 0;
35 needReinitRouteFlag_ = false;
36 }
37
~ConnManager()38 ConnManager::~ConnManager()
39 {
40 networks_.clear();
41 }
42
CreatePhysicalNetwork(uint16_t netId,NetworkPermission permission)43 int32_t ConnManager::CreatePhysicalNetwork(uint16_t netId, NetworkPermission permission)
44 {
45 if (needReinitRouteFlag_) {
46 std::set<int32_t> netIds;
47 for (const auto &iter : networks_) {
48 if (iter.first == LOCAL_NET_ID || iter.second == nullptr) {
49 continue;
50 }
51 netIds.insert(iter.second->GetNetId());
52 }
53 for (auto netId : netIds) {
54 RemoveInterfaceFromNetwork(netId, physicalInterfaceName_[netId]);
55 DestroyNetwork(netId);
56 }
57 needReinitRouteFlag_ = false;
58 }
59 std::shared_ptr<NetsysNetwork> network = std::make_shared<PhysicalNetwork>(netId, permission);
60 networks_[netId] = network;
61 return NETMANAGER_SUCCESS;
62 }
63
DestroyNetwork(int32_t netId)64 int32_t ConnManager::DestroyNetwork(int32_t netId)
65 {
66 if (netId == LOCAL_NET_ID) {
67 NETNATIVE_LOGE("Cannot destroy local network");
68 return NETMANAGER_ERROR;
69 }
70 const auto &net = FindNetworkById(netId);
71 if (std::get<0>(net)) {
72 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
73 if (defaultNetId_ == netId) {
74 if (nw->IsPhysical()) {
75 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
76 }
77 defaultNetId_ = 0;
78 }
79 nw->ClearInterfaces();
80 }
81 networks_.erase(netId);
82 return NETMANAGER_SUCCESS;
83 }
84
SetDefaultNetwork(int32_t netId)85 int32_t ConnManager::SetDefaultNetwork(int32_t netId)
86 {
87 if (defaultNetId_ == netId) {
88 return NETMANAGER_SUCCESS;
89 }
90
91 // check if this network exists
92 const auto &net = FindNetworkById(netId);
93 if (std::get<0>(net)) {
94 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
95 if (!nw->IsPhysical()) {
96 NETNATIVE_LOGE("SetDefaultNetwork fail, network :%{public}d is not physical ", netId);
97 return NETMANAGER_ERROR;
98 }
99 static_cast<PhysicalNetwork *>(nw.get())->AddDefault();
100 }
101
102 if (defaultNetId_ != 0) {
103 const auto &defaultNet = FindNetworkById(defaultNetId_);
104 if (std::get<0>(defaultNet)) {
105 std::shared_ptr<NetsysNetwork> nw = std::get<1>(defaultNet);
106 if (!nw->IsPhysical()) {
107 NETNATIVE_LOGE("SetDefaultNetwork fail, defaultNetId_ :%{public}d is not physical", defaultNetId_);
108 return NETMANAGER_ERROR;
109 }
110 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
111 }
112 }
113 defaultNetId_ = netId;
114 return NETMANAGER_SUCCESS;
115 }
116
ClearDefaultNetwork()117 int32_t ConnManager::ClearDefaultNetwork()
118 {
119 if (defaultNetId_ != 0) {
120 const auto &net = FindNetworkById(defaultNetId_);
121 if (std::get<0>(net)) {
122 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
123 if (!nw->IsPhysical()) {
124 NETNATIVE_LOGE("ClearDefaultNetwork fail, defaultNetId_ :%{public}d is not physical", defaultNetId_);
125 return NETMANAGER_ERROR;
126 }
127 static_cast<PhysicalNetwork *>(nw.get())->RemoveDefault();
128 }
129 }
130 defaultNetId_ = 0;
131 return NETMANAGER_SUCCESS;
132 }
133
FindNetworkById(int32_t netId)134 std::tuple<bool, std::shared_ptr<NetsysNetwork>> ConnManager::FindNetworkById(int32_t netId)
135 {
136 NETNATIVE_LOG_D("Entry ConnManager::FindNetworkById netId:%{public}d", netId);
137 std::map<int32_t, std::shared_ptr<NetsysNetwork>>::iterator it;
138 for (it = networks_.begin(); it != networks_.end(); ++it) {
139 if (netId == it->first) {
140 return std::make_tuple(true, it->second);
141 }
142 }
143 return std::make_tuple<bool, std::shared_ptr<NetsysNetwork>>(false, nullptr);
144 }
145
GetDefaultNetwork() const146 int32_t ConnManager::GetDefaultNetwork() const
147 {
148 return defaultNetId_;
149 }
150
GetNetworkForInterface(std::string & interfaceName)151 int32_t ConnManager::GetNetworkForInterface(std::string &interfaceName)
152 {
153 NETNATIVE_LOG_D("Entry ConnManager::GetNetworkForInterface interfaceName:%{public}s", interfaceName.c_str());
154 std::map<int32_t, std::shared_ptr<NetsysNetwork>>::iterator it;
155 for (it = networks_.begin(); it != networks_.end(); ++it) {
156 if (it->second->ExistInterface(interfaceName)) {
157 return it->first;
158 }
159 }
160 return INTERFACE_UNSET;
161 }
162
AddInterfaceToNetwork(int32_t netId,std::string & interfaceName)163 int32_t ConnManager::AddInterfaceToNetwork(int32_t netId, std::string &interfaceName)
164 {
165 NETNATIVE_LOG_D("Entry ConnManager::AddInterfaceToNetwork netId:%{public}d, interfaceName:%{public}s", netId,
166 interfaceName.c_str());
167 int32_t alreadySetNetId = GetNetworkForInterface(interfaceName);
168 if ((alreadySetNetId != netId) && (alreadySetNetId != INTERFACE_UNSET)) {
169 NETNATIVE_LOGE("AddInterfaceToNetwork failed alreadySetNetId:%{public}d", alreadySetNetId);
170 return NETMANAGER_ERROR;
171 }
172
173 const auto &net = FindNetworkById(netId);
174 if (std::get<0>(net)) {
175 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
176 physicalInterfaceName_[netId] = interfaceName;
177 return nw->AddInterface(interfaceName);
178 }
179 return NETMANAGER_ERROR;
180 }
181
RemoveInterfaceFromNetwork(int32_t netId,std::string & interfaceName)182 int32_t ConnManager::RemoveInterfaceFromNetwork(int32_t netId, std::string &interfaceName)
183 {
184 int32_t alreadySetNetId = GetNetworkForInterface(interfaceName);
185 if ((alreadySetNetId != netId) || (alreadySetNetId == INTERFACE_UNSET)) {
186 return NETMANAGER_SUCCESS;
187 } else if (alreadySetNetId == netId) {
188 const auto &net = FindNetworkById(netId);
189 if (std::get<0>(net)) {
190 std::shared_ptr<NetsysNetwork> nw = std::get<1>(net);
191 int32_t ret = nw->RemoveInterface(interfaceName);
192 physicalInterfaceName_.erase(netId);
193 return ret;
194 }
195 }
196 return NETMANAGER_SUCCESS;
197 }
198
ReinitRoute()199 int32_t ConnManager::ReinitRoute()
200 {
201 NETNATIVE_LOG_D("ConnManager::ReInitRoute");
202 needReinitRouteFlag_ = true;
203 return NETMANAGER_SUCCESS;
204 }
205
AddRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)206 int32_t ConnManager::AddRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
207 {
208 return RouteManager::AddRoute(GetTableType(netId), interfaceName, destination, nextHop);
209 }
210
RemoveRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)211 int32_t ConnManager::RemoveRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
212 {
213 return RouteManager::RemoveRoute(GetTableType(netId), interfaceName, destination, nextHop);
214 }
215
UpdateRoute(int32_t netId,std::string interfaceName,std::string destination,std::string nextHop)216 int32_t ConnManager::UpdateRoute(int32_t netId, std::string interfaceName, std::string destination, std::string nextHop)
217 {
218 return RouteManager::UpdateRoute(GetTableType(netId), interfaceName, destination, nextHop);
219 }
220
GetTableType(int32_t netId)221 RouteManager::TableType ConnManager::GetTableType(int32_t netId)
222 {
223 RouteManager::TableType tableType;
224 if (netId == LOCAL_NET_ID) {
225 tableType = RouteManager::LOCAL_NETWORK;
226 } else {
227 tableType = RouteManager::INTERFACE;
228 }
229 return tableType;
230 }
231
GetFwmarkForNetwork(int32_t netId)232 int32_t ConnManager::GetFwmarkForNetwork(int32_t netId)
233 {
234 return NETMANAGER_ERROR;
235 }
236
SetPermissionForNetwork(int32_t netId,NetworkPermission permission)237 int32_t ConnManager::SetPermissionForNetwork(int32_t netId, NetworkPermission permission)
238 {
239 return NETMANAGER_ERROR;
240 }
241
GetDumpInfos(std::string & infos)242 void ConnManager::GetDumpInfos(std::string &infos)
243 {
244 static const std::string TAB = " ";
245 infos.append("Netsys connect manager :\n");
246 infos.append(TAB + "default NetId: " + std::to_string(defaultNetId_) + "\n");
247 std::for_each(networks_.begin(), networks_.end(), [&infos](const auto &network) {
248 infos.append(TAB + "NetId:" + std::to_string(network.first));
249 std::string interfaces = TAB + "interfaces: {";
250 for (const auto &interface : network.second->GetAllInterface()) {
251 interfaces.append(interface + ", ");
252 }
253 infos.append(interfaces + "}\n");
254 });
255 }
256 } // namespace nmd
257 } // namespace OHOS
258