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 "native_c/wifi_device.h"
17 #include "native_cpp/wifi_standard/include/wifi_device.h"
18 #include "native_cpp/wifi_standard/include/wifi_scan.h"
19 #include "native_c/wifi_scan_info.h"
20 #include "native_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 WifiErrorCode EnableWifi()
38 {
39 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
40 return GetCErrorCode(wifiDevicePtr->EnableWifi());
41 }
42
DisableWifi()43 WifiErrorCode DisableWifi()
44 {
45 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
46 return GetCErrorCode(wifiDevicePtr->DisableWifi());
47 }
48
IsWifiActive()49 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 WifiErrorCode Scan()
61 {
62 CHECK_PTR_RETURN(wifiScanPtr, ERROR_WIFI_NOT_AVAILABLE);
63 return GetCErrorCode(wifiScanPtr->Scan());
64 }
65
GetScanInfoList(WifiScanInfo * result,unsigned int * size)66 WifiErrorCode GetScanInfoList(WifiScanInfo *result, unsigned int *size)
67 {
68 CHECK_PTR_RETURN(wifiScanPtr, ERROR_WIFI_NOT_AVAILABLE);
69 if (result == nullptr) {
70 WIFI_LOGE("Scan info receive addr is null!");
71 return ERROR_WIFI_UNKNOWN;
72 }
73
74 std::vector<OHOS::Wifi::WifiScanInfo> vecScnIanfos;
75 OHOS::Wifi::ErrCode ret = wifiScanPtr->GetScanInfoList(vecScnIanfos);
76 *size = (int)vecScnIanfos.size();
77 for (auto& each : vecScnIanfos) {
78 if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN, each.ssid.c_str(), each.ssid.size() + 1) != EOK) {
79 return ERROR_WIFI_UNKNOWN;
80 }
81 if (OHOS::Wifi::MacStrToArray(each.bssid, result->bssid) != EOK) {
82 WIFI_LOGE("Scan info convert bssid error!");
83 return ERROR_WIFI_UNKNOWN;
84 }
85 result->securityType = static_cast<int>(each.securityType);
86 result->rssi = each.rssi;
87 result->band = each.band;
88 result->frequency = each.frequency;
89 ++result;
90 }
91 return GetCErrorCode(ret);
92 }
93
GetKeyMgmtBySecType(const int securityType)94 static std::string GetKeyMgmtBySecType(const int securityType)
95 {
96 WifiSecurityType key = WifiSecurityType(securityType);
97 std::map<WifiSecurityType, std::string>::const_iterator iter = g_secTypeKeyMgmtMap.find(key);
98 return iter == g_secTypeKeyMgmtMap.end() ? "NONE" : iter->second;
99 }
100
GetSecTypeByKeyMgmt(const std::string & keyMgmt)101 static int GetSecTypeByKeyMgmt(const std::string& keyMgmt)
102 {
103 for (auto& each : g_secTypeKeyMgmtMap) {
104 if (each.second == keyMgmt) {
105 return static_cast<int>(each.first);
106 }
107 }
108 return static_cast<int>(WIFI_SEC_TYPE_OPEN);
109 }
110
GetStaticIpFromC(const IpConfig & ipConfig,OHOS::Wifi::StaticIpAddress & staticIp)111 static void GetStaticIpFromC(const IpConfig& ipConfig, OHOS::Wifi::StaticIpAddress& staticIp)
112 {
113 /* Just IPV4 now */
114 staticIp.ipAddress.address.addressIpv4 = ipConfig.ipAddress;
115 staticIp.gateway.addressIpv4 = ipConfig.gateway;
116 if (WIFI_MAX_DNS_NUM > 0) {
117 staticIp.dnsServer1.addressIpv4 = ipConfig.dnsServers[0];
118 }
119 /* Has backup DNS server */
120 if (WIFI_MAX_DNS_NUM > 1) {
121 staticIp.dnsServer2.addressIpv4 = ipConfig.dnsServers[1];
122 }
123 /* netmask: automatic calculate netmask, don't support customized set this value currently */
124 }
125
GetStaticIpFromCpp(const OHOS::Wifi::StaticIpAddress & staticIp,IpConfig & ipConfig)126 static void GetStaticIpFromCpp(const OHOS::Wifi::StaticIpAddress& staticIp, IpConfig& ipConfig)
127 {
128 /* Just IPV4 now */
129 ipConfig.ipAddress = staticIp.ipAddress.address.addressIpv4;
130 ipConfig.gateway = staticIp.gateway.addressIpv4;
131 if (WIFI_MAX_DNS_NUM > 0) {
132 ipConfig.dnsServers[0] = staticIp.dnsServer1.addressIpv4;
133 }
134 /* Has backup DNS server */
135 if (WIFI_MAX_DNS_NUM > 1) {
136 ipConfig.dnsServers[1] = staticIp.dnsServer2.addressIpv4;
137 }
138 /* netmask: not support now */
139 }
140
ConvertDeviceConfigFromC(const WifiDeviceConfig * config,OHOS::Wifi::WifiDeviceConfig & deviceConfig)141 static void ConvertDeviceConfigFromC(const WifiDeviceConfig *config, OHOS::Wifi::WifiDeviceConfig& deviceConfig)
142 {
143 deviceConfig.ssid = config->ssid;
144 if (OHOS::Wifi::IsMacArrayEmpty(config->bssid)) {
145 deviceConfig.bssid = "";
146 } else {
147 deviceConfig.bssid = OHOS::Wifi::MacArrayToStr(config->bssid);
148 }
149 deviceConfig.preSharedKey = config->preSharedKey;
150 deviceConfig.keyMgmt = GetKeyMgmtBySecType(config->securityType);
151 deviceConfig.networkId = config->netId;
152 deviceConfig.frequency = config->freq;
153 /* wapiPskType is not support, don't verify now */
154 if (config->ipType == DHCP) {
155 deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::DHCP;
156 } else if (config->ipType == STATIC_IP) {
157 deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::STATIC;
158 GetStaticIpFromC(config->staticIp, deviceConfig.wifiIpConfig.staticIpAddress);
159 } else {
160 deviceConfig.wifiIpConfig.assignMethod = OHOS::Wifi::AssignIpMethod::UNASSIGNED;
161 }
162 deviceConfig.hiddenSSID = config->isHiddenSsid;
163 }
164
ConvertDeviceConfigFromCpp(const OHOS::Wifi::WifiDeviceConfig & deviceConfig,WifiDeviceConfig * result)165 static OHOS::Wifi::ErrCode ConvertDeviceConfigFromCpp(const OHOS::Wifi::WifiDeviceConfig& deviceConfig,
166 WifiDeviceConfig *result)
167 {
168 if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN, deviceConfig.ssid.c_str(), deviceConfig.ssid.size() + 1) != EOK) {
169 return OHOS::Wifi::WIFI_OPT_FAILED;
170 }
171 if (OHOS::Wifi::MacStrToArray(deviceConfig.bssid, result->bssid) != EOK) {
172 WIFI_LOGE("device config convert bssid error!");
173 return OHOS::Wifi::WIFI_OPT_FAILED;
174 }
175 if (memcpy_s(result->preSharedKey, WIFI_MAX_KEY_LEN, deviceConfig.preSharedKey.c_str(), WIFI_MAX_KEY_LEN) != EOK) {
176 return OHOS::Wifi::WIFI_OPT_FAILED;
177 }
178 result->securityType = GetSecTypeByKeyMgmt(deviceConfig.keyMgmt);
179 result->netId = deviceConfig.networkId;
180 result->freq = deviceConfig.frequency;
181 /* wapiPskType is not support now */
182 if (deviceConfig.wifiIpConfig.assignMethod == OHOS::Wifi::AssignIpMethod::DHCP) {
183 result->ipType = DHCP;
184 } else if (deviceConfig.wifiIpConfig.assignMethod == OHOS::Wifi::AssignIpMethod::STATIC) {
185 result->ipType = STATIC_IP;
186 GetStaticIpFromCpp(deviceConfig.wifiIpConfig.staticIpAddress, result->staticIp);
187 } else {
188 result->ipType = UNKNOWN;
189 }
190 result->isHiddenSsid = deviceConfig.hiddenSSID;
191 return OHOS::Wifi::WIFI_OPT_SUCCESS;
192 }
193
AddDeviceConfig(const WifiDeviceConfig * config,int * result)194 WifiErrorCode AddDeviceConfig(const WifiDeviceConfig *config, int *result)
195 {
196 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
197 OHOS::Wifi::WifiDeviceConfig deviceConfig;
198 ConvertDeviceConfigFromC(config, deviceConfig);
199 int addResult = -1;
200 OHOS::Wifi::ErrCode ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, addResult);
201 *result = addResult;
202 return GetCErrorCode(ret);
203 }
204
GetDeviceConfigs(WifiDeviceConfig * result,unsigned int * size)205 WifiErrorCode GetDeviceConfigs(WifiDeviceConfig *result, unsigned int *size)
206 {
207 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
208 if (result == nullptr) {
209 WIFI_LOGE("Get device configs result array is null!");
210 return ERROR_WIFI_UNKNOWN;
211 }
212
213 std::vector<OHOS::Wifi::WifiDeviceConfig> vecDeviceConfigs;
214 OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetDeviceConfigs(vecDeviceConfigs);
215 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
216 WIFI_LOGE("Get device configs error!");
217 return GetCErrorCode(ret);
218 }
219 *size = (int)vecDeviceConfigs.size();
220 for (auto& each : vecDeviceConfigs) {
221 OHOS::Wifi::ErrCode retValue = ConvertDeviceConfigFromCpp(each, result++);
222 if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
223 ret = retValue;
224 WIFI_LOGE("Convert device configs error!");
225 }
226 }
227 return GetCErrorCode(ret);
228 }
229
RemoveDevice(int networkId)230 WifiErrorCode RemoveDevice(int networkId)
231 {
232 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
233 return GetCErrorCode(wifiDevicePtr->RemoveDevice(networkId));
234 }
235
DisableDeviceConfig(int networkId)236 WifiErrorCode DisableDeviceConfig(int networkId)
237 {
238 return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
239 }
240
EnableDeviceConfig(int networkId)241 WifiErrorCode EnableDeviceConfig(int networkId)
242 {
243 return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
244 }
245
ConnectTo(int networkId)246 WifiErrorCode ConnectTo(int networkId)
247 {
248 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
249 return GetCErrorCode(wifiDevicePtr->ConnectToNetwork(networkId));
250 }
251
ConnectToDevice(const WifiDeviceConfig * config)252 WifiErrorCode ConnectToDevice(const WifiDeviceConfig *config)
253 {
254 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
255 OHOS::Wifi::WifiDeviceConfig deviceConfig;
256 ConvertDeviceConfigFromC(config, deviceConfig);
257 return GetCErrorCode(wifiDevicePtr->ConnectToDevice(deviceConfig));
258 }
259
Disconnect()260 WifiErrorCode Disconnect()
261 {
262 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
263 return GetCErrorCode(wifiDevicePtr->Disconnect());
264 }
265
GetLinkedInfoFromCpp(const OHOS::Wifi::WifiLinkedInfo & linkedInfo,WifiLinkedInfo * result)266 static OHOS::Wifi::ErrCode GetLinkedInfoFromCpp(const OHOS::Wifi::WifiLinkedInfo& linkedInfo, WifiLinkedInfo *result)
267 {
268 if (memcpy_s(result->ssid, WIFI_MAX_SSID_LEN, linkedInfo.ssid.c_str(), linkedInfo.ssid.size() + 1) != EOK) {
269 return OHOS::Wifi::WIFI_OPT_FAILED;
270 }
271 if (OHOS::Wifi::MacStrToArray(linkedInfo.bssid, result->bssid) != EOK) {
272 WIFI_LOGE("linked info convert bssid error!");
273 return OHOS::Wifi::WIFI_OPT_FAILED;
274 }
275 result->rssi = linkedInfo.rssi;
276 result->band = linkedInfo.band;
277 result->frequency = linkedInfo.frequency;
278 result->connState = linkedInfo.connState == OHOS::Wifi::ConnState::CONNECTED ? WIFI_CONNECTED : WIFI_DISCONNECTED;
279 /* disconnectedReason not support */
280 result->ipAddress = linkedInfo.ipAddress;
281 return OHOS::Wifi::WIFI_OPT_SUCCESS;
282 }
283
GetLinkedInfo(WifiLinkedInfo * result)284 WifiErrorCode GetLinkedInfo(WifiLinkedInfo *result)
285 {
286 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
287 OHOS::Wifi::WifiLinkedInfo linkedInfo;
288 OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetLinkedInfo(linkedInfo);
289 if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
290 OHOS::Wifi::ErrCode retValue = GetLinkedInfoFromCpp(linkedInfo, result);
291 if (retValue != OHOS::Wifi::WIFI_OPT_SUCCESS) {
292 WIFI_LOGE("Get linked info from cpp error!");
293 ret = retValue;
294 }
295 }
296 return GetCErrorCode(ret);
297 }
298
GetDeviceMacAddress(unsigned char * result)299 WifiErrorCode GetDeviceMacAddress(unsigned char *result)
300 {
301 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
302 std::string mac;
303 OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetDeviceMacAddress(mac);
304 if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
305 if (OHOS::Wifi::MacStrToArray(mac, result) != EOK) {
306 WIFI_LOGE("get mac convert to array error!");
307 return ERROR_WIFI_UNKNOWN;
308 }
309 }
310 return GetCErrorCode(ret);
311 }
312
AdvanceScan(WifiScanParams * params)313 WifiErrorCode AdvanceScan(WifiScanParams *params)
314 {
315 return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
316 }
317
GetIpInfo(IpInfo * info)318 WifiErrorCode GetIpInfo(IpInfo *info)
319 {
320 return GetCErrorCode(OHOS::Wifi::WIFI_OPT_NOT_SUPPORTED);
321 }
322
GetSignalLevel(int rssi,int band)323 int GetSignalLevel(int rssi, int band)
324 {
325 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
326 int level = -1;
327 OHOS::Wifi::ErrCode ret = wifiDevicePtr->GetSignalLevel(rssi, band, level);
328 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
329 WIFI_LOGW("Get wifi signal level fail: %{public}d", ret);
330 }
331 return level;
332 }
333
SetLowLatencyMode(int enabled)334 WifiErrorCode SetLowLatencyMode(int enabled)
335 {
336 CHECK_PTR_RETURN(wifiDevicePtr, ERROR_WIFI_NOT_AVAILABLE);
337 bool ret = wifiDevicePtr->SetLowLatencyMode(enabled);
338 return ret ? WIFI_SUCCESS : ERROR_WIFI_NOT_AVAILABLE;
339 }
340