1 /*
2  * Copyright (c) 2021 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 "softbus_wifi_api_adapter.h"
17 
18 #include <stdlib.h>
19 #include <string.h>
20 
21 #include "lnn_log.h"
22 #include "securec.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_def.h"
25 #include "softbus_errcode.h"
26 #include "kits/c/wifi_device.h"
27 #include "kits/c/wifi_hid2d.h"
28 #include "kits/c/wifi_hotspot.h"
29 #include "kits/c/wifi_p2p.h"
30 #include "kits/c/wifi_state.h"
31 
ConvertSoftBusWifiConfFromWifiDev(const WifiDeviceConfig * sourceWifiConf,SoftBusWifiDevConf * wifiConf)32 static int32_t ConvertSoftBusWifiConfFromWifiDev(const WifiDeviceConfig *sourceWifiConf, SoftBusWifiDevConf *wifiConf)
33 {
34     if (strcpy_s(wifiConf->ssid, sizeof(wifiConf->ssid), sourceWifiConf->ssid) != EOK) {
35         LNN_LOGE(LNN_STATE, "str copy ssid fail");
36         return SOFTBUS_ERR;
37     }
38 
39     if (memcpy_s(wifiConf->bssid, sizeof(wifiConf->bssid), sourceWifiConf->bssid,
40         sizeof(sourceWifiConf->bssid)) != EOK) {
41         LNN_LOGE(LNN_STATE, "mem copy bssid fail");
42         return SOFTBUS_ERR;
43     }
44 
45     if (strcpy_s(wifiConf->preSharedKey, sizeof(wifiConf->preSharedKey),
46         sourceWifiConf->preSharedKey) != EOK) {
47         LNN_LOGE(LNN_STATE, "str copy ssid fail");
48         return SOFTBUS_ERR;
49     }
50 
51     wifiConf->securityType = sourceWifiConf->securityType;
52     wifiConf->isHiddenSsid = sourceWifiConf->isHiddenSsid;
53 
54     return SOFTBUS_OK;
55 }
56 
ConvertWifiDevConfFromSoftBusWifiConf(const SoftBusWifiDevConf * result,WifiDeviceConfig * wifiConf)57 static int32_t ConvertWifiDevConfFromSoftBusWifiConf(const SoftBusWifiDevConf *result, WifiDeviceConfig *wifiConf)
58 {
59     if (strcpy_s(wifiConf->ssid, sizeof(wifiConf->ssid), result->ssid) != EOK) {
60         LNN_LOGE(LNN_STATE, "str copy ssid fail");
61         return SOFTBUS_ERR;
62     }
63 
64     if (memcpy_s(wifiConf->bssid, sizeof(wifiConf->bssid),
65         result->bssid, sizeof(result->bssid)) != EOK) {
66         LNN_LOGE(LNN_STATE, "mem copy bssid fail");
67         return SOFTBUS_ERR;
68     }
69 
70     if (strcpy_s(wifiConf->preSharedKey, sizeof(wifiConf->preSharedKey),
71         result->preSharedKey) != EOK) {
72         LNN_LOGE(LNN_STATE, "str copy ssid fail");
73         return SOFTBUS_ERR;
74     }
75 
76     wifiConf->securityType = result->securityType;
77     wifiConf->isHiddenSsid = result->isHiddenSsid;
78 
79     return SOFTBUS_OK;
80 }
81 
SoftBusGetWifiDeviceConfig(SoftBusWifiDevConf * configList,uint32_t * num)82 int32_t SoftBusGetWifiDeviceConfig(SoftBusWifiDevConf *configList, uint32_t *num)
83 {
84     WifiDeviceConfig *result = NULL;
85     uint32_t wifiConfigSize;
86     int32_t retVal;
87     uint32_t i;
88 
89     if (configList == NULL) {
90         LNN_LOGW(LNN_STATE, "para configList is NULL");
91         return SOFTBUS_ERR;
92     }
93     result = SoftBusMalloc(sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
94     if (result == NULL) {
95         LNN_LOGE(LNN_STATE, "malloc wifi device config fail");
96         return SOFTBUS_ERR;
97     }
98     (void)memset_s(result, sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE, 0,
99                    sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
100     retVal = GetDeviceConfigs(result, &wifiConfigSize);
101     if (retVal != SOFTBUS_OK) {
102         LNN_LOGE(LNN_STATE, "malloc wifi device config fail");
103         (void)memset_s(result, sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE, 0,
104                        sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
105         SoftBusFree(result);
106         return SOFTBUS_ERR;
107     }
108 
109     if (wifiConfigSize > WIFI_MAX_CONFIG_SIZE) {
110         LNN_LOGE(LNN_STATE, "wifi device config size is invalid");
111         (void)memset_s(result, sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE, 0,
112                        sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
113         SoftBusFree(result);
114         return SOFTBUS_ERR;
115     }
116 
117     for (i = 0; i < wifiConfigSize; i++) {
118         if (ConvertSoftBusWifiConfFromWifiDev(result, configList) != SOFTBUS_OK) {
119             LNN_LOGE(LNN_STATE, "convert wifi config failed");
120             (void)memset_s(result, sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE, 0,
121                            sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
122             SoftBusFree(result);
123             return SOFTBUS_ERR;
124         }
125         result++;
126         configList++;
127     }
128     *num = wifiConfigSize;
129     (void)memset_s(result, sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE, 0,
130                    sizeof(WifiDeviceConfig) * WIFI_MAX_CONFIG_SIZE);
131     SoftBusFree(result);
132     return SOFTBUS_OK;
133 }
134 
SoftBusConnectToDevice(const SoftBusWifiDevConf * wifiConfig)135 int32_t SoftBusConnectToDevice(const SoftBusWifiDevConf *wifiConfig)
136 {
137     WifiDeviceConfig wifiDevConfig;
138 
139     if (wifiConfig == NULL) {
140         LNN_LOGE(LNN_STATE, "para wifiConfig is NULL");
141         return SOFTBUS_ERR;
142     }
143     (void)memset_s(&wifiDevConfig, sizeof(WifiDeviceConfig), 0, sizeof(WifiDeviceConfig));
144     if (ConvertWifiDevConfFromSoftBusWifiConf(wifiConfig, &wifiDevConfig) != SOFTBUS_OK) {
145         LNN_LOGE(LNN_STATE, "convert wifi config failed");
146         return SOFTBUS_ERR;
147     }
148 
149     if (ConnectToDevice(&wifiDevConfig) != SOFTBUS_OK) {
150         LNN_LOGE(LNN_STATE, "connect to wifi failed");
151         return SOFTBUS_ERR;
152     }
153 
154     return SOFTBUS_OK;
155 }
156 
SoftBusDisconnectDevice(void)157 int32_t SoftBusDisconnectDevice(void)
158 {
159     return Disconnect();
160 }
161 
162 static ISoftBusScanResult *g_scanResultCb[MAX_CALLBACK_NUM] = {NULL};
163 static bool g_registerFlag = true;
164 
SoftBusStartWifiScan(void)165 int32_t SoftBusStartWifiScan(void)
166 {
167     int32_t ret;
168 
169     ret = Scan();
170     if (ret != WIFI_SUCCESS) {
171         LNN_LOGE(LNN_STATE, "softbus start wifi scan failed");
172         return SOFTBUS_ERR;
173     }
174     return SOFTBUS_OK;
175 }
176 
SoftBusWifiScanStateChanged(int state,int size)177 static void SoftBusWifiScanStateChanged(int state, int size)
178 {
179     for (int i = 0; i < MAX_CALLBACK_NUM; i++) {
180         if (g_scanResultCb[i] != NULL) {
181             g_scanResultCb[i]->onSoftBusWifiScanResult(state, size);
182         }
183     }
184 }
185 
186 static WifiEvent g_event = {
187     .OnWifiConnectionChanged = NULL,
188     .OnWifiScanStateChanged = SoftBusWifiScanStateChanged,
189     .OnHotspotStateChanged = NULL,
190     .OnHotspotStaJoin = NULL,
191     .OnHotspotStaLeave = NULL,
192 };
193 
FindFreeCallbackIndex(void)194 static int32_t FindFreeCallbackIndex(void)
195 {
196     int i;
197     for (i = 0; i < MAX_CALLBACK_NUM; i++) {
198         if (g_scanResultCb[i] == NULL) {
199             break;
200         }
201     }
202     return i;
203 }
204 
SoftBusRegisterWifiEvent(ISoftBusScanResult * cb)205 int32_t SoftBusRegisterWifiEvent(ISoftBusScanResult *cb)
206 {
207     int32_t ret;
208 
209     int index = FindFreeCallbackIndex();
210     if (index == MAX_CALLBACK_NUM) {
211         LNN_LOGE(LNN_STATE, "register callback index invalid");
212         return SOFTBUS_ERR;
213     }
214     g_scanResultCb[index] = cb;
215 
216     if (g_registerFlag) {
217         ret = RegisterWifiEvent(&g_event);
218         if (ret == WIFI_SUCCESS) {
219             g_registerFlag = false;
220         } else {
221             LNN_LOGE(LNN_STATE, "softbus register wifi event failed");
222             return SOFTBUS_ERR;
223         }
224     }
225     return SOFTBUS_OK;
226 }
227 
ConvertSoftBusWifiScanInfoFromWifi(WifiScanInfo * info,SoftBusWifiScanInfo * result,uint32_t * size)228 static int32_t ConvertSoftBusWifiScanInfoFromWifi(WifiScanInfo *info, SoftBusWifiScanInfo *result, uint32_t *size)
229 {
230     if (info == NULL || result == NULL || size == NULL) {
231         LNN_LOGE(LNN_STATE, "invalid para");
232         return SOFTBUS_ERR;
233     }
234     for (uint32_t i = 0; i < (*size); i++) {
235         if (strcpy_s(result->ssid, WIFI_MAX_SSID_LEN, info->ssid) != EOK) {
236             LNN_LOGE(LNN_STATE, "strcpy ssid fail");
237             return SOFTBUS_ERR;
238         }
239         if (memcpy_s(result->bssid, WIFI_MAC_LEN, info->bssid, sizeof(info->bssid)) != EOK) {
240             LNN_LOGE(LNN_STATE, "memcpy bssid fail");
241             return SOFTBUS_ERR;
242         }
243         result->securityType =  (int32_t)(info->securityType);
244         result->rssi = (int32_t)(info->rssi);
245         result->band = (int32_t)(info->band);
246         result->frequency = (int32_t)(info->frequency);
247         result->channelWidth = (int32_t)(info->channelWidth);
248         result->centerFrequency0 = (int32_t)(info->centerFrequency0);
249         result->centerFrequency1 = (int32_t)(info->centerFrequency1);
250         result->timestamp = info->timestamp;
251         ++result;
252         ++info;
253     }
254     return SOFTBUS_OK;
255 }
256 
SoftBusGetWifiScanList(SoftBusWifiScanInfo ** result,uint32_t * size)257 int32_t SoftBusGetWifiScanList(SoftBusWifiScanInfo **result, uint32_t *size)
258 {
259     if (size == NULL || result == NULL) {
260         LNN_LOGW(LNN_STATE, "para size or result is NULL");
261         return SOFTBUS_ERR;
262     }
263     WifiScanInfo *info = (WifiScanInfo *)SoftBusMalloc(sizeof(WifiScanInfo) * WIFI_MAX_SCAN_HOTSPOT_LIMIT);
264     if (info == NULL) {
265         LNN_LOGE(LNN_STATE, "malloc wifi scan information failed");
266         return SOFTBUS_ERR;
267     }
268     (void)memset_s(info, sizeof(WifiScanInfo)*WIFI_MAX_SCAN_HOTSPOT_LIMIT, 0,
269         sizeof(WifiScanInfo)*WIFI_MAX_SCAN_HOTSPOT_LIMIT);
270     *size = WIFI_MAX_SCAN_HOTSPOT_LIMIT;
271     int32_t ret = GetScanInfoList(info, (unsigned int *)size);
272     if (ret != WIFI_SUCCESS || size == 0) {
273         LNN_LOGE(LNN_STATE, "softbus get wifi scan list failed");
274         SoftBusFree(info);
275         return SOFTBUS_ERR;
276     }
277     *result = (SoftBusWifiScanInfo *)SoftBusMalloc(sizeof(SoftBusWifiScanInfo) * (*size));
278     if (*result == NULL) {
279         LNN_LOGE(LNN_STATE, "malloc softbus wifi scan information failed");
280         SoftBusFree(info);
281         return SOFTBUS_ERR;
282     }
283     (void)memset_s(*result, sizeof(SoftBusWifiScanInfo)* (*size), 0, sizeof(SoftBusWifiScanInfo)* (*size));
284     if (ConvertSoftBusWifiScanInfoFromWifi(info, *result, size) != SOFTBUS_OK) {
285         LNN_LOGE(LNN_STATE, "ConvertSoftBusWifiScaninfoFromWifi failed");
286         SoftBusFree(*result);
287         *result = NULL;
288         SoftBusFree(info);
289         return SOFTBUS_ERR;
290     }
291     SoftBusFree(info);
292     return SOFTBUS_OK;
293 }
294 
IsScanResultCbEmpty(void)295 static bool IsScanResultCbEmpty(void)
296 {
297     for (int i = 0; i < MAX_CALLBACK_NUM; i++) {
298         if (g_scanResultCb[i] != NULL) {
299             return false;
300         }
301     }
302     return true;
303 }
304 
SoftBusUnRegisterWifiEvent(ISoftBusScanResult * cb)305 int32_t SoftBusUnRegisterWifiEvent(ISoftBusScanResult *cb)
306 {
307     int32_t ret;
308 
309     for (int i = 0; i < MAX_CALLBACK_NUM; i++) {
310         if (g_scanResultCb[i] == cb) {
311             g_scanResultCb[i] = NULL;
312         }
313     }
314 
315     if (IsScanResultCbEmpty()) {
316         ret = UnRegisterWifiEvent(&g_event);
317         if (ret == WIFI_SUCCESS) {
318             g_registerFlag = true;
319         } else {
320             LNN_LOGE(LNN_STATE, "softBus unRegister wifi event failed");
321             return SOFTBUS_ERR;
322         }
323     }
324     return SOFTBUS_OK;
325 }
326 
SoftBusGetChannelListFor5G(int32_t * channelList,int32_t num)327 int32_t SoftBusGetChannelListFor5G(int32_t *channelList, int32_t num)
328 {
329     if (channelList == NULL) {
330         LNN_LOGW(LNN_STATE, "para channelList is NULL");
331         return SOFTBUS_ERR;
332     }
333     int32_t ret = Hid2dGetChannelListFor5G(channelList, num);
334     if (ret != WIFI_SUCCESS) {
335         LNN_LOGE(LNN_STATE, "get channel 5G list failed");
336         return SOFTBUS_ERR;
337     }
338     return SOFTBUS_OK;
339 }
340 
SoftBusGetLinkBand(void)341 SoftBusBand SoftBusGetLinkBand(void)
342 {
343     WifiLinkedInfo result;
344     GetLinkedInfo(&result);
345     if (GetLinkedInfo(&result) != WIFI_SUCCESS) {
346         LNN_LOGE(LNN_STATE, "get SoftBusGetLinkBand failed");
347         return BAND_UNKNOWN;
348     }
349     if (result.band == BAND_24G) {
350         return BAND_24G;
351     } else if (result.band == BAND_5G) {
352         return BAND_5G;
353     } else {
354         LNN_LOGE(LNN_STATE, "get SoftBusGetLinkBand success");
355         return BAND_UNKNOWN;
356     }
357 }
358 
SoftBusGetLinkedInfo(SoftBusWifiLinkedInfo * info)359 int32_t SoftBusGetLinkedInfo(SoftBusWifiLinkedInfo *info)
360 {
361     WifiLinkedInfo result;
362     if (GetLinkedInfo(&result) != WIFI_SUCCESS) {
363         LNN_LOGE(LNN_STATE, "get SoftBusGetLinkedInfo failed");
364         return SOFTBUS_ERR;
365     }
366     info->frequency = result.frequency;
367     info->band = result.band;
368     info->connState = SOFTBUS_API_WIFI_DISCONNECTED;
369     if (result.connState == WIFI_CONNECTED) {
370         info->connState = SOFTBUS_API_WIFI_CONNECTED;
371     }
372     return SOFTBUS_OK;
373 }
374 
SoftBusGetCurrentGroup(SoftBusWifiP2pGroupInfo * groupInfo)375 int32_t SoftBusGetCurrentGroup(SoftBusWifiP2pGroupInfo *groupInfo)
376 {
377     WifiP2pGroupInfo result;
378     if (GetCurrentGroup(&result) != WIFI_SUCCESS) {
379         LNN_LOGD(LNN_STATE, "get SoftBusGetCurrentGroup failed");
380         return SOFTBUS_ERR;
381     }
382     if (memcpy_s(groupInfo, sizeof(SoftBusWifiP2pGroupInfo), &result, sizeof(WifiP2pGroupInfo)) != EOK) {
383         return SOFTBUS_MEM_ERR;
384     }
385     return SOFTBUS_OK;
386 }
387 
SoftBusHasWifiDirectCapability(void)388 bool SoftBusHasWifiDirectCapability(void)
389 {
390     return true;
391 }
392 
SoftBusIsWifiTripleMode(void)393 bool SoftBusIsWifiTripleMode(void)
394 {
395     return false;
396 }
397 
SoftBusGetWifiInterfaceCoexistCap(void)398 char* SoftBusGetWifiInterfaceCoexistCap(void)
399 {
400     return NULL;
401 }
402 
SoftBusIsWifiActive(void)403 bool SoftBusIsWifiActive(void)
404 {
405     int wifiState = IsWifiActive();
406     LNN_LOGI(LNN_STATE, "wifiState=%{public}d", wifiState);
407     if (wifiState == WIFI_STA_ACTIVE) {
408         return true;
409     }
410     return false;
411 }
412 
SoftBusIsHotspotActive(void)413 bool SoftBusIsHotspotActive(void)
414 {
415     int hotspotState = IsHotspotActive();
416     LNN_LOGI(LNN_STATE, "hotspotState=%{public}d", hotspotState);
417     if (hotspotState == WIFI_HOTSPOT_ACTIVE) {
418         return true;
419     }
420     return false;
421 }
422 
SoftBusGetWifiState(void)423 SoftBusWifiDetailState SoftBusGetWifiState(void)
424 {
425     WifiDetailState wifiState;
426     if (GetWifiDetailState(&wifiState) != WIFI_SUCCESS) {
427         LNN_LOGE(LNN_STATE, "GetWifiDetailState failed");
428         return SOFTBUS_WIFI_STATE_UNKNOWN;
429     }
430     LNN_LOGI(LNN_STATE, "wifiState=%{public}d", wifiState);
431     switch (wifiState) {
432         case STATE_INACTIVE:
433             return SOFTBUS_WIFI_STATE_INACTIVE;
434         case STATE_ACTIVATED:
435             return SOFTBUS_WIFI_STATE_ACTIVED;
436         case STATE_ACTIVATING:
437             return SOFTBUS_WIFI_STATE_ACTIVATING;
438         case STATE_DEACTIVATING:
439             return SOFTBUS_WIFI_STATE_DEACTIVATING;
440         case STATE_SEMI_ACTIVATING:
441             return SOFTBUS_WIFI_STATE_SEMIACTIVATING;
442         case STATE_SEMI_ACTIVE:
443             return SOFTBUS_WIFI_STATE_SEMIACTIVE;
444         default:
445             break;
446     }
447     return SOFTBUS_WIFI_STATE_UNKNOWN;
448 }
449 
SoftBusIsWifiP2pEnabled(void)450 bool SoftBusIsWifiP2pEnabled(void)
451 {
452     enum P2pState state;
453     if (GetP2pEnableStatus(&state) != WIFI_SUCCESS) {
454         LNN_LOGE(LNN_STATE, "GetP2pEnableStatus failed");
455         return false;
456     }
457     LNN_LOGI(LNN_STATE, "P2pState=%{public}d", state);
458 
459     return state == P2P_STATE_STARTED;
460 }