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 "kits/c/wifi_device.h"
17 #include "inner_api/wifi_device.h"
18 #include "inner_api/wifi_scan.h"
19 #include "kits/c/wifi_scan_info.h"
20 #include "kits/c/wifi_device_config.h"
21 #include "wifi_logger.h"
22 #include "wifi_c_utils.h"
23 #include "wifi_common_util.h"
24 #include "inner_api/wifi_msg.h"
25 
26 DEFINE_WIFILOG_LABEL("WifiCDevice");
27 
28 static std::map<WifiSecurityType, std::string> g_secTypeKeyMgmtMap = {
29     {WIFI_SEC_TYPE_OPEN, "NONE"},
30     {WIFI_SEC_TYPE_WEP, "WEP"},
31     {WIFI_SEC_TYPE_PSK, "WPA-PSK"},
32     {WIFI_SEC_TYPE_SAE, "SAE"},
33 };
34 
35 std::shared_ptr<OHOS::Wifi::WifiDevice> wifiDevicePtr = OHOS::Wifi::WifiDevice::GetInstance(WIFI_DEVICE_ABILITY_ID);
36 std::shared_ptr<OHOS::Wifi::WifiScan> wifiScanPtr = OHOS::Wifi::WifiScan::GetInstance(WIFI_SCAN_ABILITY_ID);
37 
EnableWifi()38 NO_SANITIZE("cfi") WifiErrorCode EnableWifi()
39 {
40     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
41     return GetCErrorCode(wifiDevicePtr->EnableWifi());
42 }
43 
DisableWifi()44 NO_SANITIZE("cfi") WifiErrorCode DisableWifi()
45 {
46     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
47     return GetCErrorCode(wifiDevicePtr->DisableWifi());
48 }
49 
IsWifiActive()50 NO_SANITIZE("cfi") int IsWifiActive()
51 {
52     if (wifiDevicePtr == nullptr) {
53         return false;
54     }
55 
56     bool isActive = false;
57     OHOS::Wifi::ErrCode ret = wifiDevicePtr->IsWifiActive(isActive);
58     return (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) && isActive;
59 }
60 
IsMeteredHotspot()61 NO_SANITIZE("cfi") int IsMeteredHotspot()
62 {
63     if (wifiDevicePtr == nullptr) {
64         return false;
65     }
66 
67     bool isMeteredHotspot = false;
68     OHOS::Wifi::ErrCode ret = wifiDevicePtr->IsMeteredHotspot(isMeteredHotspot);
69     return (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) && isMeteredHotspot;
70 }
71 
Scan()72 NO_SANITIZE("cfi") WifiErrorCode Scan()
73 {
74     CHECK_PTR_RETURN(wifiScanPtr, ERROR_WIFI_NOT_AVAILABLE);
75     return GetCErrorCode(wifiScanPtr->Scan(true));
76 }
77 
GetScanInfoList(WifiScanInfo * result,unsigned int * size)78 NO_SANITIZE("cfi") WifiErrorCode GetScanInfoList(WifiScanInfo *result, unsigned int *size)
79 {
80     CHECK_PTR_RETURN(wifiScanPtr, ERROR_WIFI_NOT_AVAILABLE);
81     if (result == nullptr || size == nullptr) {
82         WIFI_LOGE("Scan info input parameter is nullptr!");
83         return ERROR_WIFI_UNKNOWN;
84     }
85 
86     std::vector<OHOS::Wifi::WifiScanInfo> vecScanInfos;
87     OHOS::Wifi::ErrCode ret = wifiScanPtr->GetScanInfoList(vecScanInfos, true);
88     int vecSize = (int)vecScanInfos.size();
89     for (int i = 0; i < vecSize && i < WIFI_SCAN_HOTSPOT_LIMIT; ++i) {
90         if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN,
91             vecScanInfos[i].ssid.c_str(), vecScanInfos[i].ssid.size() + 1) != EOK) {
92             return ERROR_WIFI_UNKNOWN;
93         }
94         if (OHOS::Wifi::MacStrToArray(vecScanInfos[i].bssid, result->bssid) != EOK) {
95             WIFI_LOGE("Scan info convert bssid error!");
96             return ERROR_WIFI_UNKNOWN;
97         }
98         result->bssidType = vecScanInfos[i].bssidType;
99         result->securityType = static_cast<int>(vecScanInfos[i].securityType);
100         result->rssi = vecScanInfos[i].rssi;
101         result->band = vecScanInfos[i].band;
102         result->frequency = vecScanInfos[i].frequency;
103         result->channelWidth = WifiChannelWidth(static_cast<int>(vecScanInfos[i].channelWidth));
104         result->centerFrequency0 = vecScanInfos[i].centerFrequency0;
105         result->centerFrequency1 = vecScanInfos[i].centerFrequency1;
106         result->timestamp = vecScanInfos[i].timestamp;
107         ++result;
108     }
109     *size = static_cast<size_t>((vecSize < WIFI_SCAN_HOTSPOT_LIMIT) ? vecSize : WIFI_SCAN_HOTSPOT_LIMIT);
110     return GetCErrorCode(ret);
111 }
112 
GetKeyMgmtBySecType(const int securityType)113 static std::string GetKeyMgmtBySecType(const int securityType)
114 {
115     WifiSecurityType key = WifiSecurityType(securityType);
116     std::map<WifiSecurityType, std::string>::const_iterator iter = g_secTypeKeyMgmtMap.find(key);
117     return iter == g_secTypeKeyMgmtMap.end() ? "NONE" : iter->second;
118 }
119 
GetSecTypeByKeyMgmt(const std::string & keyMgmt)120 static int GetSecTypeByKeyMgmt(const std::string& keyMgmt)
121 {
122     for (auto& each : g_secTypeKeyMgmtMap) {
123         if (each.second == keyMgmt) {
124             return static_cast<int>(each.first);
125         }
126     }
127     return static_cast<int>(WIFI_SEC_TYPE_OPEN);
128 }
129 
GetStaticIpFromC(const IpConfig & ipConfig,OHOS::Wifi::StaticIpAddress & staticIp)130 static void GetStaticIpFromC(const IpConfig& ipConfig, OHOS::Wifi::StaticIpAddress& staticIp)
131 {
132     /* Just IPV4 now */
133     staticIp.ipAddress.address.addressIpv4 = ipConfig.ipAddress;
134     staticIp.gateway.addressIpv4 = ipConfig.gateway;
135     if (WIFI_MAX_DNS_NUM > 0) {
136         staticIp.dnsServer1.addressIpv4 = ipConfig.dnsServers[0];
137     }
138     /* Has backup DNS server */
139     if (WIFI_MAX_DNS_NUM > 1) {
140         staticIp.dnsServer2.addressIpv4 = ipConfig.dnsServers[1];
141     }
142     /* netmask: automatic calculate netmask, don't support customized set this value currently */
143 }
144 
GetStaticIpFromCpp(const OHOS::Wifi::StaticIpAddress & staticIp,IpConfig & ipConfig)145 static void GetStaticIpFromCpp(const OHOS::Wifi::StaticIpAddress& staticIp, IpConfig& ipConfig)
146 {
147     /* Just IPV4 now */
148     ipConfig.ipAddress = staticIp.ipAddress.address.addressIpv4;
149     ipConfig.gateway = staticIp.gateway.addressIpv4;
150     if (WIFI_MAX_DNS_NUM > 0) {
151         ipConfig.dnsServers[0] = staticIp.dnsServer1.addressIpv4;
152     }
153     /* Has backup DNS server */
154     if (WIFI_MAX_DNS_NUM > 1) {
155         ipConfig.dnsServers[1] = staticIp.dnsServer2.addressIpv4;
156     }
157     /* netmask: not support now */
158 }
159 
ConvertDeviceConfigFromC(const WifiDeviceConfig * config,OHOS::Wifi::WifiDeviceConfig & deviceConfig)160 static OHOS::Wifi::ErrCode ConvertDeviceConfigFromC(
161     const WifiDeviceConfig *config, OHOS::Wifi::WifiDeviceConfig& deviceConfig)
162 {
163     CHECK_PTR_RETURN(config, OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
164     if (strnlen(config->ssid, WIFI_MAX_SSID_LEN) == WIFI_MAX_SSID_LEN) {
165         return OHOS::Wifi::WIFI_OPT_INVALID_PARAM;
166     }
167     deviceConfig.ssid = config->ssid;
168     if (OHOS::Wifi::IsMacArrayEmpty(config->bssid)) {
169         deviceConfig.bssid = "";
170     } else {
171         deviceConfig.bssid = OHOS::Wifi::MacArrayToStr(config->bssid);
172     }
173     deviceConfig.bssidType = config->bssidType;
174     if (strnlen(config->preSharedKey, WIFI_MAX_KEY_LEN) == WIFI_MAX_KEY_LEN) {
175         return OHOS::Wifi::WIFI_OPT_INVALID_PARAM;
176     }
177     deviceConfig.preSharedKey = config->preSharedKey;
178     deviceConfig.keyMgmt = GetKeyMgmtBySecType(config->securityType);
179     deviceConfig.networkId = config->netId;
180     deviceConfig.frequency = config->freq;
181     deviceConfig.wifiPrivacySetting = OHOS::Wifi::WifiPrivacyConfig(config->randomMacType);
182     /* wapiPskType is not support, don't verify now */
183     if (config->ipType == DHCP) {
184         deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::DHCP;
185     } else if (config->ipType == STATIC_IP) {
186         deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::STATIC;
187         GetStaticIpFromC(config->staticIp, deviceConfig.wifiIpConfig.staticIpAddress);
188     } else {
189         deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::UNASSIGNED;
190     }
191     deviceConfig.hiddenSSID = config->isHiddenSsid;
192     return OHOS::Wifi::WIFI_OPT_SUCCESS;
193 }
194 
ConvertDeviceConfigFromCpp(const OHOS::Wifi::WifiDeviceConfig & deviceConfig,WifiDeviceConfig * result)195 static OHOS::Wifi::ErrCode ConvertDeviceConfigFromCpp(const OHOS::Wifi::WifiDeviceConfig& deviceConfig,
196     WifiDeviceConfig *result)
197 {
198     CHECK_PTR_RETURN(result, OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
199     if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN, deviceConfig.ssid.c_str(), deviceConfig.ssid.size() + 1) != EOK) {
200         return OHOS::Wifi::WIFI_OPT_FAILED;
201     }
202     if (OHOS::Wifi::MacStrToArray(deviceConfig.bssid, result->bssid) != EOK) {
203         WIFI_LOGE("device config convert bssid error!");
204         return OHOS::Wifi::WIFI_OPT_FAILED;
205     }
206     result->bssidType = deviceConfig.bssidType;
207     if (memcpy_s(result->preSharedKey, WIFI_MAX_KEY_LEN, deviceConfig.preSharedKey.c_str(), WIFI_MAX_KEY_LEN) != EOK) {
208         return OHOS::Wifi::WIFI_OPT_FAILED;
209     }
210     result->securityType = GetSecTypeByKeyMgmt(deviceConfig.keyMgmt);
211     result->netId = deviceConfig.networkId;
212     result->freq = deviceConfig.frequency;
213     result->randomMacType = static_cast<int>(deviceConfig.wifiPrivacySetting);
214     /* wapiPskType is not support now */
215     if (deviceConfig.wifiIpConfig.assignMethod == OHOS::Wifi::AssignIpMethod::DHCP) {
216         result->ipType = DHCP;
217     } else if (deviceConfig.wifiIpConfig.assignMethod == OHOS::Wifi::AssignIpMethod::STATIC) {
218         result->ipType = STATIC_IP;
219         GetStaticIpFromCpp(deviceConfig.wifiIpConfig.staticIpAddress, result->staticIp);
220     } else {
221         result->ipType = UNKNOWN;
222     }
223     result->isHiddenSsid = deviceConfig.hiddenSSID;
224     return OHOS::Wifi::WIFI_OPT_SUCCESS;
225 }
226 
ConvertScanParamsFromC(const WifiScanParams * params,OHOS::Wifi::WifiScanParams & scanParams)227 static void ConvertScanParamsFromC(const WifiScanParams *params, OHOS::Wifi::WifiScanParams& scanParams)
228 {
229     CHECK_PTR_RETURN_VOID(params);
230     scanParams.ssid = params->ssid;
231     if (OHOS::Wifi::IsMacArrayEmpty(params->bssid)) {
232         scanParams.bssid = "";
233     } else {
234         scanParams.bssid = OHOS::Wifi::MacArrayToStr(params->bssid);
235     }
236     scanParams.freqs.push_back(params->freqs);
237     scanParams.band = params->band;
238 }
239 
AddDeviceConfig(const WifiDeviceConfig * config,int * result)240 NO_SANITIZE("cfi") WifiErrorCode AddDeviceConfig(const WifiDeviceConfig *config, int *result)
241 {
242     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
243     CHECK_PTR_RETURN(config, ERROR_WIFI_INVALID_ARGS);
244     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
245     OHOS::Wifi::WifiDeviceConfig deviceConfig;
246     OHOS::Wifi::ErrCode ret = ConvertDeviceConfigFromC(config, deviceConfig);
247     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
248         WIFI_LOGE("AddDeviceConfig get device configs from c error!");
249         return GetCErrorCode(ret);
250     }
251     int addResult = -1;
252     bool isCandidate = false;
253     ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, addResult, isCandidate);
254     *result = addResult;
255     return GetCErrorCode(ret);
256 }
257 
GetDeviceConfigs(WifiDeviceConfig * result,unsigned int * size)258 NO_SANITIZE("cfi") WifiErrorCode GetDeviceConfigs(WifiDeviceConfig *result, unsigned int *size)
259 {
260     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
261     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
262     CHECK_PTR_RETURN(size, ERROR_WIFI_INVALID_ARGS);
263     std::vector<OHOS::Wifi::WifiDeviceConfig> vecDeviceConfigs;
264     bool isCandidate = false;
265     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetDeviceConfigs(vecDeviceConfigs, isCandidate);
266     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
267         WIFI_LOGE("Get device configs error!");
268         return GetCErrorCode(ret);
269     }
270     *size = (int)vecDeviceConfigs.size();
271     for (auto& each : vecDeviceConfigs) {
272         OHOS::Wifi::ErrCode retValue = ConvertDeviceConfigFromCpp(each, result++);
273         if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
274             ret = retValue;
275             WIFI_LOGE("Convert device configs error!");
276         }
277     }
278     return GetCErrorCode(ret);
279 }
280 
RemoveDevice(int networkId)281 NO_SANITIZE("cfi") WifiErrorCode RemoveDevice(int networkId)
282 {
283     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
284     return GetCErrorCode(wifiDevicePtr->RemoveDevice(networkId));
285 }
286 
DisableDeviceConfig(int networkId)287 WifiErrorCode DisableDeviceConfig(int networkId)
288 {
289     return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
290 }
291 
EnableDeviceConfig(int networkId)292 WifiErrorCode EnableDeviceConfig(int networkId)
293 {
294     return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
295 }
296 
ConnectTo(int networkId)297 NO_SANITIZE("cfi") WifiErrorCode ConnectTo(int networkId)
298 {
299     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
300     bool isCandidate = false;
301     return GetCErrorCode(wifiDevicePtr->ConnectToNetwork(networkId, isCandidate));
302 }
303 
ConnectToDevice(const WifiDeviceConfig * config)304 NO_SANITIZE("cfi") WifiErrorCode ConnectToDevice(const WifiDeviceConfig *config)
305 {
306     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
307     CHECK_PTR_RETURN(config, ERROR_WIFI_INVALID_ARGS);
308     OHOS::Wifi::WifiDeviceConfig deviceConfig;
309     OHOS::Wifi::ErrCode ret = ConvertDeviceConfigFromC(config, deviceConfig);
310     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
311         WIFI_LOGE("ConnectToDevice get device configs from c error!");
312         return GetCErrorCode(ret);
313     }
314     return GetCErrorCode(wifiDevicePtr->ConnectToDevice(deviceConfig));
315 }
316 
Disconnect()317 NO_SANITIZE("cfi") WifiErrorCode Disconnect()
318 {
319     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
320     return GetCErrorCode(wifiDevicePtr->Disconnect());
321 }
322 
GetLinkedInfoFromCpp(const OHOS::Wifi::WifiLinkedInfo & linkedInfo,WifiLinkedInfo * result)323 static OHOS::Wifi::ErrCode GetLinkedInfoFromCpp(const OHOS::Wifi::WifiLinkedInfo& linkedInfo, WifiLinkedInfo *result)
324 {
325     CHECK_PTR_RETURN(result, OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
326     if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN, linkedInfo.ssid.c_str(), linkedInfo.ssid.size() + 1) != EOK) {
327         return OHOS::Wifi::WIFI_OPT_FAILED;
328     }
329     if (OHOS::Wifi::MacStrToArray(linkedInfo.bssid, result->bssid) != EOK) {
330         WIFI_LOGE("linked info convert bssid error!");
331         return OHOS::Wifi::WIFI_OPT_FAILED;
332     }
333     result->rssi = linkedInfo.rssi;
334     result->band = linkedInfo.band;
335     result->frequency = linkedInfo.frequency;
336     result->connState = linkedInfo.connState == OHOS::Wifi::ConnState::CONNECTED ? WIFI_CONNECTED : WIFI_DISCONNECTED;
337     /* disconnectedReason not support */
338     result->ipAddress = linkedInfo.ipAddress;
339     result->wifiStandard = linkedInfo.wifiStandard;
340     result->maxSupportedRxLinkSpeed = linkedInfo.maxSupportedRxLinkSpeed;
341     result->maxSupportedTxLinkSpeed = linkedInfo.maxSupportedTxLinkSpeed;
342     result->rxLinkSpeed = linkedInfo.rxLinkSpeed;
343     result->txLinkSpeed = linkedInfo.txLinkSpeed;
344     return OHOS::Wifi::WIFI_OPT_SUCCESS;
345 }
346 
GetLinkedInfo(WifiLinkedInfo * result)347 NO_SANITIZE("cfi") WifiErrorCode GetLinkedInfo(WifiLinkedInfo *result)
348 {
349     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
350     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
351     OHOS::Wifi::WifiLinkedInfo linkedInfo;
352     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetLinkedInfo(linkedInfo);
353     if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
354         OHOS::Wifi::ErrCode retValue = GetLinkedInfoFromCpp(linkedInfo, result);
355         if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
356             WIFI_LOGE("Get linked info from cpp error!");
357             ret = retValue;
358         }
359     }
360     return GetCErrorCode(ret);
361 }
362 
GetDisconnectedReason(DisconnectedReason * result)363 NO_SANITIZE("cfi") WifiErrorCode GetDisconnectedReason(DisconnectedReason *result)
364 {
365     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
366     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
367     OHOS::Wifi::DisconnectedReason reason;
368     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetDisconnectedReason(reason);
369     if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
370         *result = (DisconnectedReason)reason;
371     } else {
372         WIFI_LOGE("GetDisconnectedReason failed:%{public}d", ret);
373     }
374     return GetCErrorCode(ret);
375 }
376 
GetDeviceMacAddress(unsigned char * result)377 NO_SANITIZE("cfi") WifiErrorCode GetDeviceMacAddress(unsigned char *result)
378 {
379     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
380     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
381     std::string mac;
382     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetDeviceMacAddress(mac);
383     if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
384         if (OHOS::Wifi::MacStrToArray(mac, result) != EOK) {
385             WIFI_LOGE("get mac convert to array error!");
386             return ERROR_WIFI_UNKNOWN;
387         }
388     }
389     return GetCErrorCode(ret);
390 }
391 
AdvanceScan(WifiScanParams * params)392 NO_SANITIZE("cfi") WifiErrorCode AdvanceScan(WifiScanParams *params)
393 {
394     CHECK_PTR_RETURN(wifiScanPtr, ERROR_WIFI_NOT_AVAILABLE);
395     CHECK_PTR_RETURN(params, ERROR_WIFI_INVALID_ARGS);
396     OHOS::Wifi::WifiScanParams scanParams;
397     ConvertScanParamsFromC(params, scanParams);
398     OHOS::Wifi::ErrCode ret = wifiScanPtr->AdvanceScan(scanParams);
399     return GetCErrorCode(ret);
400 }
401 
GetIpInfoFromCpp(const OHOS::Wifi::IpInfo & ipInfo,IpInfo * info)402 static OHOS::Wifi::ErrCode GetIpInfoFromCpp(const OHOS::Wifi::IpInfo& ipInfo, IpInfo *info)
403 {
404     CHECK_PTR_RETURN(info, OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
405     info->netGate = ipInfo.gateway;
406     info->ipAddress = ipInfo.ipAddress;
407     info->netMask = ipInfo.netmask;
408     info->dns1 = ipInfo.primaryDns;
409     info->dns2 = ipInfo.secondDns;
410     info->serverAddress = ipInfo.serverIp;
411     info->leaseDuration = ipInfo.leaseDuration;
412     return OHOS::Wifi::WIFI_OPT_SUCCESS;
413 }
414 
GetIpInfo(IpInfo * info)415 NO_SANITIZE("cfi") WifiErrorCode GetIpInfo(IpInfo *info)
416 {
417     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
418     CHECK_PTR_RETURN(info, ERROR_WIFI_INVALID_ARGS);
419     OHOS::Wifi::IpInfo ipInfo;
420     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetIpInfo(ipInfo);
421     if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
422         OHOS::Wifi::ErrCode retValue = GetIpInfoFromCpp(ipInfo, info);
423         if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
424             WIFI_LOGE("Get ip info from cpp error!");
425             ret = retValue;
426         }
427     }
428     return GetCErrorCode(ret);
429 }
430 
GetIpV6InfoFromCpp(const OHOS::Wifi::IpV6Info & ipInfo,IpV6Info * result)431 static OHOS::Wifi::ErrCode GetIpV6InfoFromCpp(const OHOS::Wifi::IpV6Info& ipInfo, IpV6Info *result)
432 {
433     CHECK_PTR_RETURN(result, OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
434     if (memcpy_s(result->linkIpV6Address, DEVICE_IPV6_MAX_LEN, ipInfo.linkIpV6Address.c_str(),
435         ipInfo.linkIpV6Address.size() + 1) != EOK) {
436         return OHOS::Wifi::WIFI_OPT_FAILED;
437     }
438     if (memcpy_s(result->globalIpV6Address, DEVICE_IPV6_MAX_LEN, ipInfo.globalIpV6Address.c_str(),
439         ipInfo.globalIpV6Address.size() + 1) != EOK) {
440         return OHOS::Wifi::WIFI_OPT_FAILED;
441     }
442     if (memcpy_s(result->randGlobalIpV6Address, DEVICE_IPV6_MAX_LEN, ipInfo.randGlobalIpV6Address.c_str(),
443         ipInfo.randGlobalIpV6Address.size() + 1) != EOK) {
444         return OHOS::Wifi::WIFI_OPT_FAILED;
445     }
446     if (memcpy_s(result->uniqueIpv6Address, DEVICE_IPV6_MAX_LEN, ipInfo.uniqueLocalAddress1.c_str(),
447         ipInfo.uniqueLocalAddress1.size() + 1) != EOK) {
448         return OHOS::Wifi::WIFI_OPT_FAILED;
449     }
450     if (memcpy_s(result->randUniqueIpv6Address, DEVICE_IPV6_MAX_LEN, ipInfo.uniqueLocalAddress2.c_str(),
451         ipInfo.uniqueLocalAddress2.size() + 1) != EOK) {
452         return OHOS::Wifi::WIFI_OPT_FAILED;
453     }
454     if (memcpy_s(result->gateway, DEVICE_IPV6_MAX_LEN, ipInfo.gateway.c_str(),
455         ipInfo.gateway.size() + 1) != EOK) {
456         return OHOS::Wifi::WIFI_OPT_FAILED;
457     }
458     if (memcpy_s(result->netmask, DEVICE_IPV6_MAX_LEN, ipInfo.netmask.c_str(),
459         ipInfo.netmask.size() + 1) != EOK) {
460         return OHOS::Wifi::WIFI_OPT_FAILED;
461     }
462     if (memcpy_s(result->primaryDns, DEVICE_IPV6_MAX_LEN, ipInfo.primaryDns.c_str(),
463         ipInfo.primaryDns.size() + 1) != EOK) {
464         return OHOS::Wifi::WIFI_OPT_FAILED;
465     }
466     if (memcpy_s(result->secondDns, DEVICE_IPV6_MAX_LEN, ipInfo.secondDns.c_str(),
467         ipInfo.secondDns.size() + 1) != EOK) {
468         return OHOS::Wifi::WIFI_OPT_FAILED;
469     }
470     return OHOS::Wifi::WIFI_OPT_SUCCESS;
471 }
472 
GetIpv6Info(IpV6Info * info)473 NO_SANITIZE("cfi") WifiErrorCode GetIpv6Info(IpV6Info *info)
474 {
475     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
476     CHECK_PTR_RETURN(info, ERROR_WIFI_INVALID_ARGS);
477     OHOS::Wifi::IpV6Info ipInfo;
478     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetIpv6Info(ipInfo);
479     if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
480         OHOS::Wifi::ErrCode retValue = GetIpV6InfoFromCpp(ipInfo, info);
481         if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
482             WIFI_LOGE("Get ip info from cpp error!");
483             ret = retValue;
484         }
485     }
486     return GetCErrorCode(ret);
487 }
488 
GetSignalLevel(int rssi,int band)489 NO_SANITIZE("cfi") int GetSignalLevel(int rssi, int band)
490 {
491     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
492     int level = -1;
493     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetSignalLevel(rssi, band, level);
494     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
495         WIFI_LOGW("Get wifi signal level fail: %{public}d", ret);
496     }
497     return level;
498 }
499 
SetLowLatencyMode(int enabled)500 NO_SANITIZE("cfi") WifiErrorCode SetLowLatencyMode(int enabled)
501 {
502     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
503     bool ret = wifiDevicePtr->SetLowLatencyMode(enabled);
504     return ret ? WIFI_SUCCESS : ERROR_WIFI_NOT_AVAILABLE;
505 }
506 
IsBandTypeSupported(int bandType,bool * supported)507 NO_SANITIZE("cfi") WifiErrorCode IsBandTypeSupported(int bandType, bool *supported)
508 {
509     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
510     OHOS::Wifi::ErrCode ret = wifiDevicePtr->IsBandTypeSupported(bandType, *supported);
511     return GetCErrorCode(ret);
512 }
513 
Get5GHzChannelList(int * result,int * size)514 NO_SANITIZE("cfi") WifiErrorCode Get5GHzChannelList(int *result, int *size)
515 {
516     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
517     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
518     CHECK_PTR_RETURN(size, ERROR_WIFI_INVALID_ARGS);
519     std::vector<int> vecChannelWidths;
520     OHOS::Wifi::ErrCode ret = wifiDevicePtr->Get5GHzChannelList(vecChannelWidths);
521     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
522         WIFI_LOGE("Get device configs error!");
523         return GetCErrorCode(ret);
524     }
525     if ((int)vecChannelWidths.size() > *size) {
526         WIFI_LOGE("input result size invalid!");
527         return GetCErrorCode(OHOS::Wifi::WIFI_OPT_INVALID_PARAM);
528     }
529 
530     *size = (int)vecChannelWidths.size();
531     for (auto& each : vecChannelWidths) {
532         *result++ = (int)each;
533     }
534     return GetCErrorCode(ret);
535 }
536 #ifndef OHOS_ARCH_LITE
GetWifiProtect(OHOS::Wifi::WifiProtectMode mode)537 NO_SANITIZE("cfi") WifiErrorCode GetWifiProtect(OHOS::Wifi::WifiProtectMode mode)
538 {
539     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
540     return GetCErrorCode(wifiDevicePtr->GetWifiProtect(mode));
541 }
542 
StartPortalCertification(int * result,int * size)543 NO_SANITIZE("cfi") WifiErrorCode StartPortalCertification(int *result, int *size)
544 {
545     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
546     CHECK_PTR_RETURN(result, ERROR_WIFI_INVALID_ARGS);
547     CHECK_PTR_RETURN(size, ERROR_WIFI_INVALID_ARGS);
548     OHOS::Wifi::ErrCode ret = wifiDevicePtr->StartPortalCertification();
549     if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
550         WIFI_LOGE("StartPortalCertification failed!");
551         return GetCErrorCode(ret);
552     }
553     return GetCErrorCode(ret);
554 }
555 
PutWifiProtect()556 NO_SANITIZE("cfi") WifiErrorCode PutWifiProtect()
557 {
558     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
559     return GetCErrorCode(wifiDevicePtr->PutWifiProtect());
560 }
561 
IsHeldWifiProtect(bool & isHeld)562 NO_SANITIZE("cfi") WifiErrorCode IsHeldWifiProtect(bool &isHeld)
563 {
564     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
565     return GetCErrorCode(wifiDevicePtr->IsHeldWifiProtect(isHeld));
566 }
567 
FactoryReset()568 NO_SANITIZE("cfi") WifiErrorCode FactoryReset()
569 {
570     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
571     return GetCErrorCode(wifiDevicePtr->FactoryReset());
572 }
573 
EnableHiLinkHandshake(bool uiFlag,std::string & bssid,OHOS::Wifi::WifiDeviceConfig & deviceConfig)574 NO_SANITIZE("cfi") WifiErrorCode EnableHiLinkHandshake(bool uiFlag, std::string &bssid,
575     OHOS::Wifi::WifiDeviceConfig &deviceConfig)
576 {
577     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
578     return GetCErrorCode(wifiDevicePtr->EnableHiLinkHandshake(uiFlag, bssid, deviceConfig));
579 }
580 
EnableSemiWifi()581 NO_SANITIZE("cfi") WifiErrorCode EnableSemiWifi()
582 {
583     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
584     return GetCErrorCode(wifiDevicePtr->EnableSemiWifi());
585 }
586 
GetWifiDetailState(WifiDetailState * state)587 NO_SANITIZE("cfi") WifiErrorCode GetWifiDetailState(WifiDetailState *state)
588 {
589     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
590     OHOS::Wifi::WifiDetailState detailState;
591     OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetWifiDetailState(detailState);
592     *state = (WifiDetailState)detailState;
593     return GetCErrorCode(ret);
594 }
595 
SetLowTxPower(const WifiLowPowerParam wifiLowPowerParam)596 NO_SANITIZE("cfi") WifiErrorCode SetLowTxPower(const WifiLowPowerParam wifiLowPowerParam)
597 {
598     CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
599     OHOS::Wifi::WifiLowPowerParam tempParam;
600     tempParam.ifName = wifiLowPowerParam.ifName;
601     tempParam.scene = wifiLowPowerParam.scene;
602     tempParam.rssiThreshold = wifiLowPowerParam.rssiThreshold;
603     tempParam.peerMacaddr = wifiLowPowerParam.peerMacaddr;
604     tempParam.powerParam = wifiLowPowerParam.powerParam;
605     tempParam.powerParamLen = wifiLowPowerParam.powerParamLen;
606     return GetCErrorCode(wifiDevicePtr->SetLowTxPower(tempParam));
607 }
608 #endif
609