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