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