1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <chrono>
18 #include <random>
19 #include "sta_state_machine.h"
20 #include "if_config.h"
21 #include "ip_tools.h"
22 #include "log_helper.h"
23 #include "mac_address.h"
24 #include "sta_monitor.h"
25 #include "wifi_chip_capability.h"
26 #include "wifi_common_util.h"
27 #include "wifi_logger.h"
28 #include "wifi_settings.h"
29 #include "wifi_sta_hal_interface.h"
30 #include "wifi_supplicant_hal_interface.h"
31 #include "wifi_hisysevent.h"
32 #include "wifi_config_center.h"
33 #ifndef OHOS_ARCH_LITE
34 #include <dlfcn.h>
35 #endif // OHOS_ARCH_LITE
36
37 #ifndef OHOS_WIFI_STA_TEST
38 #include "dhcp_service_api.h"
39 #else
40 #include "mock_dhcp_service.h"
41 #endif
42 namespace OHOS {
43 namespace Wifi {
44 DEFINE_WIFILOG_LABEL("StaStateMachine");
45 #define PBC_ANY_BSSID "any"
StaStateMachine()46 StaStateMachine::StaStateMachine()
47 : StateMachine("StaStateMachine"),
48 lastNetworkId(INVALID_NETWORK_ID),
49 operationalMode(STA_CONNECT_MODE),
50 targetNetworkId(INVALID_NETWORK_ID),
51 pinCode(0),
52 wpsState(SetupMethod::INVALID),
53 lastSignalLevel(-1),
54 targetRoamBssid(WPA_BSSID_ANY),
55 currentTpType(IPTYPE_IPV4),
56 isWpsConnect(IsWpsConnected::WPS_INVALID),
57 getIpSucNum(0),
58 getIpFailNum(0),
59 isRoam(false),
60 pDhcpService(nullptr),
61 pDhcpResultNotify(nullptr),
62 pNetcheck(nullptr),
63 pRootState(nullptr),
64 pInitState(nullptr),
65 pWpaStartingState(nullptr),
66 pWpaStartedState(nullptr),
67 pWpaStoppingState(nullptr),
68 pLinkState(nullptr),
69 pSeparatingState(nullptr),
70 pSeparatedState(nullptr),
71 pApLinkedState(nullptr),
72 pWpsState(nullptr),
73 pGetIpState(nullptr),
74 pLinkedState(nullptr),
75 pApRoamingState(nullptr)
76 {
77 }
78
~StaStateMachine()79 StaStateMachine::~StaStateMachine()
80 {
81 WIFI_LOGI("StaStateMachine::~StaStateMachine");
82 StopHandlerThread();
83 ParsePointer(pRootState);
84 ParsePointer(pInitState);
85 ParsePointer(pWpaStartingState);
86 ParsePointer(pWpaStartedState);
87 ParsePointer(pWpaStoppingState);
88 ParsePointer(pLinkState);
89 ParsePointer(pSeparatingState);
90 ParsePointer(pSeparatedState);
91 ParsePointer(pApLinkedState);
92 ParsePointer(pWpsState);
93 ParsePointer(pGetIpState);
94 ParsePointer(pLinkedState);
95 ParsePointer(pApRoamingState);
96 if (pDhcpService.get() != nullptr) {
97 if (currentTpType == IPTYPE_IPV4) {
98 pDhcpService->StopDhcpClient(IF_NAME, false);
99 } else {
100 pDhcpService->StopDhcpClient(IF_NAME, true);
101 }
102
103 pDhcpService->RemoveDhcpResult(pDhcpResultNotify);
104 pDhcpService.reset(nullptr);
105 }
106 ParsePointer(pDhcpResultNotify);
107 ParsePointer(pNetcheck);
108 }
109
110 /* ---------------------------Initialization functions------------------------------ */
InitStaStateMachine()111 ErrCode StaStateMachine::InitStaStateMachine()
112 {
113 WIFI_LOGI("Enter StaStateMachine::InitStaStateMachine.\n");
114 if (!InitialStateMachine()) {
115 WIFI_LOGE("Initial StateMachine failed.\n");
116 return WIFI_OPT_FAILED;
117 }
118
119 if (InitStaStates() == WIFI_OPT_FAILED) {
120 return WIFI_OPT_FAILED;
121 }
122 BuildStateTree();
123 SetFirstState(pInitState);
124 StartStateMachine();
125 InitStaSMHandleMap();
126 #ifndef OHOS_WIFI_STA_TEST
127 pDhcpService = DhcpServiceApi::GetInstance();
128 #else
129 pDhcpService = std::make_unique<DhcpService>();
130 #endif
131 if (pDhcpService.get() == nullptr) {
132 WIFI_LOGE("pDhcpServer is null\n");
133 return WIFI_OPT_FAILED;
134 }
135
136 pNetcheck = new (std::nothrow)
137 StaNetworkCheck(std::bind(&StaStateMachine::HandleNetCheckResult, this,
138 std::placeholders::_1, std::placeholders::_2));
139 if (pNetcheck == nullptr) {
140 WIFI_LOGE("pNetcheck is null\n");
141 return WIFI_OPT_FAILED;
142 }
143 pNetcheck->InitNetCheckThread();
144 #ifndef OHOS_ARCH_LITE
145 NetSupplierInfo = std::make_unique<NetManagerStandard::NetSupplierInfo>().release();
146 #endif
147 return WIFI_OPT_SUCCESS;
148 }
149
InitStaStates()150 ErrCode StaStateMachine::InitStaStates()
151 {
152 WIFI_LOGE("Enter InitStaStates\n");
153 int tmpErrNumber;
154 pRootState = new (std::nothrow)RootState();
155 tmpErrNumber = JudgmentEmpty(pRootState);
156 pInitState = new (std::nothrow)InitState(this);
157 tmpErrNumber += JudgmentEmpty(pInitState);
158 pWpaStartingState = new (std::nothrow)WpaStartingState(this);
159 tmpErrNumber += JudgmentEmpty(pWpaStartingState);
160 pWpaStartedState = new (std::nothrow)WpaStartedState(this);
161 tmpErrNumber += JudgmentEmpty(pWpaStartedState);
162 pWpaStoppingState = new (std::nothrow)WpaStoppingState(this);
163 tmpErrNumber += JudgmentEmpty(pWpaStoppingState);
164 pLinkState = new (std::nothrow)LinkState(this);
165 tmpErrNumber += JudgmentEmpty(pLinkState);
166 pSeparatingState = new (std::nothrow)SeparatingState();
167 tmpErrNumber += JudgmentEmpty(pSeparatingState);
168 pSeparatedState = new (std::nothrow)SeparatedState(this);
169 tmpErrNumber += JudgmentEmpty(pSeparatedState);
170 pApLinkedState = new (std::nothrow)ApLinkedState(this);
171 tmpErrNumber += JudgmentEmpty(pApLinkedState);
172 pWpsState = new (std::nothrow)StaWpsState(this);
173 tmpErrNumber += JudgmentEmpty(pWpsState);
174 pGetIpState = new (std::nothrow)GetIpState(this);
175 tmpErrNumber += JudgmentEmpty(pGetIpState);
176 pLinkedState = new (std::nothrow)LinkedState(this);
177 tmpErrNumber += JudgmentEmpty(pLinkedState);
178 pApRoamingState = new (std::nothrow)ApRoamingState(this);
179 tmpErrNumber += JudgmentEmpty(pApRoamingState);
180 pDhcpResultNotify = new (std::nothrow)DhcpResultNotify(this);
181 tmpErrNumber += JudgmentEmpty(pDhcpResultNotify);
182 if (tmpErrNumber != 0) {
183 WIFI_LOGE("InitStaStates some one state is null\n");
184 return WIFI_OPT_FAILED;
185 }
186 return WIFI_OPT_SUCCESS;
187 }
188
InitWifiLinkedInfo()189 void StaStateMachine::InitWifiLinkedInfo()
190 {
191 linkedInfo.networkId = INVALID_NETWORK_ID;
192 linkedInfo.ssid = "";
193 linkedInfo.bssid = "";
194 linkedInfo.macAddress = "";
195 linkedInfo.macType = 0;
196 linkedInfo.rxLinkSpeed = 0;
197 linkedInfo.txLinkSpeed = 0;
198 linkedInfo.rssi = 0;
199 linkedInfo.band = 0;
200 linkedInfo.frequency = 0;
201 linkedInfo.linkSpeed = 0;
202 linkedInfo.ipAddress = 0;
203 linkedInfo.connState = ConnState::DISCONNECTED;
204 linkedInfo.ifHiddenSSID = false;
205 linkedInfo.chload = 0;
206 linkedInfo.snr = 0;
207 linkedInfo.isDataRestricted = 0;
208 linkedInfo.portalUrl = "";
209 linkedInfo.detailedState = DetailedState::DISCONNECTED;
210 linkedInfo.channelWidth = WifiChannelWidth::WIDTH_INVALID;
211 linkedInfo.lastPacketDirection = 0;
212 linkedInfo.lastRxPackets = 0;
213 linkedInfo.lastTxPackets = 0;
214 linkedInfo.retryedConnCount = 0;
215 }
216
InitLastWifiLinkedInfo()217 void StaStateMachine::InitLastWifiLinkedInfo()
218 {
219 lastLinkedInfo.networkId = INVALID_NETWORK_ID;
220 lastLinkedInfo.ssid = "";
221 lastLinkedInfo.bssid = "";
222 lastLinkedInfo.macAddress = "";
223 linkedInfo.macType = 0;
224 lastLinkedInfo.rxLinkSpeed = 0;
225 lastLinkedInfo.txLinkSpeed = 0;
226 lastLinkedInfo.rssi = 0;
227 lastLinkedInfo.band = 0;
228 lastLinkedInfo.frequency = 0;
229 lastLinkedInfo.linkSpeed = 0;
230 lastLinkedInfo.ipAddress = 0;
231 lastLinkedInfo.connState = ConnState::DISCONNECTED;
232 lastLinkedInfo.ifHiddenSSID = false;
233 lastLinkedInfo.chload = 0;
234 lastLinkedInfo.snr = 0;
235 linkedInfo.isDataRestricted = 0;
236 linkedInfo.portalUrl = "";
237 lastLinkedInfo.lastPacketDirection = 0;
238 lastLinkedInfo.lastRxPackets = 0;
239 lastLinkedInfo.lastTxPackets = 0;
240 lastLinkedInfo.detailedState = DetailedState::DISCONNECTED;
241 linkedInfo.retryedConnCount = 0;
242 }
243
BuildStateTree()244 void StaStateMachine::BuildStateTree()
245 {
246 StatePlus(pRootState, nullptr);
247 StatePlus(pInitState, pRootState);
248 StatePlus(pWpaStartingState, pRootState);
249 StatePlus(pWpaStartedState, pRootState);
250 StatePlus(pLinkState, pWpaStartedState);
251 StatePlus(pSeparatingState, pLinkState);
252 StatePlus(pSeparatedState, pLinkState);
253 StatePlus(pApLinkedState, pLinkState);
254 StatePlus(pGetIpState, pApLinkedState);
255 StatePlus(pLinkedState, pApLinkedState);
256 StatePlus(pApRoamingState, pApLinkedState);
257 StatePlus(pWpsState, pLinkState);
258 StatePlus(pWpaStoppingState, pRootState);
259 }
260
RegisterStaServiceCallback(const StaServiceCallback & callbacks)261 void StaStateMachine::RegisterStaServiceCallback(const StaServiceCallback &callbacks)
262 {
263 WIFI_LOGI("RegisterStaServiceCallback.");
264 staCallback = callbacks;
265 }
266
267 /* --------------------------- state machine root state ------------------------------ */
RootState()268 StaStateMachine::RootState::RootState() : State("RootState")
269 {}
270
~RootState()271 StaStateMachine::RootState::~RootState()
272 {}
273
GoInState()274 void StaStateMachine::RootState::GoInState()
275 {
276 WIFI_LOGI("RootState GoInState function.");
277 return;
278 }
279
GoOutState()280 void StaStateMachine::RootState::GoOutState()
281 {
282 WIFI_LOGI("RootState GoOutState function.");
283 return;
284 }
285
ExecuteStateMsg(InternalMessage * msg)286 bool StaStateMachine::RootState::ExecuteStateMsg(InternalMessage *msg)
287 {
288 if (msg == nullptr) {
289 return false;
290 }
291
292 WIFI_LOGI("RootState-msgCode=%{public}d not handled.\n", msg->GetMessageName());
293 return true;
294 }
295
296 /* --------------------------- state machine Init State ------------------------------ */
InitState(StaStateMachine * staStateMachine)297 StaStateMachine::InitState::InitState(StaStateMachine *staStateMachine)
298 : State("InitState"), pStaStateMachine(staStateMachine)
299 {}
300
~InitState()301 StaStateMachine::InitState::~InitState()
302 {}
303
GoInState()304 void StaStateMachine::InitState::GoInState()
305 {
306 WIFI_LOGI("InitState GoInState function.");
307 return;
308 }
309
GoOutState()310 void StaStateMachine::InitState::GoOutState()
311 {
312 WIFI_LOGI("InitState GoOutState function.");
313 return;
314 }
315
ExecuteStateMsg(InternalMessage * msg)316 bool StaStateMachine::InitState::ExecuteStateMsg(InternalMessage *msg)
317 {
318 if (msg == nullptr) {
319 return false;
320 }
321
322 WIFI_LOGI("InitState-msgCode=%{public}d is received.\n", msg->GetMessageName());
323 bool ret = NOT_EXECUTED;
324 switch (msg->GetMessageName()) {
325 case WIFI_SVR_CMD_STA_ENABLE_WIFI: {
326 ret = EXECUTED;
327 pStaStateMachine->operationalMode = msg->GetParam1();
328 pStaStateMachine->StartWifiProcess();
329 break;
330 }
331
332 case WIFI_SVR_CMD_STA_OPERATIONAL_MODE:
333 break;
334
335 default:
336 WIFI_LOGI("InitState-msgCode=%d not handled.\n", msg->GetMessageName());
337 break;
338 }
339 return ret;
340 }
341
ConvertDeviceCfg(const WifiDeviceConfig & config) const342 ErrCode StaStateMachine::ConvertDeviceCfg(const WifiDeviceConfig &config) const
343 {
344 LOGI("Enter StaStateMachine::ConvertDeviceCfg.\n");
345 WifiIdlDeviceConfig idlConfig;
346 idlConfig.networkId = config.networkId;
347 idlConfig.ssid = config.ssid;
348 idlConfig.bssid = config.bssid;
349 idlConfig.psk = config.preSharedKey;
350 idlConfig.keyMgmt = config.keyMgmt;
351 idlConfig.priority = config.priority;
352 idlConfig.scanSsid = config.hiddenSSID ? 1 : 0;
353 idlConfig.eap = config.wifiEapConfig.eap;
354 idlConfig.identity = config.wifiEapConfig.identity;
355 idlConfig.password = config.wifiEapConfig.password;
356 idlConfig.clientCert = config.wifiEapConfig.clientCert;
357 idlConfig.privateKey = config.wifiEapConfig.privateKey;
358 idlConfig.phase2Method = static_cast<int>(config.wifiEapConfig.phase2Method);
359 idlConfig.wepKeyIdx = config.wepTxKeyIndex;
360 if (strcmp(config.keyMgmt.c_str(), "WEP") == 0) {
361 /* for wep */
362 idlConfig.authAlgorithms = 0x02;
363 }
364
365 for (int i = 0; i < MAX_WEPKEYS_SIZE; i++) {
366 idlConfig.wepKeys[i] = config.wepKeys[i];
367 }
368
369 if (WifiStaHalInterface::GetInstance().SetDeviceConfig(config.networkId, idlConfig) != WIFI_IDL_OPT_OK) {
370 LOGE("StaStateMachine::ConvertDeviceCfg SetDeviceConfig failed!");
371 return WIFI_OPT_FAILED;
372 }
373
374 if (WifiStaHalInterface::GetInstance().SaveDeviceConfig() != WIFI_IDL_OPT_OK) {
375 LOGW("StaStateMachine::ConvertDeviceCfg SaveDeviceConfig failed!");
376 }
377 return WIFI_OPT_SUCCESS;
378 }
379
SyncDeviceConfigToWpa() const380 void StaStateMachine::SyncDeviceConfigToWpa() const
381 {
382 WIFI_LOGI("SyncDeviceConfigToWpa");
383 /* Reload wifi Configurations. */
384 if (WifiSettings::GetInstance().ReloadDeviceConfig() != 0) {
385 WIFI_LOGE("ReloadDeviceConfig is failed!");
386 }
387
388 if (WifiStaHalInterface::GetInstance().ClearDeviceConfig() != WIFI_IDL_OPT_OK) {
389 WIFI_LOGE("ClearDeviceConfig() failed!");
390 } else {
391 WIFI_LOGD("ClearDeviceConfig() succeeded!");
392 std::vector<WifiDeviceConfig> results;
393 WifiSettings::GetInstance().GetDeviceConfig(results);
394 for(WifiDeviceConfig result : results) {
395 WIFI_LOGD("SyncDeviceConfigToWpa:result.networkId=[%d]!", result.networkId);
396 int networkId = INVALID_NETWORK_ID;
397 if (WifiStaHalInterface::GetInstance().GetNextNetworkId(networkId) != WIFI_IDL_OPT_OK) {
398 WIFI_LOGE("GetNextNetworkId failed.");
399 return;
400 }
401 if (networkId != result.networkId) {
402 WIFI_LOGE("DeviceConfig networkId different from wpa config networkId.");
403 return;
404 }
405 ConvertDeviceCfg(result);
406 }
407 WIFI_LOGD("SyncDeviceConfigToWpa-SaveDeviceConfig() succeed!");
408 }
409 }
410
StartWifiProcess()411 void StaStateMachine::StartWifiProcess()
412 {
413 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::ENABLING));
414 staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_OPENING);
415 int res;
416 if (WifiOprMidState::RUNNING == WifiConfigCenter::GetInstance().GetWifiScanOnlyMidState()) {
417 res = static_cast<int>(WIFI_IDL_OPT_OK);
418 } else {
419 res = WifiStaHalInterface::GetInstance().StartWifi();
420 }
421
422 if (res == static_cast<int>(WIFI_IDL_OPT_OK)) {
423 WIFI_LOGI("Start wifi successfully!");
424 if (WifiStaHalInterface::GetInstance().WpaAutoConnect(false) != WIFI_IDL_OPT_OK) {
425 WIFI_LOGI("The automatic Wpa connection is disabled failed.");
426 }
427
428 /* callback the InterfaceService that wifi is enabled successfully. */
429 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::ENABLED));
430 staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_SUCCEED);
431 /* Sets the MAC address of WifiSettings. */
432 std::string mac;
433 if ((WifiStaHalInterface::GetInstance().GetStaDeviceMacAddress(mac)) == WIFI_IDL_OPT_OK) {
434 WifiSettings::GetInstance().SetMacAddress(mac);
435 std::string realMacAddress;
436 WifiSettings::GetInstance().GetRealMacAddress(realMacAddress);
437 if (realMacAddress.empty()) {
438 WifiSettings::GetInstance().SetRealMacAddress(mac);
439 }
440 } else {
441 WIFI_LOGI("GetStaDeviceMacAddress failed!");
442 }
443 #ifndef OHOS_ARCH_LITE
444 WIFI_LOGI("Register netsupplier");
445 WifiNetAgent::GetInstance().OnStaMachineWifiStart();
446 #endif
447 /* Initialize Connection Information. */
448 InitWifiLinkedInfo();
449 InitLastWifiLinkedInfo();
450 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
451 SyncDeviceConfigToWpa();
452 #ifndef OHOS_ARCH_LITE
453 ChipCapability::GetInstance().InitializeChipCapability();
454 #endif
455 /* The current state of StaStateMachine transfers to SeparatedState after
456 * enable supplicant.
457 */
458 SwitchState(pSeparatedState);
459 } else {
460 /* Notify the InterfaceService that wifi is failed to enable wifi. */
461 LOGE("StartWifi failed, and errcode is %d.", res);
462 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::DISABLED));
463 WifiSettings::GetInstance().SetUserLastSelectedNetworkId(INVALID_NETWORK_ID);
464 staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_FAILED);
465 }
466 }
467
468 /* --------------------------- state machine WpaStarting State ------------------------------ */
WpaStartingState(StaStateMachine * staStateMachine)469 StaStateMachine::WpaStartingState::WpaStartingState(StaStateMachine *staStateMachine)
470 : State("WpaStartingState"), pStaStateMachine(staStateMachine)
471 {}
472
~WpaStartingState()473 StaStateMachine::WpaStartingState::~WpaStartingState()
474 {}
475
InitWpsSettings()476 void StaStateMachine::WpaStartingState::InitWpsSettings()
477 {
478 WIFI_LOGI("WpaStartingState InitWpsSettings function.");
479 return;
480 }
481
GoInState()482 void StaStateMachine::WpaStartingState::GoInState()
483 {
484 WIFI_LOGI("WpaStartingState GoInState function.");
485 return;
486 }
487
GoOutState()488 void StaStateMachine::WpaStartingState::GoOutState()
489 {
490 LOGI("WpaStartingState GoOutState function.");
491 return;
492 }
493
ExecuteStateMsg(InternalMessage * msg)494 bool StaStateMachine::WpaStartingState::ExecuteStateMsg(InternalMessage *msg)
495 {
496 if (msg == nullptr) {
497 return false;
498 }
499
500 bool ret = NOT_EXECUTED;
501 switch (msg->GetMessageName()) {
502 case WIFI_SVR_CMD_STA_SUP_CONNECTION_EVENT: {
503 ret = EXECUTED;
504 pStaStateMachine->SwitchState(pStaStateMachine->pWpaStartedState);
505 break;
506 }
507 default:
508 break;
509 }
510 return ret;
511 }
512
513 /* --------------------------- state machine WpaStarted State ------------------------------ */
WpaStartedState(StaStateMachine * staStateMachine)514 StaStateMachine::WpaStartedState::WpaStartedState(StaStateMachine *staStateMachine)
515 : State("WpaStartedState"), pStaStateMachine(staStateMachine)
516 {}
517
~WpaStartedState()518 StaStateMachine::WpaStartedState::~WpaStartedState()
519 {}
520
GoInState()521 void StaStateMachine::WpaStartedState::GoInState()
522 {
523 WIFI_LOGI("WpaStartedState GoInState function.");
524 if (pStaStateMachine->operationalMode == STA_CONNECT_MODE) {
525 pStaStateMachine->SwitchState(pStaStateMachine->pSeparatedState);
526 } else if (pStaStateMachine->operationalMode == STA_DISABLED_MODE) {
527 pStaStateMachine->SwitchState(pStaStateMachine->pWpaStoppingState);
528 }
529 return;
530 }
GoOutState()531 void StaStateMachine::WpaStartedState::GoOutState()
532 {
533 WIFI_LOGI("WpaStartedState GoOutState function.");
534 return;
535 }
536
ExecuteStateMsg(InternalMessage * msg)537 bool StaStateMachine::WpaStartedState::ExecuteStateMsg(InternalMessage *msg)
538 {
539 if (msg == nullptr) {
540 LOGI("msg is nullptr");
541 return false;
542 }
543
544 WIFI_LOGI("WpaStartedState ExecuteStateMsg-msgCode:%{public}d.\n", msg->GetMessageName());
545 bool ret = NOT_EXECUTED;
546 switch (msg->GetMessageName()) {
547 case WIFI_SVR_CMD_STA_DISABLE_WIFI: {
548 ret = EXECUTED;
549 pStaStateMachine->StopWifiProcess();
550 break;
551 }
552
553 default:
554 break;
555 }
556 return ret;
557 }
558
StopWifiProcess()559 void StaStateMachine::StopWifiProcess()
560 {
561 WIFI_LOGI("Enter StaStateMachine::StopWifiProcess.\n");
562 #ifndef OHOS_ARCH_LITE
563 WifiNetAgent::GetInstance().UnregisterNetSupplier();
564 #endif
565 WIFI_LOGI("Stop wifi is in process...\n");
566 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::DISABLING));
567 staCallback.OnStaCloseRes(OperateResState::CLOSE_WIFI_CLOSING);
568 StopTimer(static_cast<int>(CMD_SIGNAL_POLL));
569 if (currentTpType == IPTYPE_IPV4) {
570 pDhcpService->StopDhcpClient(IF_NAME, false);
571 } else {
572 pDhcpService->StopDhcpClient(IF_NAME, true);
573 }
574 isRoam = false;
575 WifiSettings::GetInstance().SetMacAddress("");
576
577 IpInfo ipInfo;
578 WifiSettings::GetInstance().SaveIpInfo(ipInfo);
579 IpV6Info ipV6Info;
580 WifiSettings::GetInstance().SaveIpV6Info(ipV6Info);
581 #ifdef OHOS_ARCH_LITE
582 IfConfig::GetInstance().FlushIpAddr(IF_NAME, IPTYPE_IPV4);
583 #endif
584
585 /* clear connection information. */
586 InitWifiLinkedInfo();
587 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
588
589 if (WifiOprMidState::RUNNING == WifiConfigCenter::GetInstance().GetWifiScanOnlyMidState() \
590 || WifiStaHalInterface::GetInstance().StopWifi() == WIFI_IDL_OPT_OK) {
591 /* Callback result to InterfaceService. */
592 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::DISABLED));
593 staCallback.OnStaCloseRes(OperateResState::CLOSE_WIFI_SUCCEED);
594 WIFI_LOGI("Stop WifiProcess successfully!");
595
596 /* The current state of StaStateMachine transfers to InitState. */
597 SwitchState(pInitState);
598 } else {
599 WIFI_LOGE("StopWifiProcess failed.");
600 WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::UNKNOWN));
601 staCallback.OnStaCloseRes(OperateResState::CLOSE_WIFI_FAILED);
602 }
603 WifiSettings::GetInstance().SetUserLastSelectedNetworkId(INVALID_NETWORK_ID);
604 }
605
606 /* --------------------------- state machine WpaStopping State ------------------------------ */
WpaStoppingState(StaStateMachine * staStateMachine)607 StaStateMachine::WpaStoppingState::WpaStoppingState(StaStateMachine *staStateMachine)
608 : State("WpaStoppingState"), pStaStateMachine(staStateMachine)
609 {}
610
~WpaStoppingState()611 StaStateMachine::WpaStoppingState::~WpaStoppingState()
612 {}
613
GoInState()614 void StaStateMachine::WpaStoppingState::GoInState()
615 {
616 WIFI_LOGI("WpaStoppingState GoInState function.");
617 pStaStateMachine->SwitchState(pStaStateMachine->pInitState);
618 return;
619 }
620
GoOutState()621 void StaStateMachine::WpaStoppingState::GoOutState()
622 {
623 WIFI_LOGI("WpaStoppingState GoOutState function.");
624 return;
625 }
626
ExecuteStateMsg(InternalMessage * msg)627 bool StaStateMachine::WpaStoppingState::ExecuteStateMsg(InternalMessage *msg)
628 {
629 if (msg == nullptr) {
630 return false;
631 }
632
633 bool ret = NOT_EXECUTED;
634 WIFI_LOGI("WpaStoppingState-msgCode=%{public}d not handled.\n", msg->GetMessageName());
635 return ret;
636 }
637
638 /* --------------------------- state machine link State ------------------------------ */
LinkState(StaStateMachine * staStateMachine)639 StaStateMachine::LinkState::LinkState(StaStateMachine *staStateMachine)
640 : State("LinkState"), pStaStateMachine(staStateMachine)
641 {}
642
~LinkState()643 StaStateMachine::LinkState::~LinkState()
644 {}
645
GoInState()646 void StaStateMachine::LinkState::GoInState()
647 {
648 WIFI_LOGI("LinkState GoInState function.");
649 return;
650 }
651
GoOutState()652 void StaStateMachine::LinkState::GoOutState()
653 {
654 WIFI_LOGI("LinkState GoOutState function.");
655 return;
656 }
657
ExecuteStateMsg(InternalMessage * msg)658 bool StaStateMachine::LinkState::ExecuteStateMsg(InternalMessage *msg)
659 {
660 if (msg == nullptr) {
661 return false;
662 }
663 LOGD("LinkState ExecuteStateMsg function:msgName=[%{public}d].\n", msg->GetMessageName());
664 auto iter = pStaStateMachine->staSmHandleFuncMap.find(msg->GetMessageName());
665 if (iter != pStaStateMachine->staSmHandleFuncMap.end()) {
666 (pStaStateMachine->*(iter->second))(msg);
667 return EXECUTED;
668 }
669 return NOT_EXECUTED;
670 }
671
672 /* -- state machine Connect State Message processing function -- */
InitStaSMHandleMap()673 int StaStateMachine::InitStaSMHandleMap()
674 {
675 staSmHandleFuncMap[CMD_SIGNAL_POLL] = &StaStateMachine::DealSignalPollResult;
676 staSmHandleFuncMap[WIFI_SVR_CMD_STA_CONNECT_NETWORK] = &StaStateMachine::DealConnectToUserSelectedNetwork;
677 staSmHandleFuncMap[WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK] = &StaStateMachine::DealConnectToUserSelectedNetwork;
678 staSmHandleFuncMap[WIFI_SVR_CMD_STA_NETWORK_DISCONNECTION_EVENT] = &StaStateMachine::DealDisconnectEvent;
679 staSmHandleFuncMap[WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT] = &StaStateMachine::DealConnectionEvent;
680 staSmHandleFuncMap[CMD_NETWORK_CONNECT_TIMEOUT] = &StaStateMachine::DealConnectTimeOutCmd;
681 staSmHandleFuncMap[WPA_BLOCK_LIST_CLEAR_EVENT] = &StaStateMachine::DealWpaBlockListClearEvent;
682 staSmHandleFuncMap[WIFI_SVR_CMD_STA_STARTWPS] = &StaStateMachine::DealStartWpsCmd;
683 staSmHandleFuncMap[WIFI_SVR_CMD_STA_WPS_TIMEOUT_EVNET] = &StaStateMachine::DealWpsConnectTimeOutEvent;
684 staSmHandleFuncMap[WIFI_SVR_CMD_STA_CANCELWPS] = &StaStateMachine::DealCancelWpsCmd;
685 staSmHandleFuncMap[WIFI_SVR_CMD_STA_RECONNECT_NETWORK] = &StaStateMachine::DealReConnectCmd;
686 staSmHandleFuncMap[WIFI_SVR_CMD_STA_REASSOCIATE_NETWORK] = &StaStateMachine::DealReassociateCmd;
687 staSmHandleFuncMap[WIFI_SVR_COM_STA_START_ROAM] = &StaStateMachine::DealStartRoamCmd;
688 staSmHandleFuncMap[WIFI_SVR_CMD_STA_WPA_PASSWD_WRONG_EVENT] = &StaStateMachine::DealWpaLinkFailEvent;
689 staSmHandleFuncMap[WIFI_SVR_CMD_STA_WPA_FULL_CONNECT_EVENT] = &StaStateMachine::DealWpaLinkFailEvent;
690 staSmHandleFuncMap[WIFI_SVR_CMD_STA_WPA_ASSOC_REJECT_EVENT] = &StaStateMachine::DealWpaLinkFailEvent;
691 staSmHandleFuncMap[CMD_START_NETCHECK] = &StaStateMachine::DealNetworkCheck;
692 return WIFI_OPT_SUCCESS;
693 }
694
setRssi(int rssi)695 int setRssi(int rssi)
696 {
697 if (rssi < INVALID_RSSI_VALUE) {
698 rssi = INVALID_RSSI_VALUE;
699 }
700
701 if (rssi > MAX_RSSI_VALUE) {
702 rssi = MAX_RSSI_VALUE;
703 }
704 return rssi;
705 }
706
DealSignalPollResult(InternalMessage * msg)707 void StaStateMachine::DealSignalPollResult(InternalMessage *msg)
708 {
709 LOGD("enter DealSignalPollResult.\n");
710 if (msg == nullptr) {
711 LOGE("InternalMessage msg is null.");
712 return;
713 }
714 WifiWpaSignalInfo signalInfo;
715 WifiStaHalInterface::GetInstance().GetConnectSignalInfo(linkedInfo.bssid, signalInfo);
716 LOGI("DealSignalPollResult, signal:%{public}d, txLinkSpeed:%{public}d, rxLinkSpeed:%{public}d, "
717 "freq:%{public}d, noise:%{public}d.\n",
718 signalInfo.signal, signalInfo.txrate, signalInfo.rxrate, signalInfo.frequency,
719 signalInfo.noise);
720 if (signalInfo.signal > INVALID_RSSI_VALUE && signalInfo.signal < MAX_RSSI_VALUE) {
721 if (signalInfo.signal > 0) {
722 linkedInfo.rssi = setRssi((signalInfo.signal - SIGNAL_INFO));
723 } else {
724 linkedInfo.rssi = setRssi(signalInfo.signal);
725 }
726 int currentSignalLevel = WifiSettings::GetInstance().GetSignalLevel(linkedInfo.rssi, linkedInfo.band);
727 LOGI("DealSignalPollResult, networkId:%{public}d, ssid:%{private}s, rssi:%{public}d, band:%{public}d, "
728 "connState:%{public}d, detailedState:%{public}d.\n",
729 linkedInfo.networkId, SsidAnonymize(linkedInfo.ssid).c_str(), linkedInfo.rssi, linkedInfo.band,
730 linkedInfo.connState, linkedInfo.detailedState);
731 LOGI("DealSignalPollResult currentSignalLevel:%{public}d, lastSignalLevel:%{public}d.\n",
732 currentSignalLevel, lastSignalLevel);
733 if (currentSignalLevel != lastSignalLevel) {
734 if (staCallback.OnStaRssiLevelChanged != nullptr) {
735 staCallback.OnStaRssiLevelChanged(linkedInfo.rssi);
736 }
737 #ifndef OHOS_ARCH_LITE
738 if (NetSupplierInfo != nullptr) {
739 TimeStats timeStats("Call UpdateNetSupplierInfo");
740 NetSupplierInfo->isAvailable_ = true;
741 NetSupplierInfo->isRoaming_ = isRoam;
742 NetSupplierInfo->strength_ = linkedInfo.rssi;
743 NetSupplierInfo->frequency_ = linkedInfo.frequency;
744 WifiNetAgent::GetInstance().UpdateNetSupplierInfo(NetSupplierInfo);
745 }
746 #endif
747 lastSignalLevel = currentSignalLevel;
748 }
749 } else {
750 linkedInfo.rssi = INVALID_RSSI_VALUE;
751 }
752 if (signalInfo.txrate > 0) {
753 linkedInfo.txLinkSpeed = signalInfo.txrate;
754 linkedInfo.linkSpeed = signalInfo.txrate;
755 if (staCallback.OnStaStreamChanged != nullptr) {
756 staCallback.OnStaStreamChanged(StreamDirection::STREAM_DIRECTION_UP);
757 }
758 }
759
760 if (signalInfo.rxrate > 0) {
761 linkedInfo.rxLinkSpeed = signalInfo.rxrate;
762 if (staCallback.OnStaStreamChanged != nullptr) {
763 staCallback.OnStaStreamChanged(StreamDirection::STREAM_DIRECTION_DOWN);
764 }
765 }
766
767 if (signalInfo.frequency > 0) {
768 linkedInfo.frequency = signalInfo.frequency;
769 }
770 linkedInfo.snr = linkedInfo.rssi - signalInfo.noise;
771 if (linkedInfo.wifiStandard == WIFI_MODE_UNDEFINED) {
772 WifiSettings::GetInstance().SetWifiLinkedStandardAndMaxSpeed(linkedInfo);
773 }
774 LOGI("DealSignalPollResult GetWifiStandard:%{public}d, bssid:%{public}s rxmax:%{public}d txmax:%{public}d.\n",
775 linkedInfo.wifiStandard, MacAnonymize(linkedInfo.bssid).c_str(), linkedInfo.maxSupportedRxLinkSpeed,
776 linkedInfo.maxSupportedTxLinkSpeed);
777 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
778 ConvertFreqToChannel();
779 DealSignalPacketChanged(signalInfo.txPackets, signalInfo.rxPackets);
780 StartTimer(static_cast<int>(CMD_SIGNAL_POLL), STA_SIGNAL_POLL_DELAY);
781 }
782
DealSignalPacketChanged(int txPackets,int rxPackets)783 void StaStateMachine::DealSignalPacketChanged(int txPackets, int rxPackets)
784 {
785 int send = txPackets - linkedInfo.lastTxPackets;
786 int received = rxPackets - linkedInfo.lastRxPackets;
787 int direction = 0;
788 if (send > 0) {
789 direction |= 1;
790 }
791 if (received > 0) {
792 direction |= 1 << 1;
793 }
794 if (direction != linkedInfo.lastPacketDirection) {
795 WriteWifiSignalHiSysEvent(direction, txPackets, rxPackets);
796 }
797 linkedInfo.lastPacketDirection = direction;
798 linkedInfo.lastRxPackets = rxPackets;
799 linkedInfo.lastTxPackets = txPackets;
800 }
801
ConvertFreqToChannel()802 void StaStateMachine::ConvertFreqToChannel()
803 {
804 WifiDeviceConfig config;
805 if (WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, config) != 0) {
806 LOGE("GetDeviceConfig failed!");
807 return;
808 }
809 int lastBand = linkedInfo.band;
810 config.frequency = linkedInfo.frequency;
811 if (linkedInfo.frequency >= FREQ_2G_MIN && linkedInfo.frequency <= FREQ_2G_MAX) {
812 config.band = linkedInfo.band = static_cast<int>(BandType::BAND_2GHZ);
813 config.channel = (linkedInfo.frequency - FREQ_2G_MIN) / CENTER_FREQ_DIFF + CHANNEL_2G_MIN;
814 } else if (linkedInfo.frequency == CHANNEL_14_FREQ) {
815 config.channel = CHANNEL_14;
816 } else if (linkedInfo.frequency >= FREQ_5G_MIN && linkedInfo.frequency <= FREQ_5G_MAX) {
817 config.band = linkedInfo.band = static_cast<int>(BandType::BAND_5GHZ);
818 config.channel = (linkedInfo.frequency - FREQ_5G_MIN) / CENTER_FREQ_DIFF + CHANNEL_5G_MIN;
819 }
820 if (lastBand != linkedInfo.band) {
821 WriteWifiBandHiSysEvent(linkedInfo.band);
822 }
823 WifiSettings::GetInstance().AddDeviceConfig(config);
824 return;
825 }
826
OnConnectFailed(int networkId)827 void StaStateMachine::OnConnectFailed(int networkId)
828 {
829 WIFI_LOGE("Connect to network failed: %{public}d.\n", networkId);
830 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::FAILED);
831 staCallback.OnStaConnChanged(OperateResState::CONNECT_ENABLE_NETWORK_FAILED, linkedInfo);
832 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo);
833 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
834 }
835
DealConnectToUserSelectedNetwork(InternalMessage * msg)836 void StaStateMachine::DealConnectToUserSelectedNetwork(InternalMessage *msg)
837 {
838 LOGD("enter DealConnectToUserSelectedNetwork.\n");
839 if (msg == nullptr) {
840 LOGE("msg is null.\n");
841 return;
842 }
843
844 int networkId = msg->GetParam1();
845 int connTriggerMode = msg->GetParam2();
846 if (connTriggerMode != NETWORK_SELECTED_BY_RETRY) {
847 linkedInfo.retryedConnCount = 0;
848 }
849
850 if (networkId == linkedInfo.networkId) {
851 if (linkedInfo.connState == ConnState::CONNECTED) {
852 staCallback.OnStaConnChanged(OperateResState::CONNECT_AP_CONNECTED, linkedInfo);
853 WIFI_LOGI("This network is in use and does not need to be reconnected.\n");
854 return;
855 }
856 if (linkedInfo.connState == ConnState::CONNECTING &&
857 linkedInfo.detailedState == DetailedState::OBTAINING_IPADDR) {
858 WIFI_LOGI("This network is connecting and does not need to be reconnected.\n");
859 return;
860 }
861 }
862
863 /* Save connection information. */
864 SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT);
865 SaveLinkstate(ConnState::CONNECTING, DetailedState::CONNECTING);
866 /* Callback result to InterfaceService. */
867 staCallback.OnStaConnChanged(OperateResState::CONNECT_CONNECTING, linkedInfo);
868
869 if (StartConnectToNetwork(networkId) != WIFI_OPT_SUCCESS) {
870 OnConnectFailed(networkId);
871 return;
872 }
873
874 /* Sets network status. */
875 WifiSettings::GetInstance().EnableNetwork(networkId, connTriggerMode == NETWORK_SELECTED_BY_USER);
876 WifiSettings::GetInstance().SetDeviceAfterConnect(networkId);
877 WifiSettings::GetInstance().SetDeviceState(networkId, (int)WifiDeviceConfigStatus::ENABLED, false);
878 }
879
DealConnectTimeOutCmd(InternalMessage * msg)880 void StaStateMachine::DealConnectTimeOutCmd(InternalMessage *msg)
881 {
882 LOGW("enter DealConnectTimeOutCmd.\n");
883 if (msg == nullptr) {
884 WIFI_LOGE("msg is nul\n");
885 }
886
887 if (linkedInfo.connState == ConnState::CONNECTED) {
888 WIFI_LOGE("Currently connected and do not process timeout.\n");
889 return;
890 }
891 linkedInfo.retryedConnCount++;
892 DealSetStaConnectFailedCount(1, false);
893
894 WifiSettings::GetInstance().SetConnectTimeoutBssid(linkedInfo.bssid);
895 InitWifiLinkedInfo();
896 SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT);
897 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::CONNECTION_TIMEOUT);
898 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
899 staCallback.OnStaConnChanged(OperateResState::CONNECT_CONNECTING_TIMEOUT, linkedInfo);
900 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo);
901 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
902 }
903
DealConnectionEvent(InternalMessage * msg)904 void StaStateMachine::DealConnectionEvent(InternalMessage *msg)
905 {
906 if (msg == nullptr) {
907 WIFI_LOGE("DealConnectionEvent, msg is nullptr.\n");
908 return;
909 }
910
911 WIFI_LOGI("enter DealConnectionEvent");
912 WifiSettings::GetInstance().SetDeviceAfterConnect(targetNetworkId);
913 WifiSettings::GetInstance().SetDeviceState(targetNetworkId, (int)WifiDeviceConfigStatus::ENABLED, false);
914 WifiSettings::GetInstance().SyncDeviceConfig();
915 #ifndef OHOS_ARCH_LITE
916 SaveWifiConfigForUpdate(targetNetworkId);
917 #endif
918 /* Stop clearing the Wpa_blocklist. */
919 StopTimer(static_cast<int>(WPA_BLOCK_LIST_CLEAR_EVENT));
920 ConnectToNetworkProcess(msg);
921 StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
922 StartTimer(static_cast<int>(CMD_SIGNAL_POLL), 0);
923
924 if (wpsState != SetupMethod::INVALID) {
925 SyncAllDeviceConfigs();
926 wpsState = SetupMethod::INVALID;
927 }
928 #ifndef OHOS_ARCH_LITE
929 if (NetSupplierInfo != nullptr) {
930 NetSupplierInfo->isAvailable_ = true;
931 NetSupplierInfo->isRoaming_ = isRoam;
932 WIFI_LOGI("On connect update net supplier info\n");
933 WifiNetAgent::GetInstance().OnStaMachineUpdateNetSupplierInfo(NetSupplierInfo);
934 }
935 #endif
936 /* Callback result to InterfaceService. */
937 staCallback.OnStaConnChanged(OperateResState::CONNECT_OBTAINING_IP, linkedInfo);
938
939 /* The current state of StaStateMachine transfers to GetIpState. */
940 SwitchState(pGetIpState);
941 WifiSettings::GetInstance().SetUserLastSelectedNetworkId(INVALID_NETWORK_ID);
942 }
943
DealDisconnectEvent(InternalMessage * msg)944 void StaStateMachine::DealDisconnectEvent(InternalMessage *msg)
945 {
946 LOGI("Enter DealDisconnectEvent.\n");
947 if (msg == nullptr) {
948 WIFI_LOGE("msg is null\n");
949 }
950 if (wpsState != SetupMethod::INVALID) {
951 WIFI_LOGE("wpsState is INVALID\n");
952 return;
953 }
954 #ifndef OHOS_ARCH_LITE
955 if (NetSupplierInfo != nullptr) {
956 NetSupplierInfo->isAvailable_ = false;
957 WIFI_LOGI("On disconnect update net supplier info\n");
958 WifiNetAgent::GetInstance().OnStaMachineUpdateNetSupplierInfo(NetSupplierInfo);
959 }
960 #endif
961 StopTimer(static_cast<int>(CMD_SIGNAL_POLL));
962 StopTimer(static_cast<int>(CMD_START_NETCHECK));
963 pNetcheck->StopNetCheckThread();
964 if (currentTpType == IPTYPE_IPV4) {
965 pDhcpService->StopDhcpClient(IF_NAME, false);
966 } else {
967 pDhcpService->StopDhcpClient(IF_NAME, true);
968 }
969 getIpSucNum = 0;
970 getIpFailNum = 0;
971 isRoam = false;
972
973 IpInfo ipInfo;
974 WifiSettings::GetInstance().SaveIpInfo(ipInfo);
975 IpV6Info ipV6Info;
976 WifiSettings::GetInstance().SaveIpV6Info(ipV6Info);
977 #ifdef OHOS_ARCH_LITE
978 IfConfig::GetInstance().FlushIpAddr(IF_NAME, IPTYPE_IPV4);
979 #endif
980 /* Initialize connection information. */
981 InitWifiLinkedInfo();
982 if (lastLinkedInfo.detailedState == DetailedState::CONNECTING) {
983 linkedInfo.networkId = lastLinkedInfo.networkId;
984 linkedInfo.ssid = lastLinkedInfo.ssid;
985 linkedInfo.connState = ConnState::CONNECTING;
986 linkedInfo.detailedState = DetailedState::CONNECTING;
987 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
988 } else {
989 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
990 }
991 /* Callback result to InterfaceService. */
992 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo);
993 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
994 SwitchState(pSeparatedState);
995 return;
996 }
997
DealWpaLinkFailEvent(InternalMessage * msg)998 void StaStateMachine::DealWpaLinkFailEvent(InternalMessage *msg)
999 {
1000 LOGW("enter DealWpaLinkFailEvent.\n");
1001 if (msg == nullptr) {
1002 LOGE("msg is null.\n");
1003 return;
1004 }
1005
1006 DealSetStaConnectFailedCount(1, false);
1007 if (msg->GetMessageName() != WIFI_SVR_CMD_STA_WPA_PASSWD_WRONG_EVENT &&
1008 DealReconnectSavedNetwork()) {
1009 return;
1010 }
1011
1012 StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
1013 InitWifiLinkedInfo();
1014 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
1015 if (msg->GetMessageName() == WIFI_SVR_CMD_STA_WPA_PASSWD_WRONG_EVENT) {
1016 SaveDiscReason(DisconnectedReason::DISC_REASON_WRONG_PWD);
1017 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::PASSWORD_ERROR);
1018 staCallback.OnStaConnChanged(OperateResState::CONNECT_PASSWORD_WRONG, linkedInfo);
1019 } else if (msg->GetMessageName() == WIFI_SVR_CMD_STA_WPA_FULL_CONNECT_EVENT) {
1020 DisableNetwork(targetNetworkId);
1021 SaveDiscReason(DisconnectedReason::DISC_REASON_CONNECTION_FULL);
1022 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::CONNECTION_FULL);
1023 staCallback.OnStaConnChanged(OperateResState::CONNECT_CONNECTION_FULL, linkedInfo);
1024 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo);
1025 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
1026 } else if (msg->GetMessageName() == WIFI_SVR_CMD_STA_WPA_ASSOC_REJECT_EVENT) {
1027 DisableNetwork(targetNetworkId);
1028 SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT);
1029 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::CONNECTION_REJECT);
1030 staCallback.OnStaConnChanged(OperateResState::CONNECT_CONNECTION_REJECT, linkedInfo);
1031 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo);
1032 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
1033 }
1034 }
1035
DealReconnectSavedNetwork()1036 bool StaStateMachine::DealReconnectSavedNetwork()
1037 {
1038 linkedInfo.retryedConnCount++;
1039 if (linkedInfo.retryedConnCount < MAX_RETRY_COUNT) {
1040 SendMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK,
1041 targetNetworkId, NETWORK_SELECTED_BY_RETRY);
1042 WIFI_LOGW("DealConnectTimeOutCmd retry connect to saved network.\n");
1043 return true;
1044 }
1045 return false;
1046 }
1047
DealSetStaConnectFailedCount(int count,bool set)1048 void StaStateMachine::DealSetStaConnectFailedCount(int count, bool set)
1049 {
1050 WifiDeviceConfig config;
1051 int ret = WifiSettings::GetInstance().GetDeviceConfig(targetNetworkId, config);
1052 if (ret != 0) {
1053 WIFI_LOGW("DealConnectTimeOutCmd get device[%{public}d] config failed.\n", targetNetworkId);
1054 return;
1055 }
1056 if (set) {
1057 WifiSettings::GetInstance().SetDeviceConnFailedCount(config.bssid, DEVICE_CONFIG_INDEX_BSSID,
1058 count);
1059 } else {
1060 WifiSettings::GetInstance().IncreaseDeviceConnFailedCount(config.bssid, DEVICE_CONFIG_INDEX_BSSID,
1061 count);
1062 }
1063 }
1064
DealReConnectCmd(InternalMessage * msg)1065 void StaStateMachine::DealReConnectCmd(InternalMessage *msg)
1066 {
1067 LOGI("enter DealReConnectCmd.\n");
1068 if (msg == nullptr) {
1069 WIFI_LOGE("msg is null\n");
1070 }
1071
1072 if (linkedInfo.connState == ConnState::CONNECTED) {
1073 WIFI_LOGE("Network is already connected, ignore the re-connect command!\n");
1074 return;
1075 }
1076
1077 if (WifiStaHalInterface::GetInstance().Reconnect() == WIFI_IDL_OPT_OK) {
1078 DealSetStaConnectFailedCount(0, true);
1079 WIFI_LOGI("StaStateMachine ReConnect successfully!");
1080 /* Callback result to InterfaceService */
1081 staCallback.OnStaConnChanged(OperateResState::CONNECT_CONNECTING, linkedInfo);
1082 StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
1083 StartTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT), STA_NETWORK_CONNECTTING_DELAY);
1084 } else {
1085 linkedInfo.retryedConnCount++;
1086 DealSetStaConnectFailedCount(1, false);
1087 WIFI_LOGE("ReConnect failed!");
1088 }
1089 }
1090
DealReassociateCmd(InternalMessage * msg)1091 void StaStateMachine::DealReassociateCmd(InternalMessage *msg)
1092 {
1093 LOGI("enter DealReassociateCmd.\n");
1094 if (msg == nullptr) {
1095 WIFI_LOGE("msg is null\n");
1096 }
1097
1098 if (WifiStaHalInterface::GetInstance().Reassociate() == WIFI_IDL_OPT_OK) {
1099 /* Callback result to InterfaceService */
1100 staCallback.OnStaConnChanged(OperateResState::CONNECT_ASSOCIATING, linkedInfo);
1101 WIFI_LOGD("StaStateMachine ReAssociate successfully!");
1102 StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
1103 StartTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT), STA_NETWORK_CONNECTTING_DELAY);
1104 } else {
1105 WIFI_LOGE("ReAssociate failed!");
1106 }
1107 }
1108
DealStartWpsCmd(InternalMessage * msg)1109 void StaStateMachine::DealStartWpsCmd(InternalMessage *msg)
1110 {
1111 WIFI_LOGI("enter DealStartWpsCmd\n");
1112 if (msg == nullptr) {
1113 return;
1114 }
1115
1116 if (WifiStaHalInterface::GetInstance().ClearDeviceConfig() != WIFI_IDL_OPT_OK) {
1117 LOGE("ClearDeviceConfig() failed!");
1118 return;
1119 }
1120
1121 StartWpsMode(msg);
1122 if ((wpsState == SetupMethod::DISPLAY) || (wpsState == SetupMethod::KEYPAD)) {
1123 WIFI_LOGW("Clear WPA block list every ten second!");
1124 SendMessage(WPA_BLOCK_LIST_CLEAR_EVENT);
1125 }
1126 }
1127
StartWpsMode(InternalMessage * msg)1128 void StaStateMachine::StartWpsMode(InternalMessage *msg)
1129 {
1130 if (msg == nullptr) {
1131 return;
1132 }
1133 /*
1134 * Make judgement to wps configuration information: the function will exit if
1135 * the result is fail, then else continue to chose the Wps starting mode. The
1136 * current state of StaStateMachine transfers to WpsState after Wps code start
1137 * successfully.
1138 */
1139 WifiIdlWpsConfig wpsParam;
1140 WpsConfig wpsConfig;
1141 wpsConfig.setup = static_cast<SetupMethod>(msg->GetParam1());
1142 wpsConfig.pin = msg->GetStringFromMessage();
1143 wpsConfig.bssid = msg->GetStringFromMessage();
1144 if (wpsConfig.bssid.length() == 0 || wpsConfig.bssid == PBC_ANY_BSSID) {
1145 wpsParam.anyFlag = 1;
1146 wpsParam.bssid = PBC_ANY_BSSID;
1147 } else {
1148 wpsParam.anyFlag = 0;
1149 wpsParam.bssid = wpsConfig.bssid;
1150 }
1151 wpsParam.multiAp = MULTI_AP;
1152 WIFI_LOGI("wpsConfig setup = %{public}d", wpsConfig.setup);
1153 WIFI_LOGI("wpsParam.AnyFlag = %{public}d, wpsParam.mulitAp = %{public}d, wpsParam.bssid = %{public}s",
1154 wpsParam.anyFlag,
1155 wpsParam.multiAp,
1156 MacAnonymize(wpsParam.bssid).c_str());
1157
1158 if (wpsConfig.setup == SetupMethod::PBC) {
1159 if (WifiStaHalInterface::GetInstance().StartWpsPbcMode(wpsParam) == WIFI_IDL_OPT_OK) {
1160 wpsState = wpsConfig.setup;
1161 WIFI_LOGD("StartWpsPbcMode() succeed!");
1162 /* Callback result to InterfaceService. */
1163 staCallback.OnWpsChanged(WpsStartState::START_PBC_SUCCEED, pinCode);
1164 SwitchState(pWpsState);
1165 } else {
1166 LOGE("StartWpsPbcMode() failed!");
1167 staCallback.OnWpsChanged(WpsStartState::START_PBC_FAILED, pinCode);
1168 }
1169 } else if (wpsConfig.setup == SetupMethod::DISPLAY) {
1170 if (WifiStaHalInterface::GetInstance().StartWpsPinMode(wpsParam, pinCode) == WIFI_IDL_OPT_OK) {
1171 wpsState = wpsConfig.setup;
1172 /* Callback result to InterfaceService. */
1173 staCallback.OnWpsChanged(WpsStartState::START_PIN_SUCCEED, pinCode);
1174 WIFI_LOGD("StartWpsPinMode() succeed! pincode: %d", pinCode);
1175 SwitchState(pWpsState);
1176 } else {
1177 WIFI_LOGE("StartWpsPinMode() failed!");
1178 staCallback.OnWpsChanged(WpsStartState::START_PIN_FAILED, pinCode);
1179 }
1180 } else if (wpsConfig.setup == SetupMethod::KEYPAD) {
1181 if (WifiStaHalInterface::GetInstance().StartWpsPinMode(wpsParam, pinCode) == WIFI_IDL_OPT_OK) {
1182 wpsState = wpsConfig.setup;
1183 /* Callback result to InterfaceService. */
1184 staCallback.OnWpsChanged(WpsStartState::START_AP_PIN_SUCCEED, pinCode);
1185 SwitchState(pWpsState);
1186 } else {
1187 LOGE("StartWpsPinMode() failed.");
1188 staCallback.OnWpsChanged(WpsStartState::START_AP_PIN_FAILED, pinCode);
1189 }
1190 } else {
1191 LOGE("Start Wps failed!");
1192 staCallback.OnWpsChanged(WpsStartState::START_WPS_FAILED, pinCode);
1193 }
1194 }
1195
DealWpaBlockListClearEvent(InternalMessage * msg)1196 void StaStateMachine::DealWpaBlockListClearEvent(InternalMessage *msg)
1197 {
1198 if (msg != nullptr) {
1199 WIFI_LOGE("enter DealWpaBlockListClearEvent\n");
1200 }
1201 if (WifiStaHalInterface::GetInstance().WpaBlocklistClear() != WIFI_IDL_OPT_OK) {
1202 WIFI_LOGE("Clearing the Wpa_blocklist failed\n");
1203 }
1204 StartTimer(static_cast<int>(WPA_BLOCK_LIST_CLEAR_EVENT), BLOCK_LIST_CLEAR_TIMER);
1205 WIFI_LOGI("Clearing the Wpa_blocklist.\n");
1206 }
1207
DealWpsConnectTimeOutEvent(InternalMessage * msg)1208 void StaStateMachine::DealWpsConnectTimeOutEvent(InternalMessage *msg)
1209 {
1210 WIFI_LOGW("enter DealWpsConnectTimeOutEvent\n");
1211 if (msg == nullptr) {
1212 WIFI_LOGE("msg is nullptr!\n");
1213 return;
1214 }
1215
1216 DealCancelWpsCmd(msg);
1217
1218 /* Callback InterfaceService that WPS time out. */
1219 staCallback.OnWpsChanged(WpsStartState::WPS_TIME_OUT, pinCode);
1220 SwitchState(pSeparatedState);
1221 }
1222
DealCancelWpsCmd(InternalMessage * msg)1223 void StaStateMachine::DealCancelWpsCmd(InternalMessage *msg)
1224 {
1225 if (msg == nullptr) {
1226 WIFI_LOGE("msg is null\n");
1227 }
1228
1229 StopTimer(static_cast<int>(WPA_BLOCK_LIST_CLEAR_EVENT));
1230 isWpsConnect = IsWpsConnected::WPS_INVALID;
1231 if (WifiStaHalInterface::GetInstance().StopWps() == WIFI_IDL_OPT_OK) {
1232 WIFI_LOGI("CancelWps succeed!");
1233 /* Callback result to InterfaceService that stop Wps connection successfully. */
1234 if (wpsState == SetupMethod::PBC) {
1235 staCallback.OnWpsChanged(WpsStartState::STOP_PBC_SUCCEED, pinCode);
1236 } else if (wpsState == SetupMethod::DISPLAY) {
1237 staCallback.OnWpsChanged(WpsStartState::STOP_PIN_SUCCEED, pinCode);
1238 } else if (wpsState == SetupMethod::KEYPAD) {
1239 staCallback.OnWpsChanged(WpsStartState::STOP_AP_PIN_SUCCEED, pinCode);
1240 }
1241 if (wpsState != SetupMethod::INVALID) {
1242 wpsState = SetupMethod::INVALID;
1243 SyncAllDeviceConfigs();
1244
1245 if (WifiStaHalInterface::GetInstance().EnableNetwork(lastNetworkId) == WIFI_IDL_OPT_OK) {
1246 WIFI_LOGI("EnableNetwork success! networkId is %{public}d", lastNetworkId);
1247 if (WifiStaHalInterface::GetInstance().SaveDeviceConfig() != WIFI_IDL_OPT_OK) {
1248 WIFI_LOGW("SaveDeviceConfig failed!");
1249 } else {
1250 WIFI_LOGI("SaveDeviceConfig success!");
1251 }
1252 } else {
1253 WIFI_LOGE("EnableNetwork failed");
1254 }
1255 }
1256 } else {
1257 WIFI_LOGE("CancelWps failed!");
1258 if (wpsState == SetupMethod::PBC) {
1259 staCallback.OnWpsChanged(WpsStartState::STOP_PBC_FAILED, pinCode);
1260 } else if (wpsState == SetupMethod::DISPLAY) {
1261 staCallback.OnWpsChanged(WpsStartState::STOP_PIN_FAILED, pinCode);
1262 } else if (wpsState == SetupMethod::KEYPAD) {
1263 staCallback.OnWpsChanged(WpsStartState::STOP_AP_PIN_FAILED, pinCode);
1264 }
1265 }
1266 SwitchState(pSeparatedState);
1267 }
1268
DealStartRoamCmd(InternalMessage * msg)1269 void StaStateMachine::DealStartRoamCmd(InternalMessage *msg)
1270 {
1271 if (msg == nullptr) {
1272 return;
1273 }
1274
1275 WIFI_LOGI("enter DealStartRoamCmd\n");
1276 std::string bssid = msg->GetStringFromMessage();
1277 /* GetDeviceConfig from Configuration center. */
1278 WifiDeviceConfig network;
1279 WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, network);
1280
1281 /* Setting the network. */
1282 WifiIdlDeviceConfig idlConfig;
1283 idlConfig.networkId = linkedInfo.networkId;
1284 idlConfig.ssid = linkedInfo.ssid;
1285 idlConfig.bssid = bssid;
1286 idlConfig.psk = network.preSharedKey;
1287 idlConfig.keyMgmt = network.keyMgmt;
1288 idlConfig.priority = network.priority;
1289 idlConfig.scanSsid = network.hiddenSSID ? 1 : 0;
1290 idlConfig.eap = network.wifiEapConfig.eap;
1291 idlConfig.identity = network.wifiEapConfig.identity;
1292 idlConfig.password = network.wifiEapConfig.password;
1293 idlConfig.clientCert = network.wifiEapConfig.clientCert;
1294 idlConfig.privateKey = network.wifiEapConfig.privateKey;
1295 idlConfig.phase2Method = static_cast<int>(network.wifiEapConfig.phase2Method);
1296
1297 if (WifiStaHalInterface::GetInstance().SetDeviceConfig(linkedInfo.networkId, idlConfig) != WIFI_IDL_OPT_OK) {
1298 WIFI_LOGE("DealStartRoamCmd SetDeviceConfig() failed!");
1299 return;
1300 }
1301 WIFI_LOGD("DealStartRoamCmd SetDeviceConfig() succeed!");
1302
1303 /* Save to Configuration center. */
1304 network.bssid = bssid;
1305 WifiSettings::GetInstance().AddDeviceConfig(network);
1306 WifiSettings::GetInstance().SyncDeviceConfig();
1307
1308 /* Save linkedinfo */
1309 linkedInfo.bssid = bssid;
1310 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
1311
1312 if (WifiStaHalInterface::GetInstance().Reassociate() != WIFI_IDL_OPT_OK) {
1313 WIFI_LOGE("START_ROAM-ReAssociate() failed!");
1314 }
1315 WIFI_LOGI("START_ROAM-ReAssociate() succeeded!");
1316 /* Start roaming */
1317 SwitchState(pApRoamingState);
1318 }
1319
StartConnectToNetwork(int networkId)1320 ErrCode StaStateMachine::StartConnectToNetwork(int networkId)
1321 {
1322 targetNetworkId = networkId;
1323 SetRandomMac(targetNetworkId);
1324
1325 WifiDeviceConfig deviceConfig;
1326 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, deviceConfig) != 0) {
1327 LOGE("StartConnectToNetwork get GetDeviceConfig failed!");
1328 return WIFI_OPT_FAILED;
1329 }
1330
1331 WifiStaHalInterface::GetInstance().SetBssid(networkId, deviceConfig.userSelectBssid.c_str());
1332
1333 if (WifiStaHalInterface::GetInstance().EnableNetwork(targetNetworkId) != WIFI_IDL_OPT_OK) {
1334 LOGE("EnableNetwork() failed!");
1335 return WIFI_OPT_FAILED;
1336 }
1337
1338 if (WifiStaHalInterface::GetInstance().Connect(targetNetworkId) != WIFI_IDL_OPT_OK) {
1339 LOGE("Connect failed!");
1340 staCallback.OnStaConnChanged(OperateResState::CONNECT_SELECT_NETWORK_FAILED, linkedInfo);
1341 return WIFI_OPT_FAILED;
1342 }
1343
1344 if (WifiStaHalInterface::GetInstance().SaveDeviceConfig() != WIFI_IDL_OPT_OK) {
1345 /* OHOS's wpa don't support save command, so don't judge as failure */
1346 LOGD("SaveDeviceConfig() failed!");
1347 }
1348
1349 StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
1350 StartTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT), STA_NETWORK_CONNECTTING_DELAY);
1351 return WIFI_OPT_SUCCESS;
1352 }
1353
MacAddressGenerate(WifiStoreRandomMac & randomMacInfo)1354 void StaStateMachine::MacAddressGenerate(WifiStoreRandomMac &randomMacInfo)
1355 {
1356 LOGD("enter MacAddressGenerate\n");
1357 constexpr int arraySize = 4;
1358 constexpr int macBitSize = 12;
1359 constexpr int firstBit = 1;
1360 constexpr int lastBit = 11;
1361 constexpr int two = 2;
1362 constexpr int hexBase = 16;
1363 constexpr int octBase = 8;
1364 int ret = 0;
1365 char strMacTmp[arraySize] = {0};
1366 std::mt19937_64 gen(std::chrono::high_resolution_clock::now().time_since_epoch().count()
1367 + std::hash<std::string>{}(randomMacInfo.peerBssid) + std::hash<std::string>{}(randomMacInfo.preSharedKey));
1368 for (int i = 0; i < macBitSize; i++) {
1369 if (i != firstBit) {
1370 std::uniform_int_distribution<> distribution(0, hexBase - 1);
1371 ret = sprintf_s(strMacTmp, arraySize, "%x", distribution(gen));
1372 } else {
1373 std::uniform_int_distribution<> distribution(0, octBase - 1);
1374 ret = sprintf_s(strMacTmp, arraySize, "%x", two * distribution(gen));
1375 }
1376 if (ret == -1) {
1377 LOGE("StaStateMachine::MacAddressGenerate failed, sprintf_s return -1!\n");
1378 }
1379 randomMacInfo.randomMac += strMacTmp;
1380 if ((i % two) != 0 && (i != lastBit)) {
1381 randomMacInfo.randomMac.append(":");
1382 }
1383 }
1384 }
1385
ComparedKeymgmt(const std::string scanInfoKeymgmt,const std::string deviceKeymgmt)1386 bool StaStateMachine::ComparedKeymgmt(const std::string scanInfoKeymgmt, const std::string deviceKeymgmt)
1387 {
1388 if (deviceKeymgmt == "WPA-PSK") {
1389 return scanInfoKeymgmt.find("PSK") != std::string::npos;
1390 } else if (deviceKeymgmt == "WPA-EAP") {
1391 return scanInfoKeymgmt.find("EAP") != std::string::npos;
1392 } else if (deviceKeymgmt == "SAE") {
1393 return scanInfoKeymgmt.find("SAE") != std::string::npos;
1394 } else if (deviceKeymgmt == "NONE") {
1395 return (scanInfoKeymgmt.find("PSK") == std::string::npos) &&
1396 (scanInfoKeymgmt.find("EAP") == std::string::npos) && (scanInfoKeymgmt.find("SAE") == std::string::npos);
1397 } else {
1398 return false;
1399 }
1400 }
1401
SetRandomMac(int networkId)1402 bool StaStateMachine::SetRandomMac(int networkId)
1403 {
1404 LOGD("enter SetRandomMac.\n");
1405 WifiDeviceConfig deviceConfig;
1406 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, deviceConfig) != 0) {
1407 LOGE("SetRandomMac : GetDeviceConfig failed!\n");
1408 return false;
1409 }
1410 std::string lastMac;
1411 std::string currentMac;
1412 if (deviceConfig.wifiPrivacySetting == WifiPrivacyConfig::DEVICEMAC) {
1413 } else {
1414 WifiStoreRandomMac randomMacInfo;
1415 std::vector<WifiScanInfo> scanInfoList;
1416 WifiSettings::GetInstance().GetScanInfoList(scanInfoList);
1417 for (auto scanInfo : scanInfoList) {
1418 if ((deviceConfig.ssid == scanInfo.ssid) &&
1419 (ComparedKeymgmt(scanInfo.capabilities, deviceConfig.keyMgmt))) {
1420 randomMacInfo.ssid = scanInfo.ssid;
1421 randomMacInfo.keyMgmt = deviceConfig.keyMgmt;
1422 randomMacInfo.preSharedKey = deviceConfig.preSharedKey;
1423 randomMacInfo.peerBssid = scanInfo.bssid;
1424 break;
1425 }
1426 }
1427 if (randomMacInfo.ssid.empty()) {
1428 LOGE("scanInfo has no target wifi!\n");
1429 return false;
1430 }
1431
1432 WifiSettings::GetInstance().GetRandomMac(randomMacInfo);
1433 if (randomMacInfo.randomMac.empty()) {
1434 /* Sets the MAC address of WifiSettings. */
1435 MacAddressGenerate(randomMacInfo);
1436 WifiSettings::GetInstance().AddRandomMac(randomMacInfo);
1437 }
1438 currentMac = randomMacInfo.randomMac;
1439 }
1440
1441 if ((WifiStaHalInterface::GetInstance().GetStaDeviceMacAddress(lastMac)) != WIFI_IDL_OPT_OK) {
1442 LOGE("GetStaDeviceMacAddress failed!");
1443 return false;
1444 }
1445
1446 if (MacAddress::IsValidMac(currentMac.c_str())) {
1447 LOGD("Check MacAddress successfully.\n");
1448 if (lastMac != currentMac) {
1449 if (WifiStaHalInterface::GetInstance().SetConnectMacAddr(currentMac) != WIFI_IDL_OPT_OK) {
1450 LOGE("set Mac [%{public}s] failed.\n", MacAnonymize(currentMac).c_str());
1451 return false;
1452 }
1453 }
1454 WifiSettings::GetInstance().SetMacAddress(currentMac);
1455 deviceConfig.macAddress = currentMac;
1456 WifiSettings::GetInstance().AddDeviceConfig(deviceConfig);
1457 WifiSettings::GetInstance().SyncDeviceConfig();
1458 } else {
1459 LOGE("Check MacAddress error.\n");
1460 return false;
1461 }
1462 return true;
1463 }
1464
StartRoamToNetwork(std::string bssid)1465 void StaStateMachine::StartRoamToNetwork(std::string bssid)
1466 {
1467 InternalMessage *msg = CreateMessage();
1468 if (msg == nullptr) {
1469 return;
1470 }
1471
1472 msg->SetMessageName(WIFI_SVR_COM_STA_START_ROAM);
1473 msg->AddStringMessageBody(bssid);
1474 SendMessage(msg);
1475 }
1476
IsRoaming(void)1477 bool StaStateMachine::IsRoaming(void)
1478 {
1479 return isRoam;
1480 }
1481
OnNetworkConnectionEvent(int networkId,std::string bssid)1482 void StaStateMachine::OnNetworkConnectionEvent(int networkId, std::string bssid)
1483 {
1484 InternalMessage *msg = CreateMessage();
1485 if (msg == nullptr) {
1486 LOGE("msg is nullptr.\n");
1487 return;
1488 }
1489
1490 msg->SetMessageName(WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT);
1491 msg->SetParam1(networkId);
1492 msg->AddStringMessageBody(bssid);
1493 SendMessage(msg);
1494 }
1495
OnBssidChangedEvent(std::string reason,std::string bssid)1496 void StaStateMachine::OnBssidChangedEvent(std::string reason, std::string bssid)
1497 {
1498 InternalMessage *msg = CreateMessage();
1499 if (msg == nullptr) {
1500 LOGE("msg is nullptr.\n");
1501 return;
1502 }
1503
1504 msg->SetMessageName(WIFI_SVR_CMD_STA_BSSID_CHANGED_EVENT);
1505 msg->AddStringMessageBody(reason);
1506 msg->AddStringMessageBody(bssid);
1507 SendMessage(msg);
1508 }
1509
OnDhcpResultNotifyEvent(bool result)1510 void StaStateMachine::OnDhcpResultNotifyEvent(bool result)
1511 {
1512 InternalMessage *msg = CreateMessage();
1513 if (msg == nullptr) {
1514 LOGE("msg is nullptr.\n");
1515 return;
1516 }
1517
1518 msg->SetMessageName(WIFI_SVR_CMD_STA_DHCP_RESULT_NOTIFY_EVENT);
1519 msg->SetParam1(result);
1520 SendMessage(msg);
1521 }
1522
1523 /* --------------------------- state machine Separating State ------------------------------ */
SeparatingState()1524 StaStateMachine::SeparatingState::SeparatingState() : State("SeparatingState")
1525 {}
1526
~SeparatingState()1527 StaStateMachine::SeparatingState::~SeparatingState()
1528 {}
1529
GoInState()1530 void StaStateMachine::SeparatingState::GoInState()
1531 {
1532 WIFI_LOGI("SeparatingState GoInState function.");
1533 return;
1534 }
1535
GoOutState()1536 void StaStateMachine::SeparatingState::GoOutState()
1537 {
1538 WIFI_LOGI("SeparatingState GoOutState function.");
1539 }
1540
ExecuteStateMsg(InternalMessage * msg)1541 bool StaStateMachine::SeparatingState::ExecuteStateMsg(InternalMessage *msg)
1542 {
1543 if (msg == nullptr) {
1544 return false;
1545 }
1546
1547 bool ret = NOT_EXECUTED;
1548 WIFI_LOGI("SeparatingState-msgCode=%{public}d not handled.\n", msg->GetMessageName());
1549 return ret;
1550 }
1551
1552 /* --------------------------- state machine Disconnected State ------------------------------ */
SeparatedState(StaStateMachine * staStateMachine)1553 StaStateMachine::SeparatedState::SeparatedState(StaStateMachine *staStateMachine)
1554 : State("SeparatedState"), pStaStateMachine(staStateMachine)
1555 {}
1556
~SeparatedState()1557 StaStateMachine::SeparatedState::~SeparatedState()
1558 {}
1559
GoInState()1560 void StaStateMachine::SeparatedState::GoInState()
1561 {
1562 WIFI_LOGI("SeparatedState GoInState function.");
1563 return;
1564 }
1565
GoOutState()1566 void StaStateMachine::SeparatedState::GoOutState()
1567 {
1568 WIFI_LOGI("SeparatedState GoOutState function.");
1569 return;
1570 }
1571
ExecuteStateMsg(InternalMessage * msg)1572 bool StaStateMachine::SeparatedState::ExecuteStateMsg(InternalMessage *msg)
1573 {
1574 if (msg == nullptr) {
1575 return false;
1576 }
1577
1578 WIFI_LOGI("SeparatedState-msgCode=%{public}d received.\n", msg->GetMessageName());
1579 bool ret = NOT_EXECUTED;
1580 switch (msg->GetMessageName()) {
1581 case WIFI_SVR_CMD_STA_NETWORK_DISCONNECTION_EVENT:
1582 break;
1583
1584 case WIFI_SVR_CMD_STA_ENABLE_WIFI: {
1585 ret = EXECUTED;
1586 WIFI_LOGE("Wifi has already started! start Wifi failed!");
1587 /* Callback result to InterfaceService. */
1588 pStaStateMachine->staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_OVERRIDE_OPEN_FAILED);
1589 break;
1590 }
1591
1592 default:
1593 break;
1594 }
1595
1596 return ret;
1597 }
1598
1599 /* --------------------------- state machine ApConnected State ------------------------------ */
ApLinkedState(StaStateMachine * staStateMachine)1600 StaStateMachine::ApLinkedState::ApLinkedState(StaStateMachine *staStateMachine)
1601 : State("ApLinkedState"), pStaStateMachine(staStateMachine)
1602 {}
1603
~ApLinkedState()1604 StaStateMachine::ApLinkedState::~ApLinkedState()
1605 {}
1606
GoInState()1607 void StaStateMachine::ApLinkedState::GoInState()
1608 {
1609 WIFI_LOGI("ApLinkedState GoInState function.");
1610 return;
1611 }
1612
GoOutState()1613 void StaStateMachine::ApLinkedState::GoOutState()
1614 {
1615 WIFI_LOGI("ApLinkedState GoOutState function.");
1616 return;
1617 }
1618
ExecuteStateMsg(InternalMessage * msg)1619 bool StaStateMachine::ApLinkedState::ExecuteStateMsg(InternalMessage *msg)
1620 {
1621 if (msg == nullptr) {
1622 return false;
1623 }
1624
1625 WIFI_LOGD("ApLinkedState-msgCode=%{public}d received.\n", msg->GetMessageName());
1626 bool ret = NOT_EXECUTED;
1627 switch (msg->GetMessageName()) {
1628 /* The current state of StaStateMachine transfers to SeparatingState when
1629 * receive the Separating message.
1630 */
1631 case WIFI_SVR_CMD_STA_DISCONNECT: {
1632 ret = EXECUTED;
1633 pStaStateMachine->DisConnectProcess();
1634 break;
1635 }
1636 case WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT: {
1637 ret = EXECUTED;
1638 pStaStateMachine->StopTimer(static_cast<int>(WPA_BLOCK_LIST_CLEAR_EVENT));
1639 WIFI_LOGI("Stop clearing wpa block list");
1640 /* Save linkedinfo */
1641 pStaStateMachine->linkedInfo.networkId = msg->GetParam1();
1642 pStaStateMachine->linkedInfo.bssid = msg->GetStringFromMessage();
1643 WifiSettings::GetInstance().SaveLinkedInfo(pStaStateMachine->linkedInfo);
1644
1645 break;
1646 }
1647 default:
1648 break;
1649 }
1650 return ret;
1651 }
1652
DisConnectProcess()1653 void StaStateMachine::DisConnectProcess()
1654 {
1655 WIFI_LOGI("Enter DisConnectProcess!");
1656 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTING, linkedInfo);
1657 if (WifiStaHalInterface::GetInstance().Disconnect() == WIFI_IDL_OPT_OK) {
1658 WIFI_LOGI("Disconnect() succeed!");
1659 #ifndef OHOS_ARCH_LITE
1660 if (NetSupplierInfo != nullptr) {
1661 NetSupplierInfo->isAvailable_ = false;
1662 WIFI_LOGI("Disconnect process update netsupplierinfo");
1663 WifiNetAgent::GetInstance().OnStaMachineUpdateNetSupplierInfo(NetSupplierInfo);
1664 }
1665 #endif
1666 WIFI_LOGI("Disconnect update wifi status");
1667 /* Save connection information to WifiSettings. */
1668 SaveLinkstate(ConnState::DISCONNECTED, DetailedState::DISCONNECTED);
1669 DisableNetwork(linkedInfo.networkId);
1670
1671 getIpSucNum = 0;
1672 /* The current state of StaStateMachine transfers to SeparatedState. */
1673 SwitchState(pSeparatedState);
1674 } else {
1675 SaveLinkstate(ConnState::DISCONNECTING, DetailedState::FAILED);
1676 staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECT_FAILED, linkedInfo);
1677 WIFI_LOGE("Disconnect() failed!");
1678 }
1679 }
1680
1681 /* --------------------------- state machine Wps State ------------------------------ */
StaWpsState(StaStateMachine * staStateMachine)1682 StaStateMachine::StaWpsState::StaWpsState(StaStateMachine *staStateMachine)
1683 : State("StaWpsState"), pStaStateMachine(staStateMachine)
1684 {}
1685
~StaWpsState()1686 StaStateMachine::StaWpsState::~StaWpsState()
1687 {}
1688
GoInState()1689 void StaStateMachine::StaWpsState::GoInState()
1690 {
1691 WIFI_LOGI("WpsState GoInState function.");
1692 return;
1693 }
1694
GoOutState()1695 void StaStateMachine::StaWpsState::GoOutState()
1696 {
1697 WIFI_LOGI("WpsState GoOutState function.");
1698 }
1699
ExecuteStateMsg(InternalMessage * msg)1700 bool StaStateMachine::StaWpsState::ExecuteStateMsg(InternalMessage *msg)
1701 {
1702 if (msg == nullptr) {
1703 return false;
1704 }
1705
1706 bool ret = NOT_EXECUTED;
1707 switch (msg->GetMessageName()) {
1708 case WIFI_SVR_CMD_STA_WPS_START_EVENT: {
1709 /* Wps starts successfully and Wait until the connection is complete. */
1710 break;
1711 }
1712 case WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT: {
1713 ret = EXECUTED;
1714 /* Stop clearing the Wpa_blocklist. */
1715 pStaStateMachine->StopTimer(static_cast<int>(WPA_BLOCK_LIST_CLEAR_EVENT));
1716
1717 WIFI_LOGI("WPS mode connect to a network!");
1718 pStaStateMachine->ConnectToNetworkProcess(msg);
1719 pStaStateMachine->SyncAllDeviceConfigs();
1720 /* Callback result to InterfaceService. */
1721 pStaStateMachine->SaveLinkstate(ConnState::CONNECTING, DetailedState::OBTAINING_IPADDR);
1722 pStaStateMachine->staCallback.OnStaConnChanged(OperateResState::CONNECT_OBTAINING_IP,
1723 pStaStateMachine->linkedInfo);
1724 pStaStateMachine->SwitchState(pStaStateMachine->pGetIpState);
1725 break;
1726 }
1727 case WIFI_SVR_CMD_STA_STARTWPS: {
1728 ret = EXECUTED;
1729 auto setup = static_cast<SetupMethod>(msg->GetParam1());
1730 /* Callback InterfaceService that wps has started successfully. */
1731 WIFI_LOGE("WPS has already started, start wps failed!");
1732 if (setup == SetupMethod::PBC) {
1733 pStaStateMachine->staCallback.OnWpsChanged(WpsStartState::PBC_STARTED_ALREADY,
1734 pStaStateMachine->pinCode);
1735 } else if ((setup == SetupMethod::DISPLAY) || (setup == SetupMethod::KEYPAD)) {
1736 pStaStateMachine->staCallback.OnWpsChanged(WpsStartState::PIN_STARTED_ALREADY,
1737 pStaStateMachine->pinCode);
1738 }
1739 break;
1740 }
1741 case WIFI_SVR_CMD_STA_WPS_OVERLAP_EVENT: {
1742 ret = EXECUTED;
1743 WIFI_LOGI("Wps PBC Overlap!");
1744 /* Callback InterfaceService that PBC is conflicting. */
1745 pStaStateMachine->staCallback.OnWpsChanged(WpsStartState::START_PBC_FAILED_OVERLAP,
1746 pStaStateMachine->pinCode);
1747 pStaStateMachine->SwitchState(pStaStateMachine->pSeparatedState);
1748 break;
1749 }
1750 case WIFI_SVR_CMD_STA_CANCELWPS: {
1751 ret = EXECUTED;
1752 pStaStateMachine->DealCancelWpsCmd(msg);
1753 break;
1754 }
1755 default:
1756 break;
1757 }
1758 return ret;
1759 }
1760
SyncAllDeviceConfigs()1761 void StaStateMachine::SyncAllDeviceConfigs()
1762 {
1763 std::vector<WifiDeviceConfig> result;
1764 WifiIdlDeviceConfig idlConfig;
1765 if (WifiSettings::GetInstance().GetDeviceConfig(result) != -1) {
1766 for (std::vector<WifiDeviceConfig>::iterator it = result.begin(); it != result.end(); ++it) {
1767 if (isWpsConnect == IsWpsConnected::WPS_CONNECTED && it->networkId == 0) {
1768 continue;
1769 }
1770 if (WifiStaHalInterface::GetInstance().GetNextNetworkId(it->networkId) == WIFI_IDL_OPT_OK) {
1771 WIFI_LOGI("GetNextNetworkId succeed");
1772 idlConfig.networkId = it->networkId;
1773 idlConfig.ssid = it->ssid;
1774 idlConfig.psk = it->preSharedKey;
1775 idlConfig.keyMgmt = it->keyMgmt;
1776 idlConfig.priority = it->priority;
1777 idlConfig.scanSsid = it->hiddenSSID ? 1 : 0;
1778 idlConfig.eap = it->wifiEapConfig.eap;
1779 idlConfig.identity = it->wifiEapConfig.identity;
1780 idlConfig.password = it->wifiEapConfig.password;
1781 idlConfig.clientCert = it->wifiEapConfig.clientCert;
1782 idlConfig.privateKey = it->wifiEapConfig.privateKey;
1783 idlConfig.phase2Method = static_cast<int>(it->wifiEapConfig.phase2Method);
1784 if (WifiStaHalInterface::GetInstance().SetDeviceConfig(it->networkId, idlConfig) != WIFI_IDL_OPT_OK) {
1785 WIFI_LOGE("SetDeviceConfig failed!");
1786 }
1787 WIFI_LOGD("SetDeviceConfig succeed!");
1788 } else {
1789 WIFI_LOGE("GetNextNetworkId failed!");
1790 }
1791 WIFI_LOGD("networkId = %{public}d", it->networkId);
1792 WifiStaHalInterface::GetInstance().SaveDeviceConfig();
1793 }
1794 WIFI_LOGD("Synchronizing network information!");
1795 } else {
1796 WIFI_LOGE("The Device config in WifiSettings is empty!");
1797 }
1798 }
1799
1800 /* --------------------------- state machine GetIp State ------------------------------ */
GetIpState(StaStateMachine * staStateMachine)1801 StaStateMachine::GetIpState::GetIpState(StaStateMachine *staStateMachine)
1802 : State("GetIpState"), pStaStateMachine(staStateMachine)
1803 {}
1804
~GetIpState()1805 StaStateMachine::GetIpState::~GetIpState()
1806 {}
1807
GoInState()1808 void StaStateMachine::GetIpState::GoInState()
1809 {
1810 WIFI_LOGI("GetIpState GoInState function.");
1811 #ifdef WIFI_DHCP_DISABLED
1812 SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT);
1813 SaveLinkstate(ConnState::CONNECTED, DetailedState::WORKING);
1814 staCallback.OnStaConnChanged(OperateResState::CONNECT_NETWORK_ENABLED, linkedInfo);
1815 SwitchState(pLinkedState);
1816 return;
1817 #endif
1818 pStaStateMachine->getIpSucNum = 0;
1819 WifiDeviceConfig config;
1820 AssignIpMethod assignMethod = AssignIpMethod::DHCP;
1821 int ret = WifiSettings::GetInstance().GetDeviceConfig(pStaStateMachine->linkedInfo.networkId, config);
1822 if (ret == 0) {
1823 assignMethod = config.wifiIpConfig.assignMethod;
1824 }
1825
1826 if (assignMethod == AssignIpMethod::STATIC) {
1827 pStaStateMachine->currentTpType = config.wifiIpConfig.staticIpAddress.ipAddress.address.family;
1828 if (!pStaStateMachine->ConfigStaticIpAddress(config.wifiIpConfig.staticIpAddress)) {
1829 if (pStaStateMachine->staCallback.OnStaConnChanged != nullptr) {
1830 pStaStateMachine->staCallback.OnStaConnChanged(
1831 OperateResState::CONNECT_NETWORK_DISABLED, pStaStateMachine->linkedInfo);
1832 }
1833 pStaStateMachine->DisConnectProcess();
1834 LOGE("ConfigstaticIpAddress failed!\n");
1835 }
1836 } else {
1837 int dhcpRet = 0;
1838 DhcpServiceInfo dhcpInfo;
1839 pStaStateMachine->pDhcpService->GetDhcpInfo(IF_NAME, dhcpInfo);
1840 LOGD("GetIpState get dhcp result, isRoam=%{public}d, clientRunStatus=%{public}d.",
1841 pStaStateMachine->isRoam, dhcpInfo.clientRunStatus);
1842 pStaStateMachine->currentTpType = static_cast<int>(WifiSettings::GetInstance().GetDhcpIpType());
1843 if (pStaStateMachine->currentTpType == IPTYPE_IPV4) {
1844 dhcpRet = pStaStateMachine->pDhcpService->StartDhcpClient(IF_NAME, false);
1845 } else {
1846 dhcpRet = pStaStateMachine->pDhcpService->StartDhcpClient(IF_NAME, true);
1847 }
1848 if ((dhcpRet != 0) || (pStaStateMachine->pDhcpService->GetDhcpResult(
1849 IF_NAME, pStaStateMachine->pDhcpResultNotify, DHCP_TIME) != 0)) {
1850 LOGE(" Dhcp connection failed.\n");
1851 pStaStateMachine->SaveLinkstate(ConnState::DISCONNECTED, DetailedState::OBTAINING_IPADDR_FAIL);
1852 pStaStateMachine->staCallback.OnStaConnChanged(
1853 OperateResState::CONNECT_OBTAINING_IP_FAILED, pStaStateMachine->linkedInfo);
1854 if (!pStaStateMachine->isRoam) {
1855 pStaStateMachine->DisConnectProcess();
1856 }
1857 }
1858 }
1859 return;
1860 }
1861
GoOutState()1862 void StaStateMachine::GetIpState::GoOutState()
1863 {
1864 WIFI_LOGI("GetIpState GoOutState function.");
1865 }
1866
ExecuteStateMsg(InternalMessage * msg)1867 bool StaStateMachine::GetIpState::ExecuteStateMsg(InternalMessage *msg)
1868 {
1869 if (msg == nullptr) {
1870 return false;
1871 }
1872
1873 bool ret = NOT_EXECUTED;
1874 bool result = false;
1875 WIFI_LOGI("GetIpState-msgCode=%{public}d received.\n", msg->GetMessageName());
1876 switch (msg->GetMessageName()) {
1877 case WIFI_SVR_CMD_STA_DHCP_RESULT_NOTIFY_EVENT: {
1878 ret = EXECUTED;
1879 result = msg->GetParam1();
1880 WIFI_LOGI("GetIpState, get ip result:%{public}d.\n", result);
1881 pStaStateMachine->SwitchState(pStaStateMachine->pLinkedState);
1882 break;
1883 }
1884 default:
1885 break;
1886 }
1887
1888 return ret;
1889 }
1890
1891 /* --- state machine GetIp State functions ----- */
ConfigStaticIpAddress(StaticIpAddress & staticIpAddress)1892 bool StaStateMachine::ConfigStaticIpAddress(StaticIpAddress &staticIpAddress)
1893 {
1894 WIFI_LOGI("Enter StaStateMachine::SetDhcpResultFromStatic.");
1895 DhcpResult result;
1896 switch (currentTpType) {
1897 case IPTYPE_IPV4: {
1898 result.iptype = IPTYPE_IPV4;
1899 result.strYourCli = staticIpAddress.ipAddress.address.GetIpv4Address();
1900 result.strRouter1 = staticIpAddress.gateway.GetIpv4Address();
1901 result.strSubnet = staticIpAddress.GetIpv4Mask();
1902 result.strDns1 = staticIpAddress.dnsServer1.GetIpv4Address();
1903 result.strDns2 = staticIpAddress.dnsServer2.GetIpv4Address();
1904 pDhcpResultNotify->OnSuccess(1, IF_NAME, result);
1905 break;
1906 }
1907 case IPTYPE_IPV6: {
1908 result.iptype = IPTYPE_IPV6;
1909 result.strYourCli = staticIpAddress.ipAddress.address.GetIpv6Address();
1910 result.strRouter1 = staticIpAddress.gateway.GetIpv6Address();
1911 result.strSubnet = staticIpAddress.GetIpv6Mask();
1912 result.strDns1 = staticIpAddress.dnsServer1.GetIpv6Address();
1913 result.strDns2 = staticIpAddress.dnsServer2.GetIpv6Address();
1914 pDhcpResultNotify->OnSuccess(1, IF_NAME, result);
1915 break;
1916 }
1917 case IPTYPE_MIX: {
1918 result.iptype = IPTYPE_IPV4;
1919 result.strYourCli = staticIpAddress.ipAddress.address.GetIpv4Address();
1920 result.strRouter1 = staticIpAddress.gateway.GetIpv4Address();
1921 result.strSubnet = staticIpAddress.GetIpv4Mask();
1922 result.strDns1 = staticIpAddress.dnsServer1.GetIpv4Address();
1923 result.strDns2 = staticIpAddress.dnsServer2.GetIpv4Address();
1924 pDhcpResultNotify->OnSuccess(1, IF_NAME, result);
1925
1926 result.iptype = IPTYPE_IPV6;
1927 result.strYourCli = staticIpAddress.ipAddress.address.GetIpv6Address();
1928 result.strRouter1 = staticIpAddress.gateway.GetIpv6Address();
1929 result.strSubnet = staticIpAddress.GetIpv6Mask();
1930 result.strDns1 = staticIpAddress.dnsServer1.GetIpv6Address();
1931 result.strDns2 = staticIpAddress.dnsServer2.GetIpv6Address();
1932 pDhcpResultNotify->OnSuccess(1, IF_NAME, result);
1933 break;
1934 }
1935
1936 default:
1937 WIFI_LOGE("Invalid currentTpType: %{public}d", currentTpType);
1938 return false;
1939 }
1940 return true;
1941 }
1942
HandleNetCheckResult(StaNetState netState,const std::string portalUrl)1943 void StaStateMachine::HandleNetCheckResult(StaNetState netState, const std::string portalUrl)
1944 {
1945 WIFI_LOGI("Enter HandleNetCheckResult, netState:%{public}d.", netState);
1946 if (linkedInfo.connState != ConnState::CONNECTED) {
1947 WIFI_LOGE("connState is NOT in connected state, connState:%{public}d\n", linkedInfo.connState);
1948 return;
1949 }
1950
1951 if (netState == StaNetState::NETWORK_STATE_WORKING) {
1952 WIFI_LOGI("HandleNetCheckResult network state is working\n");
1953 /* Save connection information to WifiSettings. */
1954 SaveLinkstate(ConnState::CONNECTED, DetailedState::WORKING);
1955 staCallback.OnStaConnChanged(OperateResState::CONNECT_NETWORK_ENABLED, linkedInfo);
1956 } else if (netState == StaNetState::NETWORK_CHECK_PORTAL) {
1957 linkedInfo.portalUrl = portalUrl;
1958 SaveLinkstate(ConnState::CONNECTED, DetailedState::CAPTIVE_PORTAL_CHECK);
1959 staCallback.OnStaConnChanged(OperateResState::CONNECT_CHECK_PORTAL, linkedInfo);
1960 } else {
1961 WIFI_LOGI("HandleNetCheckResult network state is notworking.\n");
1962 SaveLinkstate(ConnState::CONNECTED, DetailedState::NOTWORKING);
1963 staCallback.OnStaConnChanged(OperateResState::CONNECT_NETWORK_DISABLED, linkedInfo);
1964 }
1965 }
1966
1967 /* --------------------------- state machine Connected State ------------------------------ */
LinkedState(StaStateMachine * staStateMachine)1968 StaStateMachine::LinkedState::LinkedState(StaStateMachine *staStateMachine)
1969 : State("LinkedState"), pStaStateMachine(staStateMachine)
1970 {}
1971
~LinkedState()1972 StaStateMachine::LinkedState::~LinkedState()
1973 {}
1974
GoInState()1975 void StaStateMachine::LinkedState::GoInState()
1976 {
1977 WIFI_LOGI("LinkedState GoInState function.");
1978
1979 return;
1980 }
1981
GoOutState()1982 void StaStateMachine::LinkedState::GoOutState()
1983 {
1984 WIFI_LOGI("LinkedState GoOutState function.");
1985 }
1986
ExecuteStateMsg(InternalMessage * msg)1987 bool StaStateMachine::LinkedState::ExecuteStateMsg(InternalMessage *msg)
1988 {
1989 if (msg == nullptr) {
1990 WIFI_LOGI("msg is nullptr.");
1991 return false;
1992 }
1993
1994 WIFI_LOGI("LinkedState, reveived msgCode=%{public}d msg.\n", msg->GetMessageName());
1995 bool ret = NOT_EXECUTED;
1996 switch (msg->GetMessageName()) {
1997 case WIFI_SVR_CMD_STA_BSSID_CHANGED_EVENT: {
1998 ret = EXECUTED;
1999 std::string reason = msg->GetStringFromMessage();
2000 std::string bssid = msg->GetStringFromMessage();
2001 WIFI_LOGI("reveived bssid changed event, reason:%{public}s,bssid:%{public}s.\n",
2002 reason.c_str(), MacAnonymize(bssid).c_str());
2003 if (strcmp(reason.c_str(), "ASSOC_COMPLETE") != 0) {
2004 WIFI_LOGE("Bssid change not for ASSOC_COMPLETE, do nothing.");
2005 return false;
2006 }
2007 if (WifiStaHalInterface::GetInstance().SetBssid(pStaStateMachine->linkedInfo.networkId,
2008 bssid) != WIFI_IDL_OPT_OK) {
2009 WIFI_LOGE("SetBssid return fail.");
2010 return false;
2011 }
2012 pStaStateMachine->isRoam = true;
2013 /* The current state of StaStateMachine transfers to pApRoamingState. */
2014 pStaStateMachine->SwitchState(pStaStateMachine->pApRoamingState);
2015 break;
2016 }
2017 default:
2018 WIFI_LOGD("NOT handle this event!");
2019 break;
2020 }
2021
2022 return ret;
2023 }
2024
2025 /* --------------------------- state machine Roaming State ------------------------------ */
ApRoamingState(StaStateMachine * staStateMachine)2026 StaStateMachine::ApRoamingState::ApRoamingState(StaStateMachine *staStateMachine)
2027 : State("ApRoamingState"), pStaStateMachine(staStateMachine)
2028 {}
2029
~ApRoamingState()2030 StaStateMachine::ApRoamingState::~ApRoamingState()
2031 {}
2032
GoInState()2033 void StaStateMachine::ApRoamingState::GoInState()
2034 {
2035 WIFI_LOGI("ApRoamingState GoInState function.");
2036 }
2037
GoOutState()2038 void StaStateMachine::ApRoamingState::GoOutState()
2039 {
2040 WIFI_LOGI("ApRoamingState GoOutState function.");
2041 }
2042
ExecuteStateMsg(InternalMessage * msg)2043 bool StaStateMachine::ApRoamingState::ExecuteStateMsg(InternalMessage *msg)
2044 {
2045 if (msg == nullptr) {
2046 return false;
2047 }
2048
2049 WIFI_LOGI("ApRoamingState, reveived msgCode=%{public}d msg.", msg->GetMessageName());
2050 bool ret = NOT_EXECUTED;
2051 switch (msg->GetMessageName()) {
2052 case WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT: {
2053 WIFI_LOGI("ApRoamingState, receive WIFI_SVR_CMD_STA_NETWORK_CONNECTION_EVENT event.");
2054 ret = EXECUTED;
2055 pStaStateMachine->isRoam = true;
2056 pStaStateMachine->StopTimer(static_cast<int>(CMD_NETWORK_CONNECT_TIMEOUT));
2057 pStaStateMachine->ConnectToNetworkProcess(msg);
2058 /* Notify result to InterfaceService. */
2059 pStaStateMachine->staCallback.OnStaConnChanged(OperateResState::CONNECT_ASSOCIATED,
2060 pStaStateMachine->linkedInfo);
2061 pStaStateMachine->staCallback.OnStaConnChanged(OperateResState::CONNECT_OBTAINING_IP,
2062 pStaStateMachine->linkedInfo);
2063
2064 /* The current state of StaStateMachine transfers to GetIpState. */
2065 pStaStateMachine->SwitchState(pStaStateMachine->pGetIpState);
2066 break;
2067 }
2068 default:
2069 WIFI_LOGI("ApRoamingState-msgCode=%d not handled.", msg->GetMessageName());
2070 break;
2071 }
2072
2073 return ret;
2074 }
2075
ConnectToNetworkProcess(InternalMessage * msg)2076 void StaStateMachine::ConnectToNetworkProcess(InternalMessage *msg)
2077 {
2078 if (msg == nullptr) {
2079 return;
2080 }
2081
2082 lastNetworkId = msg->GetParam1();
2083 std::string bssid = msg->GetStringFromMessage();
2084 WIFI_LOGI("ConnectToNetworkProcess, Receive msg: lastNetworkId=%{public}d, bssid=%{public}s",
2085 lastNetworkId, MacAnonymize(bssid).c_str());
2086 WifiDeviceConfig deviceConfig;
2087 int result = WifiSettings::GetInstance().GetDeviceConfig(lastNetworkId, deviceConfig);
2088 WIFI_LOGD("Device config networkId = %{public}d", deviceConfig.networkId);
2089
2090 if (result == 0 && deviceConfig.bssid == bssid) {
2091 LOGI("Device Configuration already exists.");
2092 } else {
2093 deviceConfig.bssid = bssid;
2094 if ((wpsState == SetupMethod::DISPLAY) || (wpsState == SetupMethod::PBC) || (wpsState == SetupMethod::KEYPAD)) {
2095 /* Save connection information. */
2096 WifiIdlGetDeviceConfig config;
2097 config.networkId = lastNetworkId;
2098 config.param = "ssid";
2099 if (WifiStaHalInterface::GetInstance().GetDeviceConfig(config) != WIFI_IDL_OPT_OK) {
2100 LOGE("GetDeviceConfig failed!");
2101 }
2102
2103 deviceConfig.networkId = lastNetworkId;
2104 deviceConfig.bssid = bssid;
2105 deviceConfig.ssid = config.value;
2106 /* Remove the double quotation marks at the head and tail. */
2107 deviceConfig.ssid.erase(0, 1);
2108 deviceConfig.ssid.erase(deviceConfig.ssid.length() - 1, 1);
2109 WifiSettings::GetInstance().AddWpsDeviceConfig(deviceConfig);
2110 isWpsConnect = IsWpsConnected::WPS_CONNECTED;
2111 } else {
2112 WifiSettings::GetInstance().AddDeviceConfig(deviceConfig);
2113 }
2114 WifiSettings::GetInstance().SyncDeviceConfig();
2115 WIFI_LOGD("Device ssid = %s", SsidAnonymize(deviceConfig.ssid).c_str());
2116 }
2117
2118 std::string macAddr;
2119 WifiSettings::GetInstance().GetMacAddress(macAddr);
2120 linkedInfo.networkId = lastNetworkId;
2121 linkedInfo.bssid = bssid;
2122 linkedInfo.ssid = deviceConfig.ssid;
2123 linkedInfo.macAddress = macAddr;
2124 linkedInfo.ifHiddenSSID = deviceConfig.hiddenSSID;
2125 lastLinkedInfo.bssid = bssid;
2126 lastLinkedInfo.macAddress = deviceConfig.macAddress;
2127 lastLinkedInfo.ifHiddenSSID = deviceConfig.hiddenSSID;
2128 SetWifiLinkedInfo(lastNetworkId);
2129 SaveLinkstate(ConnState::CONNECTING, DetailedState::OBTAINING_IPADDR);
2130 }
2131
SetWifiLinkedInfo(int networkId)2132 void StaStateMachine::SetWifiLinkedInfo(int networkId)
2133 {
2134 WIFI_LOGI("SetWifiLinkedInfo, linkedInfo.networkId=%{public}d, lastLinkedInfo.networkId=%{public}d",
2135 linkedInfo.networkId, lastLinkedInfo.networkId);
2136 if (linkedInfo.networkId == INVALID_NETWORK_ID) {
2137 if (lastLinkedInfo.networkId != INVALID_NETWORK_ID) {
2138 /* Update connection information according to the last connecting information. */
2139 linkedInfo.retryedConnCount = 0;
2140 linkedInfo.networkId = lastLinkedInfo.networkId;
2141 linkedInfo.ssid = lastLinkedInfo.ssid;
2142 linkedInfo.bssid = lastLinkedInfo.bssid;
2143 linkedInfo.macAddress = lastLinkedInfo.macAddress;
2144 linkedInfo.rssi = lastLinkedInfo.rssi;
2145 linkedInfo.band = lastLinkedInfo.band;
2146 linkedInfo.frequency = lastLinkedInfo.frequency;
2147 linkedInfo.linkSpeed = lastLinkedInfo.linkSpeed;
2148 linkedInfo.ipAddress = lastLinkedInfo.ipAddress;
2149 linkedInfo.connState = lastLinkedInfo.connState;
2150 linkedInfo.ifHiddenSSID = lastLinkedInfo.ifHiddenSSID;
2151 linkedInfo.rxLinkSpeed = lastLinkedInfo.rxLinkSpeed;
2152 linkedInfo.txLinkSpeed = lastLinkedInfo.txLinkSpeed;
2153 linkedInfo.chload = lastLinkedInfo.chload;
2154 linkedInfo.snr = lastLinkedInfo.snr;
2155 linkedInfo.isDataRestricted = lastLinkedInfo.isDataRestricted;
2156 linkedInfo.portalUrl = lastLinkedInfo.portalUrl;
2157 linkedInfo.detailedState = lastLinkedInfo.detailedState;
2158 } else if (networkId != INVALID_NETWORK_ID) {
2159 linkedInfo.retryedConnCount = 0;
2160 linkedInfo.networkId = networkId;
2161 WifiDeviceConfig config;
2162 int ret = WifiSettings::GetInstance().GetDeviceConfig(networkId, config);
2163 if (ret == 0) {
2164 /* Update connection information according to configuration. */
2165 linkedInfo.networkId = config.networkId;
2166 linkedInfo.ssid = config.ssid;
2167 linkedInfo.bssid = config.bssid;
2168 linkedInfo.band = config.band;
2169 linkedInfo.connState = ConnState::CONNECTING;
2170 linkedInfo.ifHiddenSSID = config.hiddenSSID;
2171 linkedInfo.detailedState = DetailedState::OBTAINING_IPADDR;
2172
2173 lastLinkedInfo.networkId = config.networkId;
2174 lastLinkedInfo.ssid = config.ssid;
2175 lastLinkedInfo.bssid = config.bssid;
2176 lastLinkedInfo.band = config.band;
2177 lastLinkedInfo.connState = ConnState::CONNECTING;
2178 lastLinkedInfo.ifHiddenSSID = config.hiddenSSID;
2179 lastLinkedInfo.detailedState = DetailedState::OBTAINING_IPADDR;
2180 }
2181 }
2182 WriteWifiBandHiSysEvent(linkedInfo.band);
2183 }
2184 }
2185
DealNetworkCheck(InternalMessage * msg)2186 void StaStateMachine::DealNetworkCheck(InternalMessage *msg)
2187 {
2188 LOGD("enter DealNetworkCheck.\n");
2189 if (msg == nullptr) {
2190 LOGE("InternalMessage msg is null.");
2191 return;
2192 }
2193
2194 if (pNetcheck == nullptr) {
2195 LOGE("pNetcheck is null.");
2196 return;
2197 }
2198 pNetcheck->SignalNetCheckThread();
2199 }
2200
2201 /* ------------------ state machine dhcp callback function ----------------- */
2202
DhcpResultNotify(StaStateMachine * staStateMachine)2203 StaStateMachine::DhcpResultNotify::DhcpResultNotify(StaStateMachine *staStateMachine)
2204 {
2205 pStaStateMachine = staStateMachine;
2206 }
2207
~DhcpResultNotify()2208 StaStateMachine::DhcpResultNotify::~DhcpResultNotify()
2209 {}
2210
OnSuccess(int status,const std::string & ifname,DhcpResult & result)2211 void StaStateMachine::DhcpResultNotify::OnSuccess(int status, const std::string &ifname, DhcpResult &result)
2212 {
2213 LOGD("Enter Sta DhcpResultNotify::OnSuccess. ifname=[%{public}s] status=[%{public}d]\n",
2214 ifname.c_str(), status);
2215
2216 if ((pStaStateMachine->linkedInfo.detailedState == DetailedState::DISCONNECTING) ||
2217 (pStaStateMachine->linkedInfo.detailedState == DetailedState::DISCONNECTED)) {
2218 return;
2219 }
2220 WIFI_LOGD("iptype=%{public}d, ip=%{public}s, gateway=%{public}s, \
2221 subnet=%{public}s, serverAddress=%{public}s, leaseDuration=%{public}d.",
2222 result.iptype,
2223 IpAnonymize(result.strYourCli).c_str(),
2224 IpAnonymize(result.strRouter1).c_str(),
2225 IpAnonymize(result.strSubnet).c_str(),
2226 IpAnonymize(result.strServer).c_str(),
2227 result.uLeaseTime);
2228 WIFI_LOGD("strDns1=%{public}s, strDns2=%{public}s", IpAnonymize(result.strDns1).c_str(),
2229 IpAnonymize(result.strDns2).c_str());
2230
2231 IpInfo ipInfo;
2232 WifiSettings::GetInstance().GetIpInfo(ipInfo);
2233 IpV6Info ipv6Info;
2234 WifiSettings::GetInstance().GetIpv6Info(ipv6Info);
2235 TryToSaveIpV4Result(ipInfo, ipv6Info, result);
2236 TryToSaveIpV6Result(ipInfo, ipv6Info, result);
2237 TryToCloseDhcpClient(result.iptype);
2238 return;
2239 }
2240
TryToSaveIpV4Result(IpInfo & ipInfo,IpV6Info & ipv6Info,DhcpResult & result)2241 void StaStateMachine::DhcpResultNotify::TryToSaveIpV4Result(IpInfo &ipInfo, IpV6Info &ipv6Info, DhcpResult &result)
2242 {
2243 if (!((IpTools::ConvertIpv4Address(result.strYourCli) == ipInfo.ipAddress) &&
2244 (IpTools::ConvertIpv4Address(result.strRouter1) == ipInfo.gateway))) {
2245 if (result.iptype == 0) {
2246 ipInfo.ipAddress = IpTools::ConvertIpv4Address(result.strYourCli);
2247 ipInfo.gateway = IpTools::ConvertIpv4Address(result.strRouter1);
2248 ipInfo.netmask = IpTools::ConvertIpv4Address(result.strSubnet);
2249 ipInfo.primaryDns = IpTools::ConvertIpv4Address(result.strDns1);
2250 ipInfo.secondDns = IpTools::ConvertIpv4Address(result.strDns2);
2251 ipInfo.serverIp = IpTools::ConvertIpv4Address(result.strServer);
2252 ipInfo.leaseDuration = result.uLeaseTime;
2253 WifiSettings::GetInstance().SaveIpInfo(ipInfo);
2254 pStaStateMachine->linkedInfo.ipAddress = IpTools::ConvertIpv4Address(result.strYourCli);
2255 pStaStateMachine->linkedInfo.isDataRestricted =
2256 (result.strVendor.find("ANDROID_METERED") == std::string::npos) ? 0 : 1;
2257 WifiSettings::GetInstance().SaveLinkedInfo(pStaStateMachine->linkedInfo);
2258 #ifndef OHOS_ARCH_LITE
2259 WIFI_LOGD("Update NetLink info, strYourCli=%{public}s, strSubnet=%{public}s, \
2260 strRouter1=%{public}s, strDns1=%{public}s, strDns2=%{public}s",
2261 IpAnonymize(result.strYourCli).c_str(), IpAnonymize(result.strSubnet).c_str(),
2262 IpAnonymize(result.strRouter1).c_str(), IpAnonymize(result.strDns1).c_str(),
2263 IpAnonymize(result.strDns2).c_str());
2264 WIFI_LOGI("On dhcp success update net linke info");
2265 WifiDeviceConfig config;
2266 WifiSettings::GetInstance().GetDeviceConfig(pStaStateMachine->linkedInfo.networkId, config);
2267 WifiNetAgent::GetInstance().OnStaMachineUpdateNetLinkInfo(ipInfo, ipv6Info, config.wifiProxyconfig);
2268 #endif
2269 }
2270 #ifdef OHOS_ARCH_LITE
2271 IfConfig::GetInstance().SetIfDnsAndRoute(result, result.iptype);
2272 #endif
2273 }
2274 }
2275
TryToSaveIpV6Result(IpInfo & ipInfo,IpV6Info & ipv6Info,DhcpResult & result)2276 void StaStateMachine::DhcpResultNotify::TryToSaveIpV6Result(IpInfo &ipInfo, IpV6Info &ipv6Info, DhcpResult &result)
2277 {
2278 if (result.iptype == 1 &&
2279 (ipv6Info.globalIpV6Address != result.strYourCli || ipv6Info.gateway != result.strRouter1)) {
2280 ipv6Info.linkIpV6Address = "";
2281 ipv6Info.globalIpV6Address = result.strYourCli;
2282 ipv6Info.randGlobalIpV6Address = "";
2283 ipv6Info.gateway = result.strRouter1;
2284 ipv6Info.netmask = result.strSubnet;
2285 ipv6Info.primaryDns = result.strDns1;
2286 ipv6Info.secondDns = result.strDns2;
2287 WifiSettings::GetInstance().SaveIpV6Info(ipv6Info);
2288 WIFI_LOGI("V6Info::addr=%{private}s, gateway=%{private}s, mask=%{private}s, dns=%{private}s, dns2=%{private}s",
2289 ipv6Info.globalIpV6Address.c_str(), ipv6Info.gateway.c_str(), ipv6Info.netmask.c_str(),
2290 ipv6Info.primaryDns.c_str(), ipv6Info.secondDns.c_str());
2291 #ifndef OHOS_ARCH_LITE
2292 WifiDeviceConfig config;
2293 WifiSettings::GetInstance().GetDeviceConfig(pStaStateMachine->linkedInfo.networkId, config);
2294 WifiNetAgent::GetInstance().OnStaMachineUpdateNetLinkInfo(ipInfo, ipv6Info, config.wifiProxyconfig);
2295 #endif
2296 }
2297 }
2298
TryToCloseDhcpClient(int iptype)2299 void StaStateMachine::DhcpResultNotify::TryToCloseDhcpClient(int iptype)
2300 {
2301 if (iptype == 1) {
2302 return;
2303 }
2304 WIFI_LOGI("DhcpResultNotify::OnSuccess, getIpSucNum=%{public}d, isRoam=%{public}d",
2305 pStaStateMachine->getIpSucNum, pStaStateMachine->isRoam);
2306 pStaStateMachine->OnDhcpResultNotifyEvent(true);
2307 if (pStaStateMachine->getIpSucNum == 0 || pStaStateMachine->isRoam) {
2308 pStaStateMachine->SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT);
2309 pStaStateMachine->SaveLinkstate(ConnState::CONNECTED, DetailedState::CONNECTED);
2310 pStaStateMachine->staCallback.OnStaConnChanged(
2311 OperateResState::CONNECT_AP_CONNECTED, pStaStateMachine->linkedInfo);
2312 WriteWifiConnectionHiSysEvent(WifiConnectionType::CONNECT, "");
2313 /* Delay to wait for the network adapter information to take effect. */
2314 constexpr int NETCHECK_DELAY_TIME = 2000; // 2000 ms
2315 pStaStateMachine->StartTimer(static_cast<int>(CMD_START_NETCHECK), NETCHECK_DELAY_TIME);
2316 pStaStateMachine->DealSetStaConnectFailedCount(0, true);
2317 }
2318 pStaStateMachine->getIpSucNum++;
2319
2320 WIFI_LOGI("DhcpResultNotify::OnSuccess, stop dhcp client");
2321 if (pStaStateMachine->pDhcpService != nullptr) {
2322 if (pStaStateMachine->currentTpType == IPTYPE_IPV6) {
2323 pStaStateMachine->pDhcpService->StopDhcpClient(IF_NAME, true);
2324 } else {
2325 pStaStateMachine->pDhcpService->StopDhcpClient(IF_NAME, false);
2326 }
2327 }
2328 }
2329
OnFailed(int status,const std::string & ifname,const std::string & reason)2330 void StaStateMachine::DhcpResultNotify::OnFailed(int status, const std::string &ifname, const std::string &reason)
2331 {
2332 LOGI("Enter DhcpResultNotify::OnFailed. ifname=[%s] status=[%d], reason = [%s], detailedState = [%d]\n",
2333 ifname.c_str(), status, reason.c_str(), static_cast<int>(pStaStateMachine->linkedInfo.detailedState));
2334 if ((pStaStateMachine->linkedInfo.detailedState == DetailedState::DISCONNECTING) ||
2335 (pStaStateMachine->linkedInfo.detailedState == DetailedState::DISCONNECTED)) {
2336 return;
2337 }
2338
2339 LOGI("currentTpType: %{public}d, getIpSucNum: %{public}d, getIpFailNum: %{public}d, isRoam: %{public}d",
2340 pStaStateMachine->currentTpType, pStaStateMachine->getIpSucNum,
2341 pStaStateMachine->getIpFailNum, pStaStateMachine->isRoam);
2342
2343 if (pStaStateMachine->getIpFailNum == 0) {
2344 pStaStateMachine->staCallback.OnStaConnChanged(OperateResState::CONNECT_OBTAINING_IP_FAILED,
2345 pStaStateMachine->linkedInfo);
2346 pStaStateMachine->DisConnectProcess();
2347 pStaStateMachine->SaveLinkstate(ConnState::DISCONNECTED, DetailedState::OBTAINING_IPADDR_FAIL);
2348 pStaStateMachine->staCallback.OnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED,
2349 pStaStateMachine->linkedInfo);
2350 WriteWifiConnectionHiSysEvent(WifiConnectionType::DISCONNECT, "");
2351 }
2352 pStaStateMachine->getIpFailNum++;
2353 }
2354
OnSerExitNotify(const std::string & ifname)2355 void StaStateMachine::DhcpResultNotify::OnSerExitNotify(const std::string &ifname)
2356 {
2357 LOGI("Enter DhcpResultNotify::OnSerExitNotify. ifname = [%s]\n", ifname.c_str());
2358 }
2359
2360 /* ------------------ state machine Comment function ----------------- */
SaveDiscReason(DisconnectedReason discReason)2361 void StaStateMachine::SaveDiscReason(DisconnectedReason discReason)
2362 {
2363 WifiSettings::GetInstance().SaveDisconnectedReason(discReason);
2364 }
2365
SaveLinkstate(ConnState state,DetailedState detailState)2366 void StaStateMachine::SaveLinkstate(ConnState state, DetailedState detailState)
2367 {
2368 linkedInfo.connState = state;
2369 linkedInfo.detailedState = detailState;
2370 lastLinkedInfo.connState = state;
2371 lastLinkedInfo.detailedState = detailState;
2372 WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
2373 }
2374
GetLinkedInfo(WifiLinkedInfo & linkedInfo)2375 int StaStateMachine::GetLinkedInfo(WifiLinkedInfo& linkedInfo)
2376 {
2377 return WifiSettings::GetInstance().GetLinkedInfo(linkedInfo);
2378 }
2379
DisableNetwork(int networkId)2380 ErrCode StaStateMachine::DisableNetwork(int networkId)
2381 {
2382 if (WifiStaHalInterface::GetInstance().DisableNetwork(networkId) != WIFI_IDL_OPT_OK) {
2383 LOGE("DisableNetwork() failed, networkId=%d.", networkId);
2384 return WIFI_OPT_FAILED;
2385 }
2386
2387 if (WifiStaHalInterface::GetInstance().SaveDeviceConfig() != WIFI_IDL_OPT_OK) {
2388 LOGE("DisableNetwork-SaveDeviceConfig() failed!");
2389 return WIFI_OPT_FAILED;
2390 }
2391 LOGI("DisableNetwork-SaveDeviceConfig() succeed!");
2392 return WIFI_OPT_SUCCESS;
2393 }
2394
SetOperationalMode(int mode)2395 void StaStateMachine::SetOperationalMode(int mode)
2396 {
2397 SendMessage(WIFI_SVR_CMD_STA_OPERATIONAL_MODE, mode, 0);
2398 }
2399
2400 #ifndef OHOS_ARCH_LITE
OnNetManagerRestart(void)2401 void StaStateMachine::OnNetManagerRestart(void)
2402 {
2403 LOGI("OnNetManagerRestart()");
2404 int state = WifiSettings::GetInstance().GetWifiState();
2405 if (state != static_cast<int>(WifiState::ENABLED)) {
2406 return;
2407 }
2408 WifiNetAgent::GetInstance().OnStaMachineNetManagerRestart(NetSupplierInfo);
2409 }
2410
ReUpdateNetSupplierInfo(sptr<NetManagerStandard::NetSupplierInfo> supplierInfo)2411 void StaStateMachine::ReUpdateNetSupplierInfo(sptr<NetManagerStandard::NetSupplierInfo> supplierInfo)
2412 {
2413 LOGI("ReUpdateNetSupplierInfo()");
2414 WifiLinkedInfo linkedInfo;
2415 WifiSettings::GetInstance().GetLinkedInfo(linkedInfo);
2416 if ((linkedInfo.detailedState == DetailedState::NOTWORKING) && (linkedInfo.connState == ConnState::CONNECTED)) {
2417 if (supplierInfo != nullptr) {
2418 TimeStats timeStats("Call UpdateNetSupplierInfo");
2419 WifiNetAgent::GetInstance().UpdateNetSupplierInfo(supplierInfo);
2420 }
2421 }
2422 }
2423
ReUpdateNetLinkInfo(const WifiDeviceConfig & config)2424 void StaStateMachine::ReUpdateNetLinkInfo(const WifiDeviceConfig &config)
2425 {
2426 WifiLinkedInfo linkedInfo;
2427 WifiSettings::GetInstance().GetLinkedInfo(linkedInfo);
2428 LOGI("ReUpdateNetLinkInfo, detailedState:%{public}d, connState:%{public}d",
2429 linkedInfo.detailedState, linkedInfo.connState);
2430 if ((linkedInfo.detailedState == DetailedState::NOTWORKING) && (linkedInfo.connState == ConnState::CONNECTED)
2431 && (linkedInfo.ssid == config.ssid) && (linkedInfo.bssid == config.bssid)) {
2432 IpInfo wifiIpInfo;
2433 WifiSettings::GetInstance().GetIpInfo(wifiIpInfo);
2434 IpV6Info wifiIpV6Info;
2435 WifiSettings::GetInstance().GetIpv6Info(wifiIpV6Info);
2436 WifiDeviceConfig config;
2437 WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, config);
2438 WifiNetAgent::GetInstance().UpdateNetLinkInfo(wifiIpInfo, wifiIpV6Info, config.wifiProxyconfig);
2439 }
2440 }
2441
SaveWifiConfigForUpdate(int networkId)2442 void StaStateMachine::SaveWifiConfigForUpdate(int networkId)
2443 {
2444 WIFI_LOGI("Enter SaveWifiConfigForUpdate.");
2445 WifiDeviceConfig config;
2446 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config) == -1) {
2447 WIFI_LOGE("SaveWifiConfigForUpdate, get current config failed.");
2448 return;
2449 }
2450 }
2451 #endif // OHOS_ARCH_LITE
2452 } // namespace Wifi
2453 } // namespace OHOS
2454