1 /*
2  * Copyright (c) 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 "networkshare_main_statemachine.h"
17 
18 #include "netmgr_ext_log_wrapper.h"
19 #include "netsys_controller.h"
20 #include "networkshare_constants.h"
21 #include "networkshare_sub_statemachine.h"
22 #include "networkshare_tracker.h"
23 
24 namespace OHOS {
25 namespace NetManagerStandard {
26 namespace {
27 constexpr const char *ERROR_MSG_TRUNON = "Turn on Ip Forward failed";
28 constexpr const char *ERROR_MSG_TRUNOFF = "Turn off Ip Forward failed";
29 constexpr const char *ERROR_MSG_ENABLE_FORWARD = "Enable Forward failed";
30 constexpr const char *ERROR_MSG_DISABLE_FORWARD = "Disable Forward failed";
31 constexpr const char *FAKE_DOWNSTREAM_IFACENAME = "";
32 constexpr const char *EMPTY_UPSTREAM_IFACENAME = "";
33 } // namespace
34 
NetworkShareMainStateMachine(std::shared_ptr<NetworkShareUpstreamMonitor> &networkmonitor)35 NetworkShareMainStateMachine::NetworkShareMainStateMachine(std::shared_ptr<NetworkShareUpstreamMonitor> &networkmonitor)
36     : netshareRequester_("netsharing_requester"), networkMonitor_(networkmonitor)
37 {
38     MainSmStateTable temp;
39     temp.event_ = EVENT_IFACE_SM_STATE_ACTIVE;
40     temp.curState_ = MAINSTATE_INIT;
41     temp.func_ = &NetworkShareMainStateMachine::HandleInitInterfaceStateActive;
42     temp.nextState_ = MAINSTATE_ALIVE;
43     stateTable_.push_back(temp);
44 
45     temp.event_ = EVENT_IFACE_SM_STATE_INACTIVE;
46     temp.curState_ = MAINSTATE_INIT;
47     temp.func_ = &NetworkShareMainStateMachine::HandleInitInterfaceStateInactive;
48     temp.nextState_ = NO_NEXT_STATE;
49     stateTable_.push_back(temp);
50 
51     temp.event_ = EVENT_IFACE_SM_STATE_ACTIVE;
52     temp.curState_ = MAINSTATE_ALIVE;
53     temp.func_ = &NetworkShareMainStateMachine::HandleAliveInterfaceStateActive;
54     temp.nextState_ = NO_NEXT_STATE;
55     stateTable_.push_back(temp);
56 
57     temp.event_ = EVENT_IFACE_SM_STATE_INACTIVE;
58     temp.curState_ = MAINSTATE_ALIVE;
59     temp.func_ = &NetworkShareMainStateMachine::HandleAliveInterfaceStateInactive;
60     temp.nextState_ = NO_NEXT_STATE;
61     stateTable_.push_back(temp);
62 
63     temp.event_ = EVENT_UPSTREAM_CALLBACK;
64     temp.curState_ = MAINSTATE_ALIVE;
65     temp.func_ = &NetworkShareMainStateMachine::HandleAliveUpstreamMonitorCallback;
66     temp.nextState_ = NO_NEXT_STATE;
67     stateTable_.push_back(temp);
68 
69     temp.event_ = EVENT_IFACE_SM_STATE_INACTIVE;
70     temp.curState_ = MAINSTATE_ERROR;
71     temp.func_ = &NetworkShareMainStateMachine::HandleErrorInterfaceStateInactive;
72     temp.nextState_ = NO_NEXT_STATE;
73     stateTable_.push_back(temp);
74 
75     temp.event_ = CMD_CLEAR_ERROR;
76     temp.curState_ = MAINSTATE_ERROR;
77     temp.func_ = &NetworkShareMainStateMachine::HandleErrorClear;
78     temp.nextState_ = MAINSTATE_INIT;
79     stateTable_.push_back(temp);
80 }
81 
MainSmStateSwitch(int newState)82 void NetworkShareMainStateMachine::MainSmStateSwitch(int newState)
83 {
84     int oldState = curState_;
85     curState_ = newState;
86     NETMGR_EXT_LOG_I("MainSmStateSwitch from[%{public}d] to[%{public}d].", oldState, newState);
87 
88     if (oldState == MAINSTATE_INIT) {
89         InitStateExit();
90     } else if (oldState == MAINSTATE_ALIVE) {
91         AliveStateExit();
92     } else if (oldState == MAINSTATE_ERROR) {
93         ErrorStateExit();
94     } else {
95         NETMGR_EXT_LOG_E("MainSmStateSwitch oldState is unknow type value.");
96     }
97 
98     if (newState == MAINSTATE_INIT) {
99         InitStateEnter();
100     } else if (newState == MAINSTATE_ALIVE) {
101         AliveStateEnter();
102     } else if (newState == MAINSTATE_ERROR) {
103         ErrorStateEnter();
104     } else {
105         NETMGR_EXT_LOG_E("MainSmStateSwitch newState is unknow type value.");
106     }
107 }
108 
GetEventMutex()109 ffrt::recursive_mutex &NetworkShareMainStateMachine::GetEventMutex()
110 {
111     return mutex_;
112 }
113 
MainSmEventHandle(int eventId, const std::any &messageObj)114 void NetworkShareMainStateMachine::MainSmEventHandle(int eventId, const std::any &messageObj)
115 {
116     std::lock_guard<ffrt::recursive_mutex> lock(mutex_);
117     int nextState = NO_NEXT_STATE;
118     int (NetworkShareMainStateMachine::*eventActionFun)(const std::any &messageObj) = nullptr;
119     for (const auto &iter : stateTable_) {
120         if ((eventId == iter.event_) && (curState_ == iter.curState_)) {
121             eventActionFun = iter.func_;
122             nextState = iter.nextState_;
123             break;
124         }
125     }
126     if (eventActionFun == nullptr) {
127         NETMGR_EXT_LOG_W("currentstate[%{public}d]  eventId[%{public}d] is not matched.", curState_, eventId);
128         return;
129     }
130     (this->*eventActionFun)(messageObj);
131     if (nextState >= MAINSTATE_INIT && nextState < MAINSTATE_MAX) {
132         MainSmStateSwitch(nextState);
133     }
134 
135     NETMGR_EXT_LOG_I("MainSm eventId[%{public}d], handle successful.", eventId);
136 }
137 
InitStateEnter()138 void NetworkShareMainStateMachine::InitStateEnter()
139 {
140     NETMGR_EXT_LOG_I("Enter Init state");
141     std::thread unregListenNetworkThread = std::thread([this]() { this->ProcessListenDefaultNetwork(false); });
142     pthread_setname_np(unregListenNetworkThread.native_handle(), "OH_Net_UnregListenNetwork");
143     unregListenNetworkThread.detach();
144 }
145 
InitStateExit()146 void NetworkShareMainStateMachine::InitStateExit()
147 {
148     NETMGR_EXT_LOG_I("Exit Init state");
149 }
150 
ProcessListenDefaultNetwork(bool bAction)151 void NetworkShareMainStateMachine::ProcessListenDefaultNetwork(bool bAction)
152 {
153     std::shared_ptr<NetworkShareUpstreamMonitor> upstreamNetworkMonitor =
154         DelayedSingleton<NetworkShareUpstreamMonitor>::GetInstance();
155     if (bAction) {
156         upstreamNetworkMonitor->ListenDefaultNetwork();
157     } else {
158         upstreamNetworkMonitor->UnregisterListenDefaultNetwork();
159     }
160 }
161 
AliveStateEnter()162 void NetworkShareMainStateMachine::AliveStateEnter()
163 {
164     NETMGR_EXT_LOG_I("Enter Alive State");
165     if (!(TurnOnMainShareSettings())) {
166         NETMGR_EXT_LOG_E("Enter Alive State TurnOnMainShareSettings error.");
167         return;
168     }
169     if (NetworkShareTracker::GetInstance().UpstreamWanted()) {
170         ChooseUpstreamNetwork();
171     }
172     std::thread listenNetworkThread = std::thread([this]() { this->ProcessListenDefaultNetwork(true); });
173     pthread_setname_np(listenNetworkThread.native_handle(), "OH_Net_ListenNetwork");
174     listenNetworkThread.detach();
175 }
176 
AliveStateExit()177 void NetworkShareMainStateMachine::AliveStateExit()
178 {
179     NETMGR_EXT_LOG_I("Exit Alive state");
180     NetworkShareTracker::GetInstance().NotifyDownstreamsHasNewUpstreamIface(nullptr);
181 }
182 
ErrorStateEnter()183 void NetworkShareMainStateMachine::ErrorStateEnter()
184 {
185     NETMGR_EXT_LOG_I("Enter Error state, error[%{public}d].", errorType_);
186     for_each(subMachineList_.begin(), subMachineList_.end(),
187              [this](std::shared_ptr<NetworkShareSubStateMachine> subsm) {
188                  if (subsm != nullptr) {
189                      NETMGR_EXT_LOG_I("NOTIFY TO SUB SM [%{public}s] EVENT[%{public}d].",
190                                       subsm->GetInterfaceName().c_str(), errorType_);
191                      subsm->SubSmEventHandle(errorType_, 0);
192                  }
193              });
194 }
195 
ErrorStateExit() const196 void NetworkShareMainStateMachine::ErrorStateExit() const
197 {
198     NETMGR_EXT_LOG_I("Exit Error state, error[%{public}d].", errorType_);
199 }
200 
HandleInitInterfaceStateActive(const std::any &messageObj)201 int NetworkShareMainStateMachine::HandleInitInterfaceStateActive(const std::any &messageObj)
202 {
203     const MessageIfaceActive &temp = std::any_cast<const MessageIfaceActive &>(messageObj);
204     std::vector<std::shared_ptr<NetworkShareSubStateMachine>>::iterator iter =
205         find(subMachineList_.begin(), subMachineList_.end(), temp.subsm_);
206     if (iter == subMachineList_.end()) {
207         NETMGR_EXT_LOG_I("add new subSm.");
208         subMachineList_.push_back(temp.subsm_);
209     }
210 
211     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(true, temp.subsm_);
212     return NETMANAGER_EXT_SUCCESS;
213 }
214 
HandleInitInterfaceStateInactive(const std::any &messageObj)215 int NetworkShareMainStateMachine::HandleInitInterfaceStateInactive(const std::any &messageObj)
216 {
217     return EraseSharedSubSM(messageObj);
218 }
219 
HandleAliveInterfaceStateActive(const std::any &messageObj)220 int NetworkShareMainStateMachine::HandleAliveInterfaceStateActive(const std::any &messageObj)
221 {
222     const MessageIfaceActive &temp = std::any_cast<const MessageIfaceActive &>(messageObj);
223     std::vector<std::shared_ptr<NetworkShareSubStateMachine>>::iterator iter =
224         find(subMachineList_.begin(), subMachineList_.end(), temp.subsm_);
225     if (iter == subMachineList_.end()) {
226         NETMGR_EXT_LOG_I("add new subSm.");
227         subMachineList_.push_back(temp.subsm_);
228     }
229 
230     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(true, temp.subsm_);
231     if (temp.subsm_ != nullptr) {
232         std::shared_ptr<UpstreamNetworkInfo> upstreamInfo = nullptr;
233         NetworkShareTracker::GetInstance().GetUpstreamInfo(upstreamInfo);
234         NETMGR_EXT_LOG_I("NOTIFY TO SUB SM [%{public}s] CMD_NETSHARE_CONNECTION_CHANGED.",
235                          temp.subsm_->GetInterfaceName().c_str());
236         temp.subsm_->SubSmEventHandle(CMD_NETSHARE_CONNECTION_CHANGED, upstreamInfo);
237     }
238     return NETMANAGER_EXT_SUCCESS;
239 }
240 
HandleAliveInterfaceStateInactive(const std::any &messageObj)241 int NetworkShareMainStateMachine::HandleAliveInterfaceStateInactive(const std::any &messageObj)
242 {
243     int ret = EraseSharedSubSM(messageObj);
244     if (ret != NETMANAGER_EXT_SUCCESS) {
245         return ret;
246     }
247     if (subMachineList_.size() == 0) {
248         DisableForward();
249         TurnOffMainShareSettings();
250     }
251     return NETMANAGER_EXT_SUCCESS;
252 }
253 
EraseSharedSubSM(const std::any &messageObj)254 int NetworkShareMainStateMachine::EraseSharedSubSM(const std::any &messageObj)
255 {
256     const MessageIfaceActive &temp = std::any_cast<const MessageIfaceActive &>(messageObj);
257     if (temp.subsm_ == nullptr) {
258         NETMGR_EXT_LOG_E("subsm[%{public}d] is null.", temp.value_);
259         return NETMANAGER_EXT_ERR_LOCAL_PTR_NULL;
260     }
261     subMachineList_.erase(
262         remove_if(subMachineList_.begin(), subMachineList_.end(),
263                   [temp](std::shared_ptr<NetworkShareSubStateMachine> sm) { return sm == temp.subsm_; }),
264         subMachineList_.end());
265 
266     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(false, temp.subsm_);
267     return NETMANAGER_EXT_SUCCESS;
268 }
269 
ChooseUpstreamNetwork()270 void NetworkShareMainStateMachine::ChooseUpstreamNetwork()
271 {
272     sptr<NetHandle> pNetHandle = new (std::nothrow) NetHandle();
273     sptr<NetAllCapabilities> pNetCapabilities = new (std::nothrow) NetAllCapabilities();
274     sptr<NetLinkInfo> pNetLinkInfo = new (std::nothrow) NetLinkInfo();
275     std::shared_ptr<UpstreamNetworkInfo> netInfoPtr =
276         std::make_shared<UpstreamNetworkInfo>(pNetHandle, pNetCapabilities, pNetLinkInfo);
277     if (networkMonitor_ != nullptr && networkMonitor_->GetCurrentGoodUpstream(netInfoPtr)) {
278         upstreamIfaceName_ = netInfoPtr->netLinkPro_->ifaceName_;
279         int32_t result = NetsysController::GetInstance().EnableNat(FAKE_DOWNSTREAM_IFACENAME, upstreamIfaceName_);
280         if (result != NETSYS_SUCCESS) {
281             NetworkShareHisysEvent::GetInstance().SendFaultEvent(
282                 NetworkShareEventOperator::OPERATION_CONFIG_FORWARD, NetworkShareEventErrorType::ERROR_CONFIG_FORWARD,
283                 ERROR_MSG_ENABLE_FORWARD, NetworkShareEventType::SETUP_EVENT);
284             NETMGR_EXT_LOG_E("Main StateMachine enable NAT newIface[%{public}s] error[%{public}d].",
285                              upstreamIfaceName_.c_str(), result);
286         }
287         NetworkShareTracker::GetInstance().SetUpstreamNetHandle(netInfoPtr);
288     }
289 }
290 
HandleAliveUpstreamMonitorCallback(const std::any &messageObj)291 int NetworkShareMainStateMachine::HandleAliveUpstreamMonitorCallback(const std::any &messageObj)
292 {
293     if (!NetworkShareTracker::GetInstance().UpstreamWanted()) {
294         NETMGR_EXT_LOG_W("don't need handle upstream callback.");
295         return NETMANAGER_EXT_SUCCESS;
296     }
297     const MessageUpstreamInfo &temp = std::any_cast<const MessageUpstreamInfo &>(messageObj);
298     switch (temp.cmd_) {
299         case EVENT_UPSTREAM_CALLBACK_ON_LINKPROPERTIES: {
300             ChooseUpstreamNetwork();
301             break;
302         }
303         case EVENT_UPSTREAM_CALLBACK_ON_LOST: {
304             DisableForward();
305             break;
306         }
307         case EVENT_UPSTREAM_CALLBACK_ON_CAPABILITIES: {
308             break;
309         }
310         case EVENT_UPSTREAM_CALLBACK_DEFAULT_SWITCHED: {
311             DisableForward();
312             ChooseUpstreamNetwork();
313             break;
314         }
315         default:
316             break;
317     }
318     return NETMANAGER_EXT_SUCCESS;
319 }
320 
HandleErrorInterfaceStateInactive(const std::any &messageObj)321 int NetworkShareMainStateMachine::HandleErrorInterfaceStateInactive(const std::any &messageObj)
322 {
323     const MessageIfaceActive &temp = std::any_cast<const MessageIfaceActive &>(messageObj);
324     if (temp.subsm_ == nullptr) {
325         NETMGR_EXT_LOG_E("mode[%{public}d] subsm is null.", temp.value_);
326         return NETMANAGER_EXT_ERR_LOCAL_PTR_NULL;
327     }
328     NETMGR_EXT_LOG_I("NOTIFY TO SUB SM [%{public}s] EVENT[%{public}d].", temp.subsm_->GetInterfaceName().c_str(),
329                      errorType_);
330     temp.subsm_->SubSmEventHandle(errorType_, 0);
331     return NETMANAGER_EXT_SUCCESS;
332 }
333 
HandleErrorClear(const std::any &messageObj)334 int NetworkShareMainStateMachine::HandleErrorClear(const std::any &messageObj)
335 {
336     (void)messageObj;
337     errorType_ = NETWORKSHARING_SHARING_NO_ERROR;
338     return NETMANAGER_EXT_SUCCESS;
339 }
340 
SwitcheToErrorState(int32_t errType)341 void NetworkShareMainStateMachine::SwitcheToErrorState(int32_t errType)
342 {
343     NETMGR_EXT_LOG_W("SwitcheToErrorState errType[%{public}d].", errType);
344     errorType_ = errType;
345     MainSmStateSwitch(MAINSTATE_ERROR);
346 }
347 
TurnOnMainShareSettings()348 bool NetworkShareMainStateMachine::TurnOnMainShareSettings()
349 {
350     if (hasSetForward_) {
351         return true;
352     }
353     int32_t result = NetsysController::GetInstance().IpEnableForwarding(netshareRequester_);
354     if (result != NETSYS_SUCCESS) {
355         NetworkShareHisysEvent::GetInstance().SendFaultEvent(NetworkShareEventOperator::OPERATION_TURNON_IP_FORWARD,
356                                                              NetworkShareEventErrorType::ERROR_TURNON_IP_FORWARD,
357                                                              ERROR_MSG_TRUNON, NetworkShareEventType::SETUP_EVENT);
358         NETMGR_EXT_LOG_E("ipfwdEnableForwarding is error, switch error State.");
359         errorType_ = CMD_IP_FORWARDING_ENABLE_ERROR;
360         MainSmStateSwitch(MAINSTATE_ERROR);
361         return false;
362     }
363     hasSetForward_ = true;
364     NETMGR_EXT_LOG_I("turn on main ip forward successful.");
365     return true;
366 }
367 
TurnOffMainShareSettings()368 bool NetworkShareMainStateMachine::TurnOffMainShareSettings()
369 {
370     int32_t result = NetsysController::GetInstance().IpDisableForwarding(netshareRequester_);
371     if (result != NETSYS_SUCCESS) {
372         NetworkShareHisysEvent::GetInstance().SendFaultEvent(NetworkShareEventOperator::OPERATION_TURNOFF_IP_FORWARD,
373                                                              NetworkShareEventErrorType::ERROR_TURNOFF_IP_FORWARD,
374                                                              ERROR_MSG_TRUNOFF, NetworkShareEventType::CANCEL_EVENT);
375         NETMGR_EXT_LOG_E("IpfwdDisableForwarding is error, switch to error State.");
376         errorType_ = CMD_IP_FORWARDING_DISABLE_ERROR;
377         MainSmStateSwitch(MAINSTATE_ERROR);
378         return false;
379     }
380     NETMGR_EXT_LOG_I("turn off main ip forward successful, switch to init state.");
381     MainSmStateSwitch(MAINSTATE_INIT);
382     hasSetForward_ = false;
383     return true;
384 }
385 
DisableForward()386 void NetworkShareMainStateMachine::DisableForward()
387 {
388     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(nullptr);
389     int32_t result = NetsysController::GetInstance().DisableNat(FAKE_DOWNSTREAM_IFACENAME, upstreamIfaceName_);
390     if (result != NETSYS_SUCCESS) {
391         NetworkShareHisysEvent::GetInstance().SendFaultEvent(
392             NetworkShareEventOperator::OPERATION_CONFIG_FORWARD, NetworkShareEventErrorType::ERROR_CONFIG_FORWARD,
393             ERROR_MSG_DISABLE_FORWARD, NetworkShareEventType::SETUP_EVENT);
394         NETMGR_EXT_LOG_E("MainSM disable NAT newIface[%{public}s] in Lost Network error[%{public}d].",
395                          upstreamIfaceName_.c_str(), result);
396     }
397     upstreamIfaceName_ = EMPTY_UPSTREAM_IFACENAME;
398 }
399 } // namespace NetManagerStandard
400 } // namespace OHOS
401