1 /*
2 * Copyright (c) 2022-2024 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 "net_manager_center.h"
17 #include "net_manager_constants.h"
18 #include "net_manager_ext_constants.h"
19 #include "netmgr_ext_log_wrapper.h"
20 #include "netsys_controller.h"
21 #include "networkshare_sub_statemachine.h"
22 #include "networkshare_tracker.h"
23 #include "route_utils.h"
24 #include <ifaddrs.h>
25 #include <random>
26 #include <regex>
27 #include <sys/types.h>
28
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 constexpr const char *NEXT_HOT = "0.0.0.0";
33 constexpr const char *IPV6_NEXT_HOT = "";
34 const std::regex REGEX_MAC(std::string(R"(^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$)"));
35
36 /** https://www.rfc-editor.org/rfc/rfc4291
37 * The type of an IPv6 address is identified by the high-order bits of
38 * the address, as follows:
39 *
40 * Address type Binary prefix IPv6 notation Section
41 * ------------ ------------- ------------- -------
42 * Unspecified 00...0 (128 bits) ::/128 2.5.2
43 * Loopback 00...1 (128 bits) ::1/128 2.5.3
44 * Multicast 11111111 FF00::/8 2.7
45 * Link-Local unicast 1111111010 FE80::/10 2.5.6
46 * Global Unicast (everything else)
47 **/
48 constexpr const char *DEFAULT_LINK_STR = "fe80";
49 constexpr const char *DEFAULT_LINK_ROUTE = "fe80::/64";
50 constexpr const char *DEFAULT_PREFIX = "/64";
51 constexpr const char *ERROR_MSG_CONFIG_FORWARD = "Config Forward failed";
52 constexpr const char *ERROR_MSG_ADD_ROUTE_STRATEGY = "Add Route Strategy failed";
53 constexpr const char *ERROR_MSG_ADD_ROUTE_RULE = "Add Route Rule failed";
54 constexpr const char *ERROR_MSG_REMOVE_ROUTE_RULE = "Remove Route Rule failed";
55 constexpr const char *EMPTY_UPSTREAM_IFACENAME = "";
56 constexpr int32_t IP_V4 = 0;
57 constexpr uint8_t BYTE_BIT = 8;
58 constexpr int32_t PREFIX_LEN = 64;
59 constexpr int32_t MAC_BLOCK = 2;
60 constexpr int32_t HEX_BASE = 16;
61 constexpr int32_t HALF_IN6ADDR = 8;
62 constexpr int32_t INTF_ID_LEN = 64;
63 constexpr int32_t MAX_IPV6_PREFIX_LENGTH = 128;
64 constexpr int32_t BYTE_ZERO = 0;
65 constexpr int32_t BYTE_ONE = 1;
66 constexpr int32_t BYTE_TWO = 2;
67 constexpr int32_t BYTE_THREE = 3;
68 constexpr int32_t BYTE_FOUR = 4;
69 constexpr int32_t BYTE_FIVE = 5;
70 constexpr int32_t BYTE_SIX = 6;
71 constexpr int32_t BYTE_SEVEN = 7;
72 constexpr int32_t EUI64_INVERT = 0x02;
73 constexpr int32_t EUI64_FF = 0xFF;
74 constexpr int32_t EUI64_FE = 0xFE;
75 } // namespace
76
NetworkShareSubStateMachine(const std::string & ifaceName,const SharingIfaceType & interfaceType,const std::shared_ptr<NetworkShareConfiguration> & configuration)77 NetworkShareSubStateMachine::NetworkShareSubStateMachine(
78 const std::string &ifaceName, const SharingIfaceType &interfaceType,
79 const std::shared_ptr<NetworkShareConfiguration> &configuration)
80 : ifaceName_(ifaceName), netShareType_(interfaceType), configuration_(configuration)
81 {
82 CreateInitStateTable();
83 CreateSharedStateTable();
84 }
85
~NetworkShareSubStateMachine()86 __attribute__((no_sanitize("cfi"))) NetworkShareSubStateMachine::~NetworkShareSubStateMachine() {}
87
CreateInitStateTable()88 void NetworkShareSubStateMachine::CreateInitStateTable()
89 {
90 SubSmStateTable temp;
91 temp.event_ = CMD_NETSHARE_REQUESTED;
92 temp.curState_ = SUBSTATE_INIT;
93 temp.func_ = &NetworkShareSubStateMachine::HandleInitSharingRequest;
94 temp.nextState_ = SUBSTATE_SHARED;
95 stateTable_.push_back(temp);
96
97 temp.event_ = CMD_INTERFACE_DOWN;
98 temp.curState_ = SUBSTATE_INIT;
99 temp.func_ = &NetworkShareSubStateMachine::HandleInitInterfaceDown;
100 temp.nextState_ = SUBSTATE_UNAVAILABLE;
101 stateTable_.push_back(temp);
102 }
103
CreateSharedStateTable()104 void NetworkShareSubStateMachine::CreateSharedStateTable()
105 {
106 SubSmStateTable temp;
107 temp.event_ = CMD_NETSHARE_UNREQUESTED;
108 temp.curState_ = SUBSTATE_SHARED;
109 temp.func_ = &NetworkShareSubStateMachine::HandleSharedUnrequest;
110 temp.nextState_ = SUBSTATE_INIT;
111 stateTable_.push_back(temp);
112
113 temp.event_ = CMD_INTERFACE_DOWN;
114 temp.curState_ = SUBSTATE_SHARED;
115 temp.func_ = &NetworkShareSubStateMachine::HandleSharedInterfaceDown;
116 temp.nextState_ = SUBSTATE_UNAVAILABLE;
117 stateTable_.push_back(temp);
118
119 temp.event_ = CMD_NETSHARE_CONNECTION_CHANGED;
120 temp.curState_ = SUBSTATE_SHARED;
121 temp.func_ = &NetworkShareSubStateMachine::HandleSharedConnectionChange;
122 temp.nextState_ = NO_NEXT_STATE;
123 stateTable_.push_back(temp);
124
125 temp.event_ = CMD_IP_FORWARDING_ENABLE_ERROR;
126 temp.curState_ = SUBSTATE_SHARED;
127 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
128 temp.nextState_ = SUBSTATE_INIT;
129 stateTable_.push_back(temp);
130
131 temp.event_ = CMD_IP_FORWARDING_DISABLE_ERROR;
132 temp.curState_ = SUBSTATE_SHARED;
133 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
134 temp.nextState_ = SUBSTATE_INIT;
135 stateTable_.push_back(temp);
136
137 temp.event_ = CMD_START_SHARING_ERROR;
138 temp.curState_ = SUBSTATE_SHARED;
139 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
140 temp.nextState_ = SUBSTATE_INIT;
141 stateTable_.push_back(temp);
142
143 temp.event_ = CMD_STOP_SHARING_ERROR;
144 temp.curState_ = SUBSTATE_SHARED;
145 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
146 temp.nextState_ = SUBSTATE_INIT;
147 stateTable_.push_back(temp);
148
149 temp.event_ = CMD_SET_DNS_FORWARDERS_ERROR;
150 temp.curState_ = SUBSTATE_SHARED;
151 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
152 temp.nextState_ = SUBSTATE_INIT;
153 stateTable_.push_back(temp);
154 }
155
SubSmStateSwitch(int newState)156 void NetworkShareSubStateMachine::SubSmStateSwitch(int newState)
157 {
158 int oldState = curState_;
159 curState_ = newState;
160 NETMGR_EXT_LOG_I("Sub SM from[%{public}d] to[%{public}d].", oldState, newState);
161
162 if (oldState == SUBSTATE_INIT) {
163 InitStateExit();
164 } else if (oldState == SUBSTATE_SHARED) {
165 SharedStateExit();
166 } else if (oldState == SUBSTATE_UNAVAILABLE) {
167 UnavailableStateExit();
168 } else {
169 NETMGR_EXT_LOG_E("oldState is unknow type value.");
170 }
171
172 if (newState == SUBSTATE_INIT) {
173 InitStateEnter();
174 } else if (newState == SUBSTATE_SHARED) {
175 SharedStateEnter();
176 } else if (newState == SUBSTATE_UNAVAILABLE) {
177 UnavailableStateEnter();
178 } else {
179 NETMGR_EXT_LOG_E("newState is unknow type value.");
180 }
181 }
182
getUsefulMutex()183 ffrt::recursive_mutex &NetworkShareSubStateMachine::getUsefulMutex()
184 {
185 auto mainStateMachinePtr = NetworkShareTracker::GetInstance().GetMainStateMachine();
186 if (!mainStateMachinePtr) {
187 NETMGR_EXT_LOG_W("The point of NetworkShareMainStateMachine is nullptr, use mutex in this category.");
188 return mutex_;
189 }
190 return mainStateMachinePtr->GetEventMutex();
191 }
192
SubSmEventHandle(int eventId,const std::any & messageObj)193 void NetworkShareSubStateMachine::SubSmEventHandle(int eventId, const std::any &messageObj)
194 {
195 std::lock_guard<ffrt::recursive_mutex> lock(getUsefulMutex());
196 int nextState = NO_NEXT_STATE;
197 int (NetworkShareSubStateMachine::*eventFunc)(const std::any &messageObj) = nullptr;
198 for (const auto &iterState : stateTable_) {
199 if ((eventId == iterState.event_) && (curState_ == iterState.curState_)) {
200 eventFunc = iterState.func_;
201 nextState = iterState.nextState_;
202 break;
203 }
204 }
205 if (eventFunc == nullptr) {
206 NETMGR_EXT_LOG_W("SubSM currentstate[%{public}d] eventId[%{public}d] is not matched.", curState_, eventId);
207 return;
208 }
209 (this->*eventFunc)(messageObj);
210 if (nextState >= SUBSTATE_INIT && nextState < SUBSTATE_MAX) {
211 SubSmStateSwitch(nextState);
212 }
213
214 NETMGR_EXT_LOG_I("SubSM eventId[%{public}d] handle successfull.", eventId);
215 }
216
GetDownIfaceName(std::string & downIface)217 void NetworkShareSubStateMachine::GetDownIfaceName(std::string &downIface)
218 {
219 downIface = ifaceName_;
220 }
221
GetUpIfaceName(std::string & upIface)222 void NetworkShareSubStateMachine::GetUpIfaceName(std::string &upIface)
223 {
224 upIface = upstreamIfaceName_;
225 }
226
InitStateEnter()227 void NetworkShareSubStateMachine::InitStateEnter()
228 {
229 if (trackerCallback_ == nullptr) {
230 NETMGR_EXT_LOG_E("Enter Sub StateMachine Init State error, trackerCallback_ is null.");
231 return;
232 }
233 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Init State.", ifaceName_.c_str());
234 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_AVAILABLE, lastError_);
235 }
236
InitStateExit()237 void NetworkShareSubStateMachine::InitStateExit()
238 {
239 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Init State.", ifaceName_.c_str());
240 }
241
HandleInitSharingRequest(const std::any & messageObj)242 int NetworkShareSubStateMachine::HandleInitSharingRequest(const std::any &messageObj)
243 {
244 (void)messageObj;
245 lastError_ = NETMANAGER_EXT_SUCCESS;
246 return NETMANAGER_EXT_SUCCESS;
247 }
248
HandleInitInterfaceDown(const std::any & messageObj)249 int NetworkShareSubStateMachine::HandleInitInterfaceDown(const std::any &messageObj)
250 {
251 (void)messageObj;
252 return NETMANAGER_EXT_SUCCESS;
253 }
254
GetShareIpv6Prefix(const std::string & iface)255 bool NetworkShareSubStateMachine::GetShareIpv6Prefix(const std::string &iface)
256 {
257 ifaddrs *ifaddr = nullptr;
258 char ipv6Addr[INET6_ADDRSTRLEN] = {};
259 if (getifaddrs(&ifaddr)) {
260 NETMGR_EXT_LOG_E("getifaddrs err!");
261 return false;
262 }
263 for (auto ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
264 if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET6 || std::string(ifa->ifa_name) != iface) {
265 continue;
266 }
267 if (getnameinfo(ifa->ifa_addr, sizeof(sockaddr_in6), ipv6Addr, NI_MAXHOST, nullptr, 0, NI_NUMERICHOST) != 0) {
268 NETMGR_EXT_LOG_E("getnameinfo err!");
269 break;
270 }
271 if (strstr(ipv6Addr, DEFAULT_LINK_STR) != nullptr) {
272 continue;
273 }
274 IpPrefix ipPrefix;
275 inet_pton(AF_INET6, ipv6Addr, &ipPrefix.address);
276 inet_pton(AF_INET6, ipv6Addr, &ipPrefix.prefix);
277 if (memset_s(ipPrefix.prefix.s6_addr + HALF_IN6ADDR, HALF_IN6ADDR, 0, HALF_IN6ADDR) != EOK) {
278 NETMGR_EXT_LOG_E("Failed memset_s");
279 break;
280 }
281 ipPrefix.prefixesLength = PREFIX_LEN;
282 lastRaParams_.prefixes_.emplace_back(ipPrefix);
283 }
284 freeifaddrs(ifaddr);
285 return true;
286 }
287
MacToEui64Addr(std::string & mac)288 std::string NetworkShareSubStateMachine::MacToEui64Addr(std::string &mac)
289 {
290 sockaddr macSockaddr = {};
291 for (size_t i = 0; i < mac.length(); i += MAC_SSCANF_SPACE) {
292 std::string byte = mac.substr(i, MAC_BLOCK);
293 macSockaddr.sa_data[i / MAC_SSCANF_SPACE] = static_cast<char>(strtol(byte.c_str(), nullptr, HEX_BASE));
294 }
295 unsigned char eui64Sa[HALF_IN6ADDR] = {0};
296 char eui64Addr[INTF_ID_LEN] = {0};
297 eui64Sa[BYTE_ZERO] =
298 macSockaddr.sa_data[BYTE_ZERO] | ((macSockaddr.sa_data[BYTE_ZERO] & EUI64_INVERT) ^ EUI64_INVERT);
299 eui64Sa[BYTE_ONE] = macSockaddr.sa_data[BYTE_ONE];
300 eui64Sa[BYTE_TWO] = macSockaddr.sa_data[BYTE_TWO];
301 eui64Sa[BYTE_THREE] = EUI64_FF;
302 eui64Sa[BYTE_FOUR] = EUI64_FE;
303 eui64Sa[BYTE_FIVE] = macSockaddr.sa_data[BYTE_THREE];
304 eui64Sa[BYTE_SIX] = macSockaddr.sa_data[BYTE_FOUR];
305 eui64Sa[BYTE_SEVEN] = macSockaddr.sa_data[BYTE_FIVE];
306 if (snprintf_s(eui64Addr, sizeof(eui64Addr), sizeof(eui64Addr) - 1, "%02x%02x:%02x%02x:%02x%02x:%02x%02x",
307 eui64Sa[BYTE_ZERO], eui64Sa[BYTE_ONE], eui64Sa[BYTE_TWO], eui64Sa[BYTE_THREE], eui64Sa[BYTE_FOUR],
308 eui64Sa[BYTE_FIVE], eui64Sa[BYTE_SIX], eui64Sa[BYTE_SEVEN]) < 0) {
309 return std::string{};
310 }
311 return std::string(eui64Addr);
312 }
313
GenerateIpv6(const std::string & iface)314 int32_t NetworkShareSubStateMachine::GenerateIpv6(const std::string &iface)
315 {
316 std::string eui64Addr = std::string("::") + MacToEui64Addr(lastRaParams_.macAddr_);
317 in6_addr eui64 = IN6ADDR_ANY_INIT;
318 inet_pton(AF_INET6, eui64Addr.c_str(), &eui64);
319 for (IpPrefix &prefix : lastRaParams_.prefixes_) {
320 for (int32_t index = HALF_IN6ADDR; index < MAX_IPV6_PREFIX_LENGTH / BYTE_BIT; ++index) {
321 prefix.address.s6_addr[index] = eui64.s6_addr[index];
322 }
323 prefix.address.s6_addr[HALF_IN6ADDR - 1]++;
324 prefix.prefix.s6_addr[HALF_IN6ADDR - 1]++;
325 }
326 return NETMANAGER_EXT_SUCCESS;
327 }
328
StartIpv6()329 void NetworkShareSubStateMachine::StartIpv6()
330 {
331 NETMGR_EXT_LOG_I("Start ipv6 for iface: %{public}s", ifaceName_.c_str());
332 if (lastRaParams_.prefixes_.size() == 0) {
333 NETMGR_EXT_LOG_I("have nothing ipv6 address!");
334 return;
335 }
336 if (raDaemon_ == nullptr) {
337 raDaemon_ = std::make_shared<RouterAdvertisementDaemon>();
338 }
339 if (raDaemon_->Init(ifaceName_) != NETMANAGER_EXT_SUCCESS) {
340 NETMGR_EXT_LOG_E("Init ipv6 share failed");
341 return;
342 }
343 int32_t mtu = NetsysController::GetInstance().GetInterfaceMtu(ifaceName_);
344 lastRaParams_.mtu_ = mtu > IPV6_MIN_MTU ? mtu : IPV6_MIN_MTU;
345 raDaemon_->BuildNewRa(lastRaParams_);
346 if (raDaemon_->StartRa() != NETMANAGER_EXT_SUCCESS) {
347 NETMGR_EXT_LOG_E("StartRa failed");
348 StopIpv6();
349 }
350 }
351
StopIpv6()352 void NetworkShareSubStateMachine::StopIpv6()
353 {
354 NETMGR_EXT_LOG_I("Stop ipv6 for iface: %{public}s", ifaceName_.c_str());
355 if (raDaemon_ != nullptr) {
356 raDaemon_->StopRa();
357 lastRaParams_.Clear();
358 raDaemon_ = nullptr;
359 }
360 }
SharedStateEnter()361 void NetworkShareSubStateMachine::SharedStateEnter()
362 {
363 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Shared State.", ifaceName_.c_str());
364 if (trackerCallback_ == nullptr) {
365 NETMGR_EXT_LOG_E("Enter Sub StateMachine Shared State error, trackerCallback_ is null.");
366 return;
367 }
368 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_SHARED, lastError_);
369 if (!ConfigureShareDhcp(true)) {
370 lastError_ = NETWORKSHARE_ERROR_IFACE_CFG_ERROR;
371 NETMGR_EXT_LOG_E("Enter sub StateMachine[%{public}s] Shared State configIpv4 error.", ifaceName_.c_str());
372 }
373 StartIpv6();
374 }
375
SharedStateExit()376 void NetworkShareSubStateMachine::SharedStateExit()
377 {
378 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Shared State.", ifaceName_.c_str());
379 CleanupUpstreamInterface();
380 ConfigureShareDhcp(false);
381 StopIpv6();
382 }
383
HandleSharedUnrequest(const std::any & messageObj)384 int NetworkShareSubStateMachine::HandleSharedUnrequest(const std::any &messageObj)
385 {
386 (void)messageObj;
387 return NETMANAGER_EXT_SUCCESS;
388 }
389
HandleSharedInterfaceDown(const std::any & messageObj)390 int NetworkShareSubStateMachine::HandleSharedInterfaceDown(const std::any &messageObj)
391 {
392 (void)messageObj;
393 return NETMANAGER_EXT_SUCCESS;
394 }
395
HandleSharedConnectionChange(const std::any & messageObj)396 int NetworkShareSubStateMachine::HandleSharedConnectionChange(const std::any &messageObj)
397 {
398 std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo =
399 std::any_cast<std::shared_ptr<UpstreamNetworkInfo>>(messageObj);
400 if (upstreamNetInfo == nullptr) {
401 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] upstreamNetInfo is null, need clean.", ifaceName_.c_str());
402 CleanupUpstreamInterface();
403 upstreamIfaceName_ = EMPTY_UPSTREAM_IFACENAME;
404 return NETMANAGER_EXT_SUCCESS;
405 }
406 HandleConnectionChanged(upstreamNetInfo);
407 return NETMANAGER_EXT_SUCCESS;
408 }
409
HandleSharedErrors(const std::any & messageObj)410 int NetworkShareSubStateMachine::HandleSharedErrors(const std::any &messageObj)
411 {
412 (void)messageObj;
413 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] SharedState has ERROR.", ifaceName_.c_str());
414 lastError_ = NETWORKSHARE_ERROR_INTERNAL_ERROR;
415 return NETMANAGER_EXT_SUCCESS;
416 }
417
UnavailableStateEnter()418 void NetworkShareSubStateMachine::UnavailableStateEnter()
419 {
420 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Unavailable State.", ifaceName_.c_str());
421 lastError_ = NETMANAGER_EXT_SUCCESS;
422 if (trackerCallback_ == nullptr) {
423 NETMGR_EXT_LOG_E("Enter Sub StateMachine Unavailable State error, trackerCallback_ is null.");
424 return;
425 }
426 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_UNAVAILABLE, NETMANAGER_EXT_SUCCESS);
427 }
428
UnavailableStateExit()429 void NetworkShareSubStateMachine::UnavailableStateExit()
430 {
431 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Unavailable State.", ifaceName_.c_str());
432 }
433
HandleConnectionChanged(const std::shared_ptr<UpstreamNetworkInfo> & upstreamNetInfo)434 void NetworkShareSubStateMachine::HandleConnectionChanged(const std::shared_ptr<UpstreamNetworkInfo> &upstreamNetInfo)
435 {
436 if (upstreamNetInfo == nullptr) {
437 return;
438 }
439 if (upstreamNetInfo->netLinkPro_ == nullptr) {
440 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] HandleConnectionChanged netLinkPro_ is null.",
441 ifaceName_.c_str());
442 return;
443 }
444 if (!HasChangeUpstreamIfaceSet(upstreamNetInfo->netLinkPro_->ifaceName_)) {
445 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] HandleConnectionChanged Upstream Iface no change.",
446 ifaceName_.c_str());
447 return;
448 }
449
450 CleanupUpstreamInterface();
451 upstreamIfaceName_ = upstreamNetInfo->netLinkPro_->ifaceName_;
452
453 HandleConnection();
454 AddRoutesToLocalNetwork();
455 AddIpv6InfoToLocalNetwork();
456 }
457
HandleConnection()458 void NetworkShareSubStateMachine::HandleConnection()
459 {
460 int32_t result = NetsysController::GetInstance().IpfwdAddInterfaceForward(ifaceName_, upstreamIfaceName_);
461 if (result != NETSYS_SUCCESS) {
462 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
463 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
464 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_CONFIG_FORWARD,
465 NetworkShareEventType::SETUP_EVENT);
466 NETMGR_EXT_LOG_E(
467 "Sub StateMachine[%{public}s] IpfwdAddInterfaceForward newIface[%{public}s] error[%{public}d].",
468 ifaceName_.c_str(), upstreamIfaceName_.c_str(), result);
469 lastError_ = NETWORKSHARE_ERROR_ENABLE_FORWARDING_ERROR;
470 SubSmStateSwitch(SUBSTATE_INIT);
471 return;
472 }
473
474 result = NetsysController::GetInstance().NetworkAddInterface(LOCAL_NET_ID, ifaceName_);
475 if (result != NETMANAGER_SUCCESS) {
476 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
477 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
478 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_STRATEGY,
479 NetworkShareEventType::SETUP_EVENT);
480 NETMGR_EXT_LOG_E(
481 "Sub StateMachine[%{public}s] SharedState NetworkAddInterface newIface[%{public}s] error[%{public}d].",
482 ifaceName_.c_str(), upstreamIfaceName_.c_str(), result);
483 NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ifaceName_, upstreamIfaceName_);
484 lastError_ = NETWORKSHARE_ERROR_ENABLE_FORWARDING_ERROR;
485 SubSmStateSwitch(SUBSTATE_INIT);
486 return;
487 }
488 }
489
RemoveRoutesToLocalNetwork()490 void NetworkShareSubStateMachine::RemoveRoutesToLocalNetwork()
491 {
492 std::string destination;
493 if (!FindDestinationAddr(destination)) {
494 NETMGR_EXT_LOG_E("Get Destination fail");
495 return;
496 }
497 int32_t result =
498 NetsysController::GetInstance().NetworkRemoveRoute(LOCAL_NET_ID, ifaceName_, destination, NEXT_HOT);
499 if (result != NETSYS_SUCCESS) {
500 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
501 netShareType_, NetworkShareEventOperator::OPERATION_CANCEL_FORWARD,
502 NetworkShareEventErrorType::ERROR_CANCEL_FORWARD, ERROR_MSG_REMOVE_ROUTE_RULE,
503 NetworkShareEventType::CANCEL_EVENT);
504 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Remove Route error[%{public}d].", ifaceName_.c_str(), result);
505 }
506 }
507
AddRoutesToLocalNetwork()508 void NetworkShareSubStateMachine::AddRoutesToLocalNetwork()
509 {
510 std::string destination;
511 if (!FindDestinationAddr(destination)) {
512 NETMGR_EXT_LOG_E("Get Destination fail");
513 return;
514 }
515 int32_t result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, NEXT_HOT);
516 if (result != NETSYS_SUCCESS) {
517 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
518 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
519 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
520 NetworkShareEventType::SETUP_EVENT);
521 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
522 }
523 }
524
AddIpv6AddrToLocalNetwork()525 void NetworkShareSubStateMachine::AddIpv6AddrToLocalNetwork()
526 {
527 char address[INET6_ADDRSTRLEN] = {0};
528 char addressPrefix[INET6_ADDRSTRLEN] = {0};
529 std::string destination;
530 int32_t result = NETSYS_SUCCESS;
531 for (const auto &prefix : lastRaParams_.prefixes_) {
532 inet_ntop(AF_INET6, &(prefix.address), address, sizeof(address));
533 if (NetsysController::GetInstance().AddInterfaceAddress(ifaceName_, address, PREFIX_LEN) != 0) {
534 NETMGR_EXT_LOG_E("Failed setting ipv6 address");
535 return;
536 }
537 inet_ntop(AF_INET6, &(prefix.prefix), addressPrefix, sizeof(addressPrefix));
538 destination = std::string(addressPrefix) + DEFAULT_PREFIX;
539 result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, IPV6_NEXT_HOT);
540 if (result != NETSYS_SUCCESS) {
541 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
542 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
543 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
544 NetworkShareEventType::SETUP_EVENT);
545 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
546 }
547 }
548 destination = std::string(DEFAULT_LINK_ROUTE);
549 result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, IPV6_NEXT_HOT);
550 if (result != NETSYS_SUCCESS) {
551 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
552 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
553 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
554 NetworkShareEventType::SETUP_EVENT);
555 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
556 }
557 }
558
AddIpv6InfoToLocalNetwork()559 void NetworkShareSubStateMachine::AddIpv6InfoToLocalNetwork()
560 {
561 if (!GetWifiApDstIpv6Addr()) {
562 NETMGR_EXT_LOG_E("have nothing ipv6 params!");
563 return;
564 }
565 AddIpv6AddrToLocalNetwork();
566 }
567
FindDestinationAddr(std::string & destination)568 bool NetworkShareSubStateMachine::FindDestinationAddr(std::string &destination)
569 {
570 if (netShareType_ == SharingIfaceType::SHARING_BLUETOOTH) {
571 if (!GetBtDestinationAddr(destination)) {
572 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get btpan Destination Addr failed.",
573 ifaceName_.c_str());
574 return false;
575 }
576 return true;
577 }
578 if (netShareType_ == SharingIfaceType::SHARING_WIFI) {
579 if (!GetWifiApDestinationAddr(destination)) {
580 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get wifi Destination Addr failed.",
581 ifaceName_.c_str());
582 return false;
583 }
584 return true;
585 }
586 if (netShareType_ == SharingIfaceType::SHARING_USB) {
587 if (!GetUsbDestinationAddr(destination)) {
588 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get usb Destination Addr failed.",
589 ifaceName_.c_str());
590 return false;
591 }
592 return true;
593 }
594 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route sharetype is unknown.", ifaceName_.c_str());
595 return false;
596 }
597
GetWifiHotspotDhcpFlag()598 bool NetworkShareSubStateMachine::GetWifiHotspotDhcpFlag()
599 {
600 if (configuration_ == nullptr) {
601 return false;
602 }
603 return configuration_->GetWifiHotspotSetDhcpFlag();
604 }
605
GetBtDestinationAddr(std::string & addrStr)606 bool NetworkShareSubStateMachine::GetBtDestinationAddr(std::string &addrStr)
607 {
608 if (configuration_ == nullptr) {
609 NETMGR_EXT_LOG_E("GetBtDestinationAddr configuration is null.");
610 return false;
611 }
612 std::string btpanIpv4Addr = configuration_->GetBtpanIpv4Addr();
613 if (btpanIpv4Addr.empty()) {
614 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get btpan ipv4 addr failed.", ifaceName_.c_str());
615 return false;
616 }
617 std::string::size_type dotPos = btpanIpv4Addr.rfind(".");
618 if (dotPos == std::string::npos) {
619 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] btpan ipv4 addr error.", ifaceName_.c_str());
620 return false;
621 }
622 std::string routeSuffix = configuration_->GetRouteSuffix();
623 if (routeSuffix.empty()) {
624 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
625 return false;
626 }
627
628 addrStr = btpanIpv4Addr.substr(0, dotPos) + routeSuffix;
629 return true;
630 }
631
GetWifiApDestinationAddr(std::string & addrStr)632 bool NetworkShareSubStateMachine::GetWifiApDestinationAddr(std::string &addrStr)
633 {
634 if (configuration_ == nullptr) {
635 NETMGR_EXT_LOG_E("GetWifiApDestinationAddr configuration is null.");
636 return false;
637 }
638 std::string wifiIpv4Addr = configuration_->GetWifiHotspotIpv4Addr();
639 if (wifiIpv4Addr.empty()) {
640 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get wifi ipv4 addr failed.", ifaceName_.c_str());
641 return false;
642 }
643 std::string::size_type dotPos = wifiIpv4Addr.rfind(".");
644 if (dotPos == std::string::npos) {
645 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] wifi ipv4 addr error.", ifaceName_.c_str());
646 return false;
647 }
648 std::string routeSuffix = configuration_->GetRouteSuffix();
649 if (routeSuffix.empty()) {
650 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
651 return false;
652 }
653 addrStr = wifiIpv4Addr.substr(0, dotPos) + routeSuffix;
654 return true;
655 }
656
GetWifiApDstIpv6Addr()657 bool NetworkShareSubStateMachine::GetWifiApDstIpv6Addr()
658 {
659 lastRaParams_.Clear();
660 OHOS::nmd::InterfaceConfigurationParcel config;
661 config.ifName = ifaceName_;
662 if (NetsysController::GetInstance().GetInterfaceConfig(config) != ERR_NONE) {
663 NETMGR_EXT_LOG_E("Get interface mac err!");
664 return false;
665 }
666 if (!std::regex_match(config.hwAddr, REGEX_MAC)) {
667 NETMGR_EXT_LOG_E("Get interface mac format err!");
668 return false;
669 }
670 lastRaParams_.macAddr_ = config.hwAddr;
671 if (!GetShareIpv6Prefix(upstreamIfaceName_)) {
672 NETMGR_EXT_LOG_E("Get ipv6 addr for iface[%{public}s fail.", upstreamIfaceName_.c_str());
673 return false;
674 }
675 if (lastRaParams_.prefixes_.size() == 0) {
676 NETMGR_EXT_LOG_E("have nothing ipv6 address for iface[%{public}s!", upstreamIfaceName_.c_str());
677 return false;
678 }
679 if (GenerateIpv6(upstreamIfaceName_) != NETMANAGER_EXT_SUCCESS) {
680 NETMGR_EXT_LOG_E("Generate ipv6 adress Fail %{public}s", upstreamIfaceName_.c_str());
681 return false;
682 }
683 return true;
684 }
685
GetUsbDestinationAddr(std::string & addrStr)686 bool NetworkShareSubStateMachine::GetUsbDestinationAddr(std::string &addrStr)
687 {
688 if (configuration_ == nullptr) {
689 NETMGR_EXT_LOG_E("GetUsbDestinationAddr configuration is null.");
690 return false;
691 }
692 std::string usbIpv4Addr = configuration_->GetUsbRndisIpv4Addr();
693 if (usbIpv4Addr.empty()) {
694 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get usb ipv4 addr failed.", ifaceName_.c_str());
695 return false;
696 }
697 std::string::size_type dotPos = usbIpv4Addr.rfind(".");
698 if (dotPos == std::string::npos) {
699 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] usb ipv4 addr error.", ifaceName_.c_str());
700 return false;
701 }
702 std::string routeSuffix = configuration_->GetRouteSuffix();
703 if (routeSuffix.empty()) {
704 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
705 return false;
706 }
707 addrStr = usbIpv4Addr.substr(0, dotPos) + routeSuffix;
708 return true;
709 }
710
StartDhcp(const std::shared_ptr<INetAddr> & netAddr)711 bool NetworkShareSubStateMachine::StartDhcp(const std::shared_ptr<INetAddr> &netAddr)
712 {
713 if (netAddr == nullptr) {
714 NETMGR_EXT_LOG_E("StartDhcp netAddr is null.");
715 return false;
716 }
717 std::string endIp;
718 std::string mask;
719 if (!CheckConfig(endIp, mask)) {
720 NETMGR_EXT_LOG_E("StartDhcp Get necessary config failed.");
721 return false;
722 }
723
724 std::string ipAddr = netAddr->address_;
725 std::string::size_type pos = ipAddr.rfind(".");
726 if (pos == std::string::npos) {
727 NETMGR_EXT_LOG_E("StartDhcp addr is error.");
728 return false;
729 }
730 std::string ipHead = ipAddr.substr(0, pos);
731 std::string ipEnd = ipAddr.substr(pos + 1);
732 std::string startIp = std::to_string(atoi(ipEnd.c_str()) + 1);
733
734 std::string strStartip = ipHead + "." + startIp;
735 std::string strEndip = ipHead + "." + endIp;
736
737 DhcpRange range;
738 range.iptype = IP_V4;
739 if (!SetRange(range, ipHead, strStartip, strEndip, mask)) {
740 return false;
741 }
742
743 if (SetDhcpRange(ifaceName_.c_str(), &range) != DHCP_SUCCESS) {
744 NETMGR_EXT_LOG_E("StartDhcp SetDhcpRange failed.");
745 return false;
746 }
747
748 if (StartDhcpServer(ifaceName_.c_str()) != DHCP_SUCCESS) {
749 NETMGR_EXT_LOG_E("StartDhcp StartDhcpServer failed.");
750 return false;
751 }
752 NETMGR_EXT_LOG_I("StartDhcp StartDhcpServer successful.");
753 return true;
754 }
755
SetRange(DhcpRange & range,const std::string & ipHead,const std::string & strStartip,const std::string & strEndip,const std::string & mask)756 bool NetworkShareSubStateMachine::SetRange(DhcpRange &range, const std::string &ipHead, const std::string &strStartip,
757 const std::string &strEndip, const std::string &mask)
758 {
759 if (strcpy_s(range.strTagName, DHCP_MAX_FILE_BYTES, ifaceName_.c_str()) != 0) {
760 NETMGR_EXT_LOG_E("strcpy_s strTagName failed!");
761 return false;
762 }
763
764 if (strcpy_s(range.strStartip, INET_ADDRSTRLEN, strStartip.c_str()) != 0) {
765 NETMGR_EXT_LOG_E("strcpy_s strStartip failed!");
766 return false;
767 }
768
769 if (strcpy_s(range.strEndip, INET_ADDRSTRLEN, strEndip.c_str()) != 0) {
770 NETMGR_EXT_LOG_E("strcpy_s strEndip failed!");
771 return false;
772 }
773
774 if (strcpy_s(range.strSubnet, INET_ADDRSTRLEN, mask.c_str()) != 0) {
775 NETMGR_EXT_LOG_E("strcpy_s strSubnet failed!");
776 return false;
777 }
778 NETMGR_EXT_LOG_I(
779 "Set dhcp range : ifaceName[%{public}s] TagName[%{public}s] start ip[%{private}s] end ip[%{private}s]",
780 ifaceName_.c_str(), range.strTagName, range.strStartip, range.strEndip);
781
782 return true;
783 }
784
CheckConfig(std::string & endIp,std::string & mask)785 bool NetworkShareSubStateMachine::CheckConfig(std::string &endIp, std::string &mask)
786 {
787 if (configuration_ == nullptr) {
788 NETMGR_EXT_LOG_E("StartDhcp configuration is null.");
789 return false;
790 }
791 endIp = configuration_->GetDhcpEndIP();
792 if (endIp.empty()) {
793 NETMGR_EXT_LOG_E("StartDhcp GetDhcpEndIP is null.");
794 return false;
795 }
796 mask = configuration_->GetDefaultMask();
797 if (mask.empty()) {
798 NETMGR_EXT_LOG_E("StartDhcp GetDefaultMask is null.");
799 return false;
800 }
801 return true;
802 }
803
StopDhcp()804 bool NetworkShareSubStateMachine::StopDhcp()
805 {
806 if (netShareType_ == SharingIfaceType::SHARING_WIFI) {
807 NETMGR_EXT_LOG_W("StopDhcp wifi hotspot not need stop.");
808 return true;
809 }
810
811 int ret = StopDhcpServer(ifaceName_.c_str());
812 if (ret != 0) {
813 NETMGR_EXT_LOG_E("StopDhcpServer failed, error[%{public}d].", ret);
814 return false;
815 }
816 NETMGR_EXT_LOG_I("StopDhcpServer successful.");
817 return true;
818 }
819
ConfigureShareDhcp(bool enabled)820 bool NetworkShareSubStateMachine::ConfigureShareDhcp(bool enabled)
821 {
822 std::shared_ptr<INetAddr> ipv4Address = nullptr;
823 if (enabled) {
824 bool ret = RequestIpv4Address(ipv4Address);
825 if (ipv4Address == nullptr || !ret) {
826 NETMGR_EXT_LOG_E("ConfigureShareDhcp no available ipv4 address.");
827 return false;
828 }
829 if (netShareType_ == SharingIfaceType::SHARING_WIFI && !GetWifiHotspotDhcpFlag()) {
830 NETMGR_EXT_LOG_W("StartDhcp wifi hotspot not need start.");
831 return true;
832 }
833 return StartDhcp(ipv4Address);
834 }
835 return StopDhcp();
836 }
837
RequestIpv4Address(std::shared_ptr<INetAddr> & netAddr)838 bool NetworkShareSubStateMachine::RequestIpv4Address(std::shared_ptr<INetAddr> &netAddr)
839 {
840 if (configuration_ == nullptr) {
841 NETMGR_EXT_LOG_E("RequestIpv4Address get configuration failed.");
842 return false;
843 }
844
845 netAddr = std::make_shared<INetAddr>();
846 netAddr->type_ = INetAddr::IPV4;
847 netAddr->prefixlen_ = PREFIX_LENGTH_24;
848 netAddr->netMask_ = configuration_->GetDefaultMask();
849 if (netAddr->netMask_.empty()) {
850 NETMGR_EXT_LOG_E("RequestIpv4Address get default mask failed.");
851 return false;
852 }
853 switch (netShareType_) {
854 case SharingIfaceType::SHARING_BLUETOOTH: {
855 netAddr->address_ = configuration_->GetBtpanIpv4Addr();
856 netAddr->hostName_ = configuration_->GetBtpanDhcpServerName();
857 break;
858 }
859 case SharingIfaceType::SHARING_WIFI: {
860 netAddr->address_ = configuration_->GetWifiHotspotIpv4Addr();
861 netAddr->hostName_ = configuration_->GetWifiHotspotDhcpServerName();
862 break;
863 }
864 case SharingIfaceType::SHARING_USB: {
865 netAddr->address_ = configuration_->GetUsbRndisIpv4Addr();
866 netAddr->hostName_ = configuration_->GetUsbRndisDhcpServerName();
867 break;
868 }
869 default:
870 NETMGR_EXT_LOG_E("Unknown share type");
871 return false;
872 }
873
874 if (netAddr->address_.empty() || netAddr->hostName_.empty()) {
875 NETMGR_EXT_LOG_E("Failed to get ipv4 Address or dhcp server name.");
876 return false;
877 }
878 return true;
879 }
880
CleanupUpstreamInterface()881 void NetworkShareSubStateMachine::CleanupUpstreamInterface()
882 {
883 NETMGR_EXT_LOG_I("Clearn Forward, downstream Iface[%{public}s], upstream iface[%{public}s].", ifaceName_.c_str(),
884 upstreamIfaceName_.c_str());
885 RemoveRoutesToLocalNetwork();
886 NetsysController::GetInstance().NetworkRemoveInterface(LOCAL_NET_ID, ifaceName_);
887 NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ifaceName_, upstreamIfaceName_);
888 }
889
HasChangeUpstreamIfaceSet(const std::string & newUpstreamIface)890 bool NetworkShareSubStateMachine::HasChangeUpstreamIfaceSet(const std::string &newUpstreamIface)
891 {
892 if ((upstreamIfaceName_.empty()) && (newUpstreamIface.empty())) {
893 return false;
894 }
895 if ((!upstreamIfaceName_.empty()) && (!newUpstreamIface.empty())) {
896 return upstreamIfaceName_ != newUpstreamIface;
897 }
898 return true;
899 }
900
RegisterSubSMCallback(const std::shared_ptr<SubStateMachineCallback> & callback)901 void NetworkShareSubStateMachine::RegisterSubSMCallback(const std::shared_ptr<SubStateMachineCallback> &callback)
902 {
903 trackerCallback_ = callback;
904 }
905
GetNetShareType() const906 SharingIfaceType NetworkShareSubStateMachine::GetNetShareType() const
907 {
908 return netShareType_;
909 }
910
GetInterfaceName() const911 const std::string &NetworkShareSubStateMachine::GetInterfaceName() const
912 {
913 return ifaceName_;
914 }
915 } // namespace NetManagerStandard
916 } // namespace OHOS
917