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