1 /*
2  * Driver interaction with hdf wifi
3  * Copyright (c) 2020 Huawei Device Co., Ltd.
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "wpa_hal.h"
10 #include "includes.h"
11 #include "utils/common.h"
12 #include "driver.h"
13 #include "ap/hostapd.h"
14 #include "l2_packet/l2_packet.h"
15 #include "eloop.h"
16 #include "securec.h"
17 #include <dirent.h>
18 
19 #ifdef __cplusplus
20 #if __cplusplus
21 extern "C" {
22 #endif
23 #endif
24 
25 WifiDriverData *g_wifiDriverData = NULL;
26 enum WifiIfType g_wifiDriverType = WIFI_IFTYPE_UNSPECIFIED;
27 #define WAIT_LOAD_NETDEVICE 2500
28 #ifdef CONFIG_OHOS_P2P
29 uint8_t g_msgInit = TRUE;
30 #endif
31 
GetDrvDatanull32 WifiDriverData *GetDrvData()
33 {
34     return g_wifiDriverData;
35 }
36 
37 #ifdef CONFIG_OHOS_P2P
38 #define WPA_MAX_WIFI_DEV_NUM 3
39 
40 WifiDev* g_wifiDev[WPA_MAX_WIFI_DEV_NUM] = {NULL};
41 
GetWifiDevByName(const char *ifName)42 WifiDev* GetWifiDevByName(const char *ifName)
43 {
44     int32_t i;
45     if (ifName == NULL) {
46         return NULL;
47     }
48     for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
49         if ((g_wifiDev[i] != NULL) && (strncmp(g_wifiDev[i]->ifName, ifName, strlen(ifName)) == 0)) {
50             g_wifiDev[i]->networkId = i;
51             return g_wifiDev[i];
52         }
53     }
54     return NULL;
55 }
56 
SetWifiDev(WifiDev *wifiDev)57 int32_t SetWifiDev(WifiDev *wifiDev)
58 {
59     int32_t i;
60     if (wifiDev == NULL) {
61         return -EFAIL;
62     }
63     for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
64         if ((g_wifiDev[i] != NULL) && (strncmp(g_wifiDev[i]->ifName, wifiDev->ifName, strlen(wifiDev->ifName)) == 0)) {
65             g_wifiDev[i] = wifiDev;
66             return SUCC;
67         } else if (g_wifiDev[i] == NULL) {
68             g_wifiDev[i] = wifiDev;
69             g_wifiDev[i]->networkId = i;
70             return SUCC;
71         }
72     }
73     return -EFAIL;
74 }
75 
FreeWifiDev(WifiDev *wifiDev)76 void FreeWifiDev(WifiDev *wifiDev)
77 {
78     int32_t i;
79     if (wifiDev == NULL) {
80         return;
81     }
82     for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
83         if (g_wifiDev[i] == wifiDev) {
84             g_wifiDev[i] = NULL;
85             break;
86         }
87     }
88     os_free(wifiDev);
89     wifiDev = NULL;
90 }
91 
CountWifiDevInUsenull92 int32_t CountWifiDevInUse()
93 {
94     int32_t i;
95     int32_t count = 0;
96     for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
97         if (g_wifiDev[i] != NULL) {
98             count++;
99         }
100     }
101     return count;
102 }
103 #endif // CONFIG_OHOS_P2P
104 
OnWpaWiFiEvents(uint32_t event, void *data, const char *ifName)105 static int OnWpaWiFiEvents(uint32_t event, void *data, const char *ifName)
106 {
107     WifiDriverData *drv = NULL;
108 #ifndef CONFIG_OHOS_P2P
109     drv = GetDrvData();
110 #else
111     WifiDev *wifiDev = NULL;
112     wifiDev = GetWifiDevByName(ifName);
113     if (wifiDev == NULL) {
114         wpa_printf(MSG_ERROR, "OnWpaWiFiEvents wifiDev is null\n");
115         return -EFAIL;
116     }
117     drv = wifiDev->priv;
118 #endif
119     (void)ifName;
120     wpa_printf(MSG_INFO, "OnWpaWiFiEvents event=%d", event);
121     if (drv == NULL || data == NULL) {
122         return -EFAIL;
123     }
124     switch (event) {
125         case WIFI_EVENT_NEW_STA:
126             WifiWpaNewStaProcess(drv, (WifiNewStaInfo *)data);
127             break;
128         case WIFI_EVENT_DEL_STA:
129             WifiWpaDelStaProcess(drv, (uint8_t *)data);
130             break;
131         case WIFI_EVENT_RX_MGMT:
132             WifiWpaRxMgmtProcess(drv, (WifiRxMgmt *)data);
133             break;
134         case WIFI_EVENT_TX_STATUS:
135             WifiWpaTxStatusProcess(drv, (WifiTxStatus *)data);
136             break;
137         case WIFI_EVENT_SCAN_DONE:
138             WifiWpaScanDoneProcess(drv, (uint32_t *)data);
139             break;
140         case WIFI_EVENT_SCAN_RESULT:
141             WifiWpaScanResultProcess(drv, (WifiScanResult *)data);
142             break;
143         case WIFI_EVENT_CONNECT_RESULT:
144             WifiWpaConnectResultProcess(drv, (WifiConnectResult *)data);
145             break;
146         case WIFI_EVENT_DISCONNECT:
147             WifiWpaDisconnectProcess(drv, (WifiDisconnect *)data);
148             break;
149         case WIFI_EVENT_EAPOL_RECV:
150             WifiWpaDriverEapolRecvProcess(drv, data);
151             break;
152         case WIFI_EVENT_REMAIN_ON_CHANNEL:
153             WifiWpaRemainOnChannelProcess(drv, (WifiOnChannel *)data);
154             break;
155         case WIFI_EVENT_CANCEL_REMAIN_ON_CHANNEL:
156             WifiWpaCancelRemainOnChannelProcess(drv, (WifiOnChannel *)data);
157             break;
158         default:
159             break;
160     }
161 
162     return SUCC;
163 }
164 
WifiClientInit(const char *ifName)165 static int32_t WifiClientInit(const char *ifName)
166 {
167     int32_t ret;
168 
169     wpa_printf(MSG_INFO, "WifiClientInit enter.");
170     ret = WifiDriverClientInit();
171     if (ret != SUCC) {
172         wpa_printf(MSG_ERROR, "WifiWpa init msg service failed");
173         return ret;
174     }
175     ret = WifiRegisterEventCallback(OnWpaWiFiEvents, WIFI_KERNEL_TO_WPA_CLIENT, ifName);
176     if (ret != SUCC) {
177         wpa_printf(MSG_ERROR, "WifiWpa register event listener faild");
178     }
179     return ret;
180 }
181 
WifiClientDeinit(const char *ifName)182 void WifiClientDeinit(const char *ifName)
183 {
184     WifiUnregisterEventCallback(OnWpaWiFiEvents, WIFI_KERNEL_TO_WPA_CLIENT, ifName);
185     WifiDriverClientDeinit();
186 }
187 
WifiWpaGetBssid(void *priv, uint8_t *bssid)188 static int32_t WifiWpaGetBssid(void *priv, uint8_t *bssid)
189 {
190     WifiDriverData *drv = priv;
191     errno_t rc;
192     if ((priv == NULL) || (bssid == NULL)) {
193         return -EFAIL;
194     }
195     if (drv->associated == WIFI_DISCONNECT) {
196         wpa_printf(MSG_ERROR, "%s associated status error", __func__);
197         return -EFAIL;
198     }
199 
200     rc = memcpy_s(bssid, ETH_ADDR_LEN, drv->bssid, ETH_ADDR_LEN);
201     if (rc != EOK) {
202         return -EFAIL;
203     }
204     return SUCC;
205 }
206 
WifiWpaGetSsid(void *priv, uint8_t *ssid)207 static int32_t WifiWpaGetSsid(void *priv, uint8_t *ssid)
208 {
209     WifiDriverData *drv = priv;
210     errno_t rc;
211     if ((priv == NULL) || (ssid == NULL)) {
212         return -EFAIL;
213     }
214     if (drv->associated == WIFI_DISCONNECT) {
215         wpa_printf(MSG_ERROR, "%s associated status error", __func__);
216         return -EFAIL;
217     }
218     rc = memcpy_s(ssid, MAX_SSID_LEN, drv->ssid, drv->ssidLen);
219     if (rc != EOK) {
220         return -EFAIL;
221     }
222     return drv->ssidLen;
223 }
224 
WifiAlgToCipherSuite(enum wpa_alg alg, size_t keyLen)225 static uint32_t WifiAlgToCipherSuite(enum wpa_alg alg, size_t keyLen)
226 {
227     switch (alg) {
228         case WPA_ALG_WEP:
229             if (keyLen == WPA_WEP40_KEY_LEN) {
230                 return RSN_CIPHER_SUITE_WEP40;
231             }
232             return RSN_CIPHER_SUITE_WEP104;
233         case WPA_ALG_TKIP:
234             return RSN_CIPHER_SUITE_TKIP;
235         case WPA_ALG_CCMP:
236             return RSN_CIPHER_SUITE_CCMP;
237         case WPA_ALG_GCMP:
238             return RSN_CIPHER_SUITE_GCMP;
239         case WPA_ALG_CCMP_256:
240             return RSN_CIPHER_SUITE_CCMP_256;
241         case WPA_ALG_GCMP_256:
242             return RSN_CIPHER_SUITE_GCMP_256;
243         case WPA_ALG_IGTK:
244             return RSN_CIPHER_SUITE_AES_128_CMAC;
245         case WPA_ALG_BIP_GMAC_128:
246             return RSN_CIPHER_SUITE_BIP_GMAC_128;
247         case WPA_ALG_BIP_GMAC_256:
248             return RSN_CIPHER_SUITE_BIP_GMAC_256;
249         case WPA_ALG_BIP_CMAC_256:
250             return RSN_CIPHER_SUITE_BIP_CMAC_256;
251         case WPA_ALG_SMS4:
252             return RSN_CIPHER_SUITE_SMS4;
253         case WPA_ALG_KRK:
254             return RSN_CIPHER_SUITE_KRK;
255         case WPA_ALG_NONE:
256         case WPA_ALG_PMK:
257             return 0;
258         default:
259             return 0;
260     }
261 }
262 
IsBroadcastAddr(const uint8_t *addr)263 static inline int IsBroadcastAddr(const uint8_t *addr)
264 {
265     // 0 1 2 3 4 5 are mac index
266     return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
267 }
268 
WifiWpaInitAlg(WifiKeyExt *keyExt, enum wpa_alg alg, size_t keyLen)269 static void WifiWpaInitAlg(WifiKeyExt *keyExt, enum wpa_alg alg, size_t keyLen)
270 {
271     keyExt->cipher = WifiAlgToCipherSuite(alg, keyLen);
272     if ((alg == WPA_ALG_IGTK) || (alg == WPA_ALG_BIP_GMAC_128) || (alg == WPA_ALG_BIP_GMAC_256) ||
273         (alg == WPA_ALG_BIP_CMAC_256)) {
274         keyExt->defMgmt = TRUE;
275     } else {
276         keyExt->def = TRUE;
277     }
278 }
279 
WifiWpaInitAddr(WifiKeyExt *keyExt, const uint8_t *addr, const enum wpa_alg alg, const int32_t keyIdx, const int32_t setTx)280 static int32_t WifiWpaInitAddr(WifiKeyExt *keyExt, const uint8_t *addr, const enum wpa_alg alg, const int32_t keyIdx,
281     const int32_t setTx)
282 {
283     keyExt->type = WIFI_KEYTYPE_BUTT;
284     keyExt->defaultTypes = WIFI_KEY_DEFAULT_TYPE_INVALID;
285     if (addr != NULL) {
286         if (!IsBroadcastAddr(addr)) {
287             keyExt->addr = (uint8_t *)os_zalloc(ETH_ADDR_LEN);
288             if ((keyExt->addr == NULL) || (memcpy_s(keyExt->addr, ETH_ADDR_LEN, addr, ETH_ADDR_LEN) != EOK)) {
289                 return -EFAIL;
290             }
291             if ((alg != WPA_ALG_WEP) && (keyIdx != 0) && (setTx == 0)) {
292                 keyExt->type = WIFI_KEYTYPE_GROUP;
293             }
294             keyExt->defaultTypes = WIFI_KEY_DEFAULT_TYPE_UNICAST;
295         } else {
296             keyExt->addr = NULL;
297             keyExt->defaultTypes = WIFI_KEY_DEFAULT_TYPE_MULTICAST;
298         }
299     }
300     if (keyExt->type == WIFI_KEYTYPE_BUTT) {
301         keyExt->type = (keyExt->addr != NULL) ? WIFI_KEYTYPE_PAIRWISE : WIFI_KEYTYPE_GROUP;
302     }
303     return SUCC;
304 }
305 
WifiWpaInitSeq(WifiKeyExt *keyExt, const uint8_t *seq, const size_t seqLen)306 static int32_t WifiWpaInitSeq(WifiKeyExt *keyExt, const uint8_t *seq, const size_t seqLen)
307 {
308     keyExt->seqLen = seqLen;
309     if ((seq != NULL) && (seqLen != 0)) {
310         keyExt->seq = (uint8_t *)os_zalloc(seqLen);
311         if ((keyExt->seq == NULL) || (memcpy_s(keyExt->seq, seqLen, seq, seqLen) != EOK)) {
312             return -EFAIL;
313         }
314     }
315     return SUCC;
316 }
317 
WifiWpaInitKey(WifiKeyExt *keyExt, const uint8_t *key, const size_t keyLen, const int32_t keyIdx, const enum wpa_alg alg)318 static int32_t WifiWpaInitKey(WifiKeyExt *keyExt, const uint8_t *key, const size_t keyLen, const int32_t keyIdx,
319     const enum wpa_alg alg)
320 {
321     keyExt->keyLen = keyLen;
322     keyExt->keyIdx = keyIdx;
323     if ((alg != WPA_ALG_NONE) && (key != NULL) && (keyLen != 0)) {
324         keyExt->key = (uint8_t *)os_zalloc(keyLen);
325         if ((keyExt->key == NULL) || (memcpy_s(keyExt->key, keyLen, key, keyLen) != EOK)) {
326             return -EFAIL;
327         }
328     }
329     return SUCC;
330 }
331 
WifiKeyExtFree(WifiKeyExt **key)332 static void WifiKeyExtFree(WifiKeyExt **key)
333 {
334     if (key == NULL || *key == NULL) {
335         return;
336     }
337 
338     if ((*key)->addr != NULL) {
339         os_free((*key)->addr);
340         (*key)->addr = NULL;
341     }
342     if ((*key)->seq != NULL) {
343         os_free((*key)->seq);
344         (*key)->seq = NULL;
345     }
346     if ((*key)->key != NULL) {
347         os_free((*key)->key);
348         (*key)->key = NULL;
349     }
350 
351     os_free(*key);
352     *key = NULL;
353 }
354 
IsApInterface(int32_t mode)355 static inline int32_t IsApInterface(int32_t mode)
356 {
357     return ((mode) == WIFI_IFTYPE_AP || (mode) == WIFI_IFTYPE_P2P_GO);
358 }
359 
WifiWpaSetKey(const char *ifname, void *priv, enum wpa_alg alg, const uint8_t *addr, int32_t keyIdx, int32_t setTx, const uint8_t *seq, size_t seqLen, const uint8_t *key, size_t keyLen)360 static int32_t WifiWpaSetKey(const char *ifname, void *priv, enum wpa_alg alg, const uint8_t *addr, int32_t keyIdx,
361     int32_t setTx, const uint8_t *seq, size_t seqLen, const uint8_t *key, size_t keyLen)
362 {
363     int32_t ret;
364     WifiKeyExt *keyExt = NULL;
365     WifiDriverData *drv = priv;
366 
367     if ((ifname == NULL) || (priv == NULL)) {
368         return -EFAIL;
369     }
370     if (drv->mode == WIFI_IFTYPE_P2P_DEVICE) {
371         return SUCC;
372     }
373 
374     keyExt = os_zalloc(sizeof(WifiKeyExt));
375     if (keyExt == NULL) {
376         return -EFAIL;
377     }
378 
379     WifiWpaInitAlg(keyExt, alg, keyLen);
380     if (WifiWpaInitAddr(keyExt, addr, alg, keyIdx, setTx) != SUCC || WifiWpaInitSeq(keyExt, seq, seqLen) != SUCC ||
381         WifiWpaInitKey(keyExt, key, keyLen, keyIdx, alg) != SUCC) {
382         WifiKeyExtFree(&keyExt);
383         wpa_printf(MSG_ERROR, "WifiWpaInitKey failed");
384         return -EFAIL;
385     }
386 
387     if (alg == WPA_ALG_NONE) {
388         ret = WifiCmdDelKey(ifname, keyExt);
389     } else {
390         ret = WifiCmdNewKey(ifname, keyExt);
391         if ((ret != SUCC) || (setTx == 0) || (alg == WPA_ALG_NONE)) {
392             WifiKeyExtFree(&keyExt);
393             return ret;
394         }
395 
396         if ((IsApInterface(drv->mode)) && (keyExt->addr != NULL) && (!IsBroadcastAddr(keyExt->addr))) {
397             WifiKeyExtFree(&keyExt);
398             return ret;
399         }
400         ret = WifiCmdSetKey(ifname, keyExt);
401     }
402 
403     WifiKeyExtFree(&keyExt);
404     return ret;
405 }
406 
WifiWpaReceiveEapol(void *ctx, const uint8_t *srcAddr, const uint8_t *buf, size_t len)407 static void WifiWpaReceiveEapol(void *ctx, const uint8_t *srcAddr, const uint8_t *buf, size_t len)
408 {
409     WifiDriverData *drv = ctx;
410 
411     if ((ctx == NULL) || (srcAddr == NULL) || (buf == NULL) || (len < sizeof(struct l2_ethhdr))) {
412         return;
413     }
414 
415     drv_event_eapol_rx(drv->ctx, srcAddr, buf + sizeof(struct l2_ethhdr), len - sizeof(struct l2_ethhdr));
416     wpa_printf(MSG_INFO, "WifiWpaReceiveEapol done");
417 }
418 
WifiWpaPreInit(const WifiDriverData *drv)419 static void WifiWpaPreInit(const WifiDriverData *drv)
420 {
421     WifiSetMode setMode;
422     WifiSetNewDev info;
423 
424     if (drv == NULL) {
425         return;
426     }
427 
428     (void)memset_s(&setMode, sizeof(WifiSetMode), 0, sizeof(WifiSetMode));
429     (void)memset_s(&info, sizeof(WifiSetNewDev), 0, sizeof(WifiSetNewDev));
430 
431     if  (strncmp(drv->iface, "p2p-p2p0-", 9) == 0) {
432         info.ifType = WIFI_IFTYPE_P2P_CLIENT;
433         setMode.iftype = WIFI_IFTYPE_P2P_CLIENT;
434     } else if (strncmp(drv->iface, "p2p0", 4) == 0) {
435         info.ifType = WIFI_IFTYPE_P2P_DEVICE;
436         setMode.iftype = WIFI_IFTYPE_P2P_DEVICE;
437     } else {
438         setMode.iftype = WIFI_IFTYPE_STATION;
439         info.status = FALSE;
440         info.ifType = WIFI_IFTYPE_STATION;
441         info.mode = WIFI_PHY_MODE_11N;
442         if (WifiCmdSetNetdev(drv->iface, &info) != SUCC) {
443             wpa_printf(MSG_ERROR, "%s set netdev failed", __func__);
444         }
445         if (WifiCmdSetMode((char *)drv->iface, &setMode) != SUCC) {
446             wpa_printf(MSG_ERROR, "%s set mode failed", __func__);
447         }
448     }
449 }
450 
451 #ifdef CONFIG_OPEN_HARMONY_PATCH
CheckWifiIface(const char *ifName)452 static void CheckWifiIface(const char *ifName)
453 {
454     DIR *dir;
455     struct dirent *dent;
456     while (TRUE) {
457         dir = opendir("/sys/class/net");
458         if (dir == 0) {
459             return;
460         }
461         while ((dent = readdir(dir))) {
462             if (dent->d_name[0] == '.') {
463                 continue;
464             }
465             if (strcmp(dent->d_name, ifName) == 0) {
466                 goto out;
467             }
468             usleep(WAIT_LOAD_NETDEVICE);
469         }
470     }
471 out:
472     closedir(dir);
473 }
474 #endif
475 
WifiWpaDeinit(void *priv)476 static void WifiWpaDeinit(void *priv)
477 {
478     WifiDriverData *drv = NULL;
479     WifiSetNewDev info;
480 
481     if (priv == NULL) {
482         return;
483     }
484 
485     drv = (WifiDriverData *)priv;
486     info.status = FALSE;
487     info.ifType = WIFI_IFTYPE_STATION;
488     info.mode = WIFI_PHY_MODE_11N;
489 #ifdef CONFIG_OHOS_P2P
490     if  (strncmp(drv->iface, "p2p-p2p0-", 9) == 0) {
491         info.ifType = WIFI_IFTYPE_P2P_CLIENT;
492     } else if (strncmp(drv->iface, "p2p0", 4) == 0) {
493         info.ifType = WIFI_IFTYPE_P2P_DEVICE;
494     }
495     WifiDev *wifiDev = NULL;
496     wifiDev = GetWifiDevByName(drv->iface);
497     if (wifiDev == NULL) {
498         wpa_printf(MSG_ERROR, "%s: GetWifiDevByName failed.\r\n.", __FUNCTION__);
499     }
500     FreeWifiDev(wifiDev);
501 #endif // CONFIG_OHOS_P2P
502     eloop_cancel_timeout(WifiWpaScanTimeout, drv, drv->ctx);
503     WifiCmdSetNetdev(drv->iface, &info);
504 
505     if (drv->eapolSock != NULL) {
506         l2_packet_deinit(drv->eapolSock);
507     }
508 
509 #ifdef CONFIG_OHOS_P2P
510     WifiUnregisterEventCallback(OnWpaWiFiEvents, WIFI_KERNEL_TO_WPA_CLIENT, drv->iface);
511     if (CountWifiDevInUse() == 0) {
512         g_msgInit = TRUE;
513         os_free(g_wifiDriverData);
514         g_wifiDriverData = NULL;
515         (void)WifiClientDeinit(drv->iface);
516     }
517 #else
518     os_free(g_wifiDriverData);
519     g_wifiDriverData = NULL;
520     (void)WifiClientDeinit(drv->iface);
521 #endif //CONFIG_OHOS_P2P
522 
523     wpa_printf(MSG_INFO, "WifiWpaDeinit done");
524 }
525 
WifiWpaInit(void *ctx, const char *ifName)526 static void *WifiWpaInit(void *ctx, const char *ifName)
527 {
528     int32_t ret;
529     WifiSetNewDev info;
530 #ifdef CONFIG_OHOS_P2P
531     WifiDev *wifiDev = NULL;
532     errno_t rc;
533 #endif
534 
535     if ((ctx == NULL) || (ifName == NULL)) {
536         return NULL;
537     }
538 
539     wpa_printf(MSG_INFO, "%s enter, interface name:%s.", __FUNCTION__, ifName);
540     (void)memset_s(&info, sizeof(WifiSetNewDev), 0, sizeof(WifiSetNewDev));
541     WifiDriverData *drv = os_zalloc(sizeof(WifiDriverData));
542     if (drv == NULL) {
543         goto failed;
544     }
545 
546     drv->ctx = ctx;
547     if (memcpy_s(drv->iface, sizeof(drv->iface), ifName, sizeof(drv->iface)) != EOK) {
548         goto failed;
549     }
550 #ifdef CONFIG_OHOS_P2P
551     if (g_msgInit && (strncmp(drv->iface, "p2p0", 4) == 0)) {
552         if (WifiClientInit(drv->iface) != SUCC) {
553             goto failed;
554         }
555         g_msgInit = FALSE;
556     }
557 #endif // CONFIG_OHOS_P2P
558     if (strncmp(drv->iface, "wlan0", 5) == 0) {
559         if (WifiClientInit(drv->iface) != SUCC) {
560             goto failed;
561         }
562     }
563 #ifdef CONFIG_OPEN_HARMONY_PATCH
564     CheckWifiIface(ifName);
565 #endif
566     WifiWpaPreInit(drv);
567 
568     info.status = TRUE;
569     info.ifType = WIFI_IFTYPE_STATION;
570     info.mode = WIFI_PHY_MODE_11N;
571 #ifdef CONFIG_OHOS_P2P
572     if  (strncmp(drv->iface, "p2p-p2p0-", 9) == 0) {
573         info.ifType = WIFI_IFTYPE_P2P_CLIENT;
574     } else if (strncmp(drv->iface, "p2p0", 4) == 0) {
575         info.ifType = WIFI_IFTYPE_P2P_DEVICE;
576     }
577 #endif // CONFIG_OHOS_P2P
578     ret = WifiCmdSetNetdev(drv->iface, &info);
579     if (ret != SUCC) {
580         wpa_printf(MSG_ERROR, "WifiWpaInit set netdev faild");
581         goto failed;
582     }
583     drv->eapolSock = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, WifiWpaReceiveEapol, drv, 1);
584     if (drv->eapolSock == NULL) {
585         wpa_printf(MSG_ERROR, "WifiWpaInit l2_packet_init faild");
586         goto failed;
587     }
588 
589     if (l2_packet_get_own_addr(drv->eapolSock, drv->ownAddr)) {
590         wpa_printf(MSG_ERROR, "l2_packet_get_own_addr faild");
591         goto failed;
592     }
593 
594     g_wifiDriverType = WIFI_IFTYPE_STATION;
595 #ifdef CONFIG_OHOS_P2P
596     wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
597     if (wifiDev == NULL) {
598         wpa_printf(MSG_ERROR, "%s wifiDev malloc failed.", __FUNCTION__);
599         goto failed;
600     }
601     wifiDev->priv = drv;
602     wifiDev->ifNameLen = sizeof(ifName);
603     rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), drv->iface, sizeof(drv->iface));
604     if (rc != EOK) {
605         wpa_printf(MSG_ERROR, "%s could not copy wifi device name.", __FUNCTION__);
606         goto failed;
607     }
608     wpa_printf(MSG_ERROR, "%s init done, ifName:%s.", __FUNCTION__, wifiDev->ifName);
609     SetWifiDev(wifiDev);
610 #endif // CONFIG_OHOS_P2P
611     g_wifiDriverData = drv;
612     return drv;
613 
614 failed:
615 #ifdef CONFIG_OHOS_P2P
616     FreeWifiDev(wifiDev);
617 #endif // CONFIG_OHOS_P2P
618     WifiWpaDeinit(drv);
619     return NULL;
620 }
621 
WifiWpaDeauthenticate(void *priv, const uint8_t *addr, uint16_t reasonCode)622 static int32_t WifiWpaDeauthenticate(void *priv, const uint8_t *addr, uint16_t reasonCode)
623 {
624     int32_t ret;
625     WifiDriverData *drv = priv;
626 
627     (void)addr;
628     if (priv == NULL) {
629         return -EFAIL;
630     }
631 
632     wpa_printf(MSG_INFO, "WifiWpaDeauthenticate reasonCode = %d", reasonCode);
633     ret = WifiCmdDisconnet(drv->iface, reasonCode);
634     if (ret == SUCC) {
635         drv->associated = WIFI_DISCONNECT;
636     }
637     return ret;
638 }
639 
WifiWpaDriverAp(WifiDriverData *drv, struct wpa_driver_associate_params *params)640 static int32_t WifiWpaDriverAp(WifiDriverData *drv, struct wpa_driver_associate_params *params)
641 {
642     int32_t ret;
643     WifiSetMode setMode;
644     errno_t rc;
645 
646     if ((drv == NULL) || (params == NULL)) {
647         wpa_printf(MSG_ERROR, "%s input NULL ptr.", __FUNCTION__);
648         return -EFAIL;
649     }
650     rc = memset_s(&setMode, sizeof(WifiSetMode), 0, sizeof(WifiSetMode));
651     if (rc != EOK) {
652         wpa_printf(MSG_ERROR, "%s: memset failed.", __FUNCTION__);
653         return -EFAIL;
654     }
655     if (params->p2p) {
656         wpa_printf(MSG_INFO, "%s: Setup AP operations for P2P group.(GO).", __FUNCTION__);
657         setMode.iftype = WIFI_IFTYPE_P2P_GO;
658     } else {
659         setMode.iftype = WIFI_IFTYPE_AP;
660     }
661     rc = memcpy_s(setMode.bssid, ETH_ADDR_LEN, drv->ownAddr, ETH_ADDR_LEN);
662     if (rc != EOK) {
663         wpa_printf(MSG_ERROR, "%s memcpy failed.", __FUNCTION__);
664         return -EFAIL;
665     }
666     ret = WifiCmdSetMode(drv->iface, &setMode);
667     if (ret != SUCC) {
668         wpa_printf(MSG_ERROR, "%s: set mode failed.", __FUNCTION__);
669         return -EFAIL;
670     }
671     return SUCC;
672 }
673 
WifiWpaAssocParamsSet(WifiDriverData *drv, struct wpa_driver_associate_params *params, WifiAssociateParams *assocParams)674 static int32_t WifiWpaAssocParamsSet(WifiDriverData *drv, struct wpa_driver_associate_params *params,
675     WifiAssociateParams *assocParams)
676 {
677     if (params->bssid != NULL) {
678         assocParams->bssid = (uint8_t *)os_zalloc(ETH_ADDR_LEN);
679         if (assocParams->bssid == NULL) {
680             return -EFAIL;
681         }
682         if (memcpy_s(assocParams->bssid, ETH_ADDR_LEN, params->bssid, ETH_ADDR_LEN) != EOK) {
683             return -EFAIL;
684         }
685     }
686 
687     if (params->freq.freq != 0) {
688         assocParams->freq = params->freq.freq;
689     }
690     if (params->ssid_len > MAX_SSID_LEN) {
691         params->ssid_len = MAX_SSID_LEN;
692     }
693     if ((params->ssid != NULL) && (params->ssid_len != 0)) {
694         assocParams->ssid = (uint8_t *)os_zalloc(params->ssid_len);
695         if (assocParams->ssid == NULL) {
696             return -EFAIL;
697         }
698         assocParams->ssidLen = params->ssid_len;
699         if (memcpy_s(assocParams->ssid, assocParams->ssidLen, params->ssid, params->ssid_len) != EOK) {
700             return -EFAIL;
701         }
702         if (memset_s(drv->ssid, MAX_SSID_LEN, 0, MAX_SSID_LEN) != EOK) {
703             return -EFAIL;
704         }
705         if (memcpy_s(drv->ssid, MAX_SSID_LEN, params->ssid, params->ssid_len) != EOK) {
706             return -EFAIL;
707         }
708         drv->ssidLen = params->ssid_len;
709     }
710 
711     if ((params->wpa_ie != NULL) && (params->wpa_ie_len != 0)) {
712         assocParams->ie = (uint8_t *)os_zalloc(params->wpa_ie_len);
713         if (assocParams->ie == NULL) {
714             return -EFAIL;
715         }
716         assocParams->ieLen = params->wpa_ie_len;
717         if (memcpy_s(assocParams->ie, assocParams->ieLen, params->wpa_ie, params->wpa_ie_len) != EOK) {
718             return -EFAIL;
719         }
720     }
721 
722     return SUCC;
723 }
724 
WifiCipherToCipherSuite(uint32_t cipher)725 static uint32_t WifiCipherToCipherSuite(uint32_t cipher)
726 {
727     switch (cipher) {
728         case WPA_CIPHER_CCMP_256:
729             return RSN_CIPHER_SUITE_CCMP_256;
730         case WPA_CIPHER_GCMP_256:
731             return RSN_CIPHER_SUITE_GCMP_256;
732         case WPA_CIPHER_CCMP:
733             return RSN_CIPHER_SUITE_CCMP;
734         case WPA_CIPHER_GCMP:
735             return RSN_CIPHER_SUITE_GCMP;
736         case WPA_CIPHER_TKIP:
737             return RSN_CIPHER_SUITE_TKIP;
738         case WPA_CIPHER_WEP104:
739             return RSN_CIPHER_SUITE_WEP104;
740         case WPA_CIPHER_WEP40:
741             return RSN_CIPHER_SUITE_WEP40;
742         case WPA_CIPHER_GTK_NOT_USED:
743             return RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED;
744         default:
745             return 0;
746     }
747 }
748 
WifiWpaAssocParamCryptoSet(const struct wpa_driver_associate_params *params, WifiAssociateParams *assocParams)749 static int32_t WifiWpaAssocParamCryptoSet(const struct wpa_driver_associate_params *params,
750     WifiAssociateParams *assocParams)
751 {
752     uint32_t ver = 0;
753     uint32_t akm_suites_num = 0;
754     uint32_t ciphers_pairwise_num = 0;
755     int32_t mgmt = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
756 
757     assocParams->crypto = (WifiCryptoSetting *)os_zalloc(sizeof(WifiCryptoSetting));
758     if (assocParams->crypto == NULL) {
759         return -EFAIL;
760     }
761 
762     if (params->wpa_proto != 0) {
763         if (params->wpa_proto & WPA_PROTO_WPA) {
764             ver |= WPA_VERSION_1;
765         }
766         if (params->wpa_proto & WPA_PROTO_RSN) {
767             ver |= WPA_VERSION_2;
768         }
769         assocParams->crypto->wpaVersions = ver;
770     }
771 
772     if (params->pairwise_suite != WPA_CIPHER_NONE) {
773         assocParams->crypto->ciphersPairwise[ciphers_pairwise_num++] = WifiCipherToCipherSuite(params->pairwise_suite);
774         assocParams->crypto->nCiphersPairwise = ciphers_pairwise_num;
775     }
776 
777     if (params->group_suite != WPA_CIPHER_NONE) {
778         assocParams->crypto->cipherGroup = WifiCipherToCipherSuite(params->group_suite);
779     }
780 
781     if (params->key_mgmt_suite == WPA_KEY_MGMT_PSK || params->key_mgmt_suite == WPA_KEY_MGMT_SAE ||
782         params->key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256) {
783         switch (params->key_mgmt_suite) {
784             case WPA_KEY_MGMT_PSK_SHA256:
785                 mgmt = RSN_AUTH_KEY_MGMT_PSK_SHA256;
786                 break;
787             case WPA_KEY_MGMT_SAE:
788                 mgmt = RSN_AUTH_KEY_MGMT_SAE;
789                 break;
790             case WPA_KEY_MGMT_PSK: /* fall through */
791             default:
792                 mgmt = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
793                 break;
794         }
795         assocParams->crypto->akmSuites[akm_suites_num++] = mgmt;
796         assocParams->crypto->nAkmSuites = akm_suites_num;
797     }
798 
799     return SUCC;
800 }
801 
WifiWpaSetConnKeys(const struct wpa_driver_associate_params *wpa_params, WifiAssociateParams *params)802 static void WifiWpaSetConnKeys(const struct wpa_driver_associate_params *wpa_params, WifiAssociateParams *params)
803 {
804     int32_t loop;
805     uint8_t privacy;
806     errno_t rc;
807 
808     if ((wpa_params == NULL) || (params == NULL)) {
809         return;
810     }
811 
812     privacy = 0;
813     for (loop = 0; loop < WEP_KEY_NUM; loop++) {
814         if (wpa_params->wep_key[loop] == NULL) {
815             continue;
816         }
817         privacy = 1;
818         break;
819     }
820 
821     if ((wpa_params->wps == WPS_MODE_PRIVACY) ||
822         ((wpa_params->pairwise_suite != 0) && (wpa_params->pairwise_suite != WPA_CIPHER_NONE))) {
823         privacy = 1;
824     }
825     if (privacy == 0) {
826         return;
827     }
828     params->privacy = privacy;
829     for (loop = 0; loop < WEP_KEY_NUM; loop++) {
830         if (wpa_params->wep_key[loop] == NULL) {
831             continue;
832         }
833         params->keyLen = wpa_params->wep_key_len[loop];
834         params->key = (uint8_t *)os_zalloc(params->keyLen);
835         if (params->key == NULL) {
836             return;
837         }
838 
839         rc = memcpy_s(params->key, params->keyLen, wpa_params->wep_key[loop], params->keyLen);
840         if (rc != EOK) {
841             os_free(params->key);
842             params->key = NULL;
843             return;
844         }
845         params->keyIdx = wpa_params->wep_tx_keyidx;
846         break;
847     }
848 
849     return;
850 }
851 
WifiWpaConnectFree(WifiAssociateParams **params)852 static void WifiWpaConnectFree(WifiAssociateParams **params)
853 {
854     if (params == NULL || *params == NULL) {
855         return;
856     }
857 
858     if ((*params)->ie != NULL) {
859         os_free((*params)->ie);
860         (*params)->ie = NULL;
861     }
862     if ((*params)->crypto != NULL) {
863         os_free((*params)->crypto);
864         (*params)->crypto = NULL;
865     }
866     if ((*params)->ssid != NULL) {
867         os_free((*params)->ssid);
868         (*params)->ssid = NULL;
869     }
870     if ((*params)->bssid != NULL) {
871         os_free((*params)->bssid);
872         (*params)->bssid = NULL;
873     }
874     if ((*params)->key != NULL) {
875         os_free((*params)->key);
876         (*params)->key = NULL;
877     }
878 
879     os_free(*params);
880     *params = NULL;
881 }
882 
WifiGetStaAuthType(const struct wpa_driver_associate_params *params)883 static WifiAuthType WifiGetStaAuthType(const struct wpa_driver_associate_params *params)
884 {
885     WifiAuthType type = WIFI_AUTHTYPE_BUTT;
886     uint32_t algs = 0;
887 
888     if ((uint32_t)(params->auth_alg) & WPA_AUTH_ALG_OPEN) {
889         type = WIFI_AUTHTYPE_OPEN_SYSTEM;
890         algs++;
891     }
892     if ((uint32_t)(params->auth_alg) & WPA_AUTH_ALG_SHARED) {
893         type = WIFI_AUTHTYPE_SHARED_KEY;
894         algs++;
895     }
896     if ((uint32_t)(params->auth_alg) & WPA_AUTH_ALG_LEAP) {
897         type = WIFI_AUTHTYPE_EAP;
898         algs++;
899     }
900 
901     if (algs > 1) {
902         return WIFI_AUTHTYPE_AUTOMATIC;
903     } else if (algs == 1) {
904         return type;
905     }
906 
907     if ((uint32_t)params->auth_alg & WPA_AUTH_ALG_FT) {
908         type = WIFI_AUTHTYPE_FT;
909     }
910     return type;
911 }
912 
WifiWpaTryConnect(WifiDriverData *drv, struct wpa_driver_associate_params *params)913 static int32_t WifiWpaTryConnect(WifiDriverData *drv, struct wpa_driver_associate_params *params)
914 {
915     WifiAssociateParams *assocParams = NULL;
916     int32_t ret = -EFAIL;
917 
918     if ((drv == NULL) || (params == NULL)) {
919         return -EFAIL;
920     }
921 
922     assocParams = (WifiAssociateParams *)os_zalloc(sizeof(WifiAssociateParams));
923     if (assocParams == NULL) {
924         return ret;
925     }
926     if (WifiWpaAssocParamsSet(drv, params, assocParams) != SUCC) {
927         wpa_printf(MSG_ERROR, "WifiWpaTryConnect set assoc params faild");
928         goto skip_auth_type;
929     }
930     if (WifiWpaAssocParamCryptoSet(params, assocParams) != SUCC) {
931         wpa_printf(MSG_ERROR, "WifiWpaTryConnect set assoc crypto faild");
932         goto skip_auth_type;
933     }
934     assocParams->mfp = params->mgmt_frame_protection;
935     assocParams->authType = WifiGetStaAuthType(params);
936 
937     WifiWpaSetConnKeys(params, assocParams);
938     ret = WifiCmdAssoc(drv->iface, assocParams);
939     if (ret != SUCC) {
940         wpa_printf(MSG_ERROR, "WifiWpaTryConnect assoc faild");
941     }
942 
943 skip_auth_type:
944     WifiWpaConnectFree(&assocParams);
945     return ret;
946 }
947 
WifiWpaDisconnet(WifiDriverData *drv, uint16_t reasonCode)948 static int32_t WifiWpaDisconnet(WifiDriverData *drv, uint16_t reasonCode)
949 {
950     int32_t ret;
951 
952     if (drv == NULL) {
953         return -EFAIL;
954     }
955     ret = WifiCmdDisconnet(drv->iface, reasonCode);
956     if (ret == SUCC) {
957         drv->associated = WIFI_DISCONNECT;
958     }
959     wpa_printf(MSG_INFO, "WifiWpaDisconnet done ret=%d", ret);
960     return ret;
961 }
WifiWpaAssociate(void *priv, struct wpa_driver_associate_params *params)962 static int WifiWpaAssociate(void *priv, struct wpa_driver_associate_params *params)
963 {
964     int ret;
965     WifiDriverData *drv = priv;
966 
967     if ((drv == NULL) || (params == NULL)) {
968         return -EFAIL;
969     }
970 #ifdef CONFIG_OHOS_P2P
971     if (params->mode == IEEE80211_MODE_AP) {
972         return WifiWpaDriverAp(drv, params);
973     }
974 #endif
975     ret = WifiWpaTryConnect(drv, params);
976     if (ret != SUCC) {
977         if (WifiWpaDisconnet(drv, WLAN_REASON_PREV_AUTH_NOT_VALID)) {
978             return -EFAIL;
979         }
980         ret = WifiWpaTryConnect(drv, params);
981     }
982     wpa_printf(MSG_INFO, "WifiWpaAssociate done ret=%d", ret);
983     return ret;
984 }
985 
WifiWpaGetMacAddr(void *priv)986 static const uint8_t *WifiWpaGetMacAddr(void *priv)
987 {
988     WifiDriverData *drv = priv;
989 
990     if (priv == NULL) {
991         return NULL;
992     }
993     return drv->ownAddr;
994 }
995 
WifiWpaWpaSendEapol(void *priv, const uint8_t *dest, uint16_t proto, const uint8_t *data, size_t dataLen)996 int32_t WifiWpaWpaSendEapol(void *priv, const uint8_t *dest, uint16_t proto, const uint8_t *data, size_t dataLen)
997 {
998     WifiDriverData *drv = priv;
999     int32_t ret;
1000     uint32_t frameLen;
1001     uint8_t *frame = NULL;
1002     uint8_t *payload = NULL;
1003     struct l2_ethhdr *l2_ethhdr = NULL;
1004     errno_t rc;
1005 
1006     if ((priv == NULL) || (data == NULL) || (dest == NULL)) {
1007         return -EFAIL;
1008     }
1009 
1010     frameLen = dataLen + sizeof(struct l2_ethhdr);
1011     frame = os_zalloc(frameLen);
1012     if (frame == NULL) {
1013         return -EFAIL;
1014     }
1015 
1016     l2_ethhdr = (struct l2_ethhdr *)frame;
1017     rc = memcpy_s(l2_ethhdr->h_dest, ETH_ADDR_LEN, dest, ETH_ADDR_LEN);
1018     if (rc != EOK) {
1019         os_free(frame);
1020         frame = NULL;
1021         return -EFAIL;
1022     }
1023     rc = memcpy_s(l2_ethhdr->h_source, ETH_ADDR_LEN, drv->ownAddr, ETH_ADDR_LEN);
1024     if (rc != EOK) {
1025         os_free(frame);
1026         frame = NULL;
1027         return -EFAIL;
1028     }
1029     l2_ethhdr->h_proto = host_to_be16(proto);
1030 
1031     payload = (uint8_t *)(l2_ethhdr + 1);
1032     rc = memcpy_s(payload, dataLen, data, dataLen);
1033     if (rc != EOK) {
1034         os_free(frame);
1035         frame = NULL;
1036         return -EFAIL;
1037     }
1038     ret = l2_packet_send(drv->eapolSock, dest, host_to_be16(proto), frame, frameLen);
1039     os_free(frame);
1040     frame = NULL;
1041     wpa_printf(MSG_INFO, "WifiWpaWpaSendEapol done ret=%d", ret);
1042     return ret;
1043 }
1044 
WifiWpaHwFeatureDataFree(struct hostapd_hw_modes **modes, uint16_t num)1045 static void WifiWpaHwFeatureDataFree(struct hostapd_hw_modes **modes, uint16_t num)
1046 {
1047     uint16_t loop;
1048 
1049     if (modes == NULL || *modes == NULL) {
1050         return;
1051     }
1052     for (loop = 0; loop < num; ++loop) {
1053         if ((*modes)[loop].channels != NULL) {
1054             os_free((*modes)[loop].channels);
1055             (*modes)[loop].channels = NULL;
1056         }
1057         if ((*modes)[loop].rates != NULL) {
1058             os_free((*modes)[loop].rates);
1059             (*modes)[loop].rates = NULL;
1060         }
1061     }
1062     os_free(*modes);
1063     *modes = NULL;
1064 }
1065 
WifiWpaGetHwFeatureData(void *priv, uint16_t *numModes, uint16_t *flags, uint8_t *dfs)1066 static struct hostapd_hw_modes *WifiWpaGetHwFeatureData(void *priv, uint16_t *numModes, uint16_t *flags, uint8_t *dfs)
1067 {
1068     WifiModes modesData[] = {{IEEE80211G_RATES_NUM, HOSTAPD_MODE_IEEE80211G},
1069         {IEEE80211B_RATES_NUM, HOSTAPD_MODE_IEEE80211B}, {IEEE80211A_RATES_NUM, HOSTAPD_MODE_IEEE80211A}};
1070     size_t loop;
1071     uint32_t index;
1072     uint32_t iee80211band;
1073     WifiHwFeatureData hwFeatureData;
1074     WifiDriverData *drv = (WifiDriverData *)priv;
1075     (void)dfs;
1076     if ((priv == NULL) || (numModes == NULL) || (flags == NULL)) {
1077         return NULL;
1078     }
1079     (void)memset_s(&hwFeatureData, sizeof(WifiHwFeatureData), 0, sizeof(WifiHwFeatureData));
1080     *numModes = DEFAULT_NUM_MODES;
1081     *flags = 0;
1082 
1083     if (WifiCmdGetHwFeature(drv->iface, &hwFeatureData) != SUCC) {
1084         return NULL;
1085     }
1086     if (hwFeatureData.bands[IEEE80211_BAND_5GHZ].channelNum != 0) {
1087         *numModes = sizeof(modesData) / sizeof(WifiModes);
1088     }
1089     struct hostapd_hw_modes *modes = os_calloc(*numModes, sizeof(struct hostapd_hw_modes));
1090     if (modes == NULL) {
1091         return NULL;
1092     }
1093 
1094     for (loop = 0; loop < *numModes; ++loop) {
1095         modes[loop].channels = NULL;
1096         modes[loop].rates = NULL;
1097     }
1098 
1099     modes[0].ht_capab = hwFeatureData.htCapab;
1100     iee80211band = IEEE80211_BAND_2GHZ;
1101     for (index = 0; index < *numModes; index++) {
1102         if (index >= DEFAULT_NUM_MODES) {
1103             iee80211band = IEEE80211_BAND_5GHZ;
1104         }
1105         modes[index].mode = modesData[index].mode;
1106         modes[index].num_channels = hwFeatureData.bands[iee80211band].channelNum;
1107         modes[index].num_rates = modesData[index].numRates;
1108         modes[index].channels = os_calloc(hwFeatureData.bands[iee80211band].channelNum, sizeof(struct hostapd_channel_data));
1109         modes[index].rates = os_calloc(modes[index].num_rates, sizeof(uint32_t));
1110         if ((modes[index].channels == NULL) || (modes[index].rates == NULL)) {
1111             WifiWpaHwFeatureDataFree(&modes, *numModes);
1112             return NULL;
1113         }
1114 
1115         for (loop = 0; loop < (size_t)hwFeatureData.bands[iee80211band].channelNum; loop++) {
1116             modes[index].channels[loop].chan = hwFeatureData.bands[iee80211band].iee80211Channel[loop].channel;
1117             modes[index].channels[loop].freq = hwFeatureData.bands[iee80211band].iee80211Channel[loop].freq;
1118             modes[index].channels[loop].flag = hwFeatureData.bands[iee80211band].iee80211Channel[loop].flags;
1119             modes[index].channels[loop].allowed_bw = HOSTAPD_CHAN_WIDTH_20 | HOSTAPD_CHAN_WIDTH_10;
1120         }
1121 
1122         for (loop = 0; loop < (size_t)modes[index].num_rates; loop++) {
1123             if (index < DEFAULT_NUM_MODES) {
1124                 modes[index].rates[loop] = hwFeatureData.bitrate[loop];
1125             } else {
1126                 modes[index].rates[loop] = hwFeatureData.bitrate[loop + IEEE80211B_RATES_NUM];
1127             }
1128         }
1129     }
1130 
1131     wpa_printf(MSG_INFO, "WifiWpaGetHwFeatureData done");
1132     return modes;
1133 }
1134 
WifiWpaSendMlme(void *priv, const uint8_t *data, size_t dataLen, int32_t noack, uint32_t freq, const uint16_t *csaOffs, size_t csaOffsLen)1135 static int32_t WifiWpaSendMlme(void *priv, const uint8_t *data, size_t dataLen, int32_t noack, uint32_t freq,
1136     const uint16_t *csaOffs, size_t csaOffsLen)
1137 {
1138     int32_t ret;
1139     WifiDriverData *drv = priv;
1140     WifiMlmeData *mlme = NULL;
1141     errno_t rc;
1142 
1143     (void)freq;
1144     (void)csaOffs;
1145     (void)csaOffsLen;
1146     (void)noack;
1147     if ((priv == NULL) || (data == NULL)) {
1148         return -EFAIL;
1149     }
1150     mlme = os_zalloc(sizeof(WifiMlmeData));
1151     if (mlme == NULL) {
1152         return -EFAIL;
1153     }
1154     mlme->data = NULL;
1155     mlme->dataLen = dataLen;
1156     mlme->cookie = &(drv->actionCookie);
1157     if ((data != NULL) && (dataLen != 0)) {
1158         mlme->data = (uint8_t *)os_zalloc(dataLen);
1159         if (mlme->data == NULL) {
1160             os_free(mlme);
1161             mlme = NULL;
1162             return -EFAIL;
1163         }
1164         rc = memcpy_s(mlme->data, dataLen, data, dataLen);
1165         if (rc != EOK) {
1166             os_free(mlme->data);
1167             mlme->data = NULL;
1168             os_free(mlme);
1169             return -EFAIL;
1170         }
1171     }
1172     ret = WifiCmdSendMlme(drv->iface, mlme);
1173     os_free(mlme->data);
1174     mlme->data = NULL;
1175     os_free(mlme);
1176     if (ret != SUCC) {
1177         ret = -EFAIL;
1178     }
1179     wpa_printf(MSG_INFO, "WifiWpaSendMlme done ret=%d", ret);
1180     return ret;
1181 }
1182 
WifiWpaGetScanResults2(void *priv)1183 static struct wpa_scan_results *WifiWpaGetScanResults2(void *priv)
1184 {
1185     struct wpa_scan_results *results = NULL;
1186     WifiDriverData *drv = priv;
1187     uint32_t loop;
1188     errno_t rc;
1189 
1190     if (priv == NULL) {
1191         return NULL;
1192     }
1193 
1194     results = (struct wpa_scan_results *)os_zalloc(sizeof(struct wpa_scan_results));
1195     if (results == NULL) {
1196         return NULL;
1197     }
1198 
1199     results->num = drv->scanNum;
1200     if (results->num == 0) {
1201         return results;
1202     }
1203     results->res = (struct wpa_scan_res **)os_zalloc(results->num * sizeof(struct wpa_scan_res *));
1204     if (results->res == NULL) {
1205         os_free(results);
1206         results = NULL;
1207         return NULL;
1208     }
1209     rc = memcpy_s(results->res, results->num * sizeof(struct wpa_scan_res *), drv->scanRes,
1210         results->num * sizeof(struct wpa_scan_res *));
1211     if (rc != EOK) {
1212         os_free(results->res);
1213         os_free(results);
1214         results = NULL;
1215         return NULL;
1216     }
1217     drv->scanNum = 0;
1218     for (loop = 0; loop < SCAN_AP_LIMIT; loop++) {
1219         drv->scanRes[loop] = NULL;
1220     }
1221     wpa_printf(MSG_INFO, "WifiWpaGetScanResults2 done");
1222     return results;
1223 }
1224 
WifiWpaInit2(void *ctx, const char *ifname, void *globalPriv)1225 static void *WifiWpaInit2(void *ctx, const char *ifname, void *globalPriv)
1226 {
1227     (void)globalPriv;
1228     return WifiWpaInit(ctx, ifname);
1229 }
1230 
WifiWpaScanProcessSsid(struct wpa_driver_scan_params *params, WifiScan *scan)1231 static int32_t WifiWpaScanProcessSsid(struct wpa_driver_scan_params *params, WifiScan *scan)
1232 {
1233     errno_t rc;
1234     size_t loop;
1235     if (params->num_ssids == 0) {
1236         return SUCC;
1237     }
1238 
1239     scan->numSsids = params->num_ssids;
1240     scan->ssids = (WifiDriverScanSsid *)os_zalloc(sizeof(WifiDriverScanSsid) * params->num_ssids);
1241     if (scan->ssids == NULL) {
1242         return -EFAIL;
1243     }
1244 
1245     for (loop = 0; (loop < params->num_ssids) && (loop < WPAS_MAX_SCAN_SSIDS); loop++) {
1246         wpa_printf(MSG_INFO, "WIFI: Scan : %s SSID : %zu\n", params->ssids[loop].ssid, params->ssids[loop].ssid_len);
1247 
1248         if (params->ssids[loop].ssid_len > MAX_SSID_LEN) {
1249             params->ssids[loop].ssid_len = MAX_SSID_LEN;
1250         }
1251         if (params->ssids[loop].ssid_len) {
1252             rc = memcpy_s(scan->ssids[loop].ssid, MAX_SSID_LEN, params->ssids[loop].ssid, params->ssids[loop].ssid_len);
1253             if (rc != EOK) {
1254                 return -EFAIL;
1255             }
1256         }
1257         scan->ssids[loop].ssidLen = params->ssids[loop].ssid_len;
1258     }
1259 
1260     return SUCC;
1261 }
1262 
WifiWpaScanProcessBssid(const struct wpa_driver_scan_params *params, WifiScan *scan)1263 static int32_t WifiWpaScanProcessBssid(const struct wpa_driver_scan_params *params, WifiScan *scan)
1264 {
1265     errno_t rc;
1266     if (params->bssid != NULL) {
1267         scan->bssid = (uint8_t *)os_zalloc(ETH_ADDR_LEN);
1268         if (scan->bssid == NULL) {
1269             return -EFAIL;
1270         }
1271         rc = memcpy_s(scan->bssid, ETH_ADDR_LEN, params->bssid, ETH_ADDR_LEN);
1272         if (rc != EOK) {
1273             return -EFAIL;
1274         }
1275     }
1276     return SUCC;
1277 }
1278 
WifiWpaScanProcessExtraIes(const struct wpa_driver_scan_params *params, WifiScan *scan)1279 static int32_t WifiWpaScanProcessExtraIes(const struct wpa_driver_scan_params *params, WifiScan *scan)
1280 {
1281     errno_t rc;
1282     if ((params->extra_ies != NULL) && (params->extra_ies_len != 0)) {
1283         scan->extraIes = (uint8_t *)os_zalloc(params->extra_ies_len);
1284         if (scan->extraIes == NULL) {
1285             return -EFAIL;
1286         }
1287 
1288         rc = memcpy_s(scan->extraIes, params->extra_ies_len, params->extra_ies, params->extra_ies_len);
1289         if (rc != EOK) {
1290             return -EFAIL;
1291         }
1292         scan->extraIesLen = params->extra_ies_len;
1293     }
1294     return SUCC;
1295 }
1296 
WifiWpaScanProcessFreq(const struct wpa_driver_scan_params *params, WifiScan *scan)1297 static int32_t WifiWpaScanProcessFreq(const struct wpa_driver_scan_params *params, WifiScan *scan)
1298 {
1299     uint32_t numFreqs;
1300     int32_t *freqs = NULL;
1301     errno_t rc;
1302 
1303     if (params->freqs != NULL) {
1304         numFreqs = 0;
1305         for (freqs = params->freqs; *freqs != 0; freqs++) {
1306             numFreqs++;
1307             if (numFreqs > 14) { // 14 is 2.4G channel num
1308                 return -EFAIL;
1309             }
1310         }
1311 
1312         scan->numFreqs = numFreqs;
1313         scan->freqs = (int32_t *)os_zalloc(numFreqs * (sizeof(int32_t)));
1314         if (scan->freqs == NULL) {
1315             return -EFAIL;
1316         }
1317         rc = memcpy_s(scan->freqs, numFreqs * (sizeof(int32_t)), params->freqs, numFreqs * (sizeof(int32_t)));
1318         if (rc != EOK) {
1319             return -EFAIL;
1320         }
1321     }
1322     return SUCC;
1323 }
1324 
WifiWpaScanFree(WifiScan **scan)1325 static void WifiWpaScanFree(WifiScan **scan)
1326 {
1327     if (scan == NULL || *scan == NULL) {
1328         return;
1329     }
1330 
1331     if ((*scan)->ssids != NULL) {
1332         os_free((*scan)->ssids);
1333         (*scan)->ssids = NULL;
1334     }
1335     if ((*scan)->bssid != NULL) {
1336         os_free((*scan)->bssid);
1337         (*scan)->bssid = NULL;
1338     }
1339 
1340     if ((*scan)->extraIes != NULL) {
1341         os_free((*scan)->extraIes);
1342         (*scan)->extraIes = NULL;
1343     }
1344 
1345     if ((*scan)->freqs != NULL) {
1346         os_free((*scan)->freqs);
1347         (*scan)->freqs = NULL;
1348     }
1349 
1350     os_free(*scan);
1351     *scan = NULL;
1352 }
1353 
WifiWpaScanTimeout(void *eloop, void *ctx)1354 void WifiWpaScanTimeout(void *eloop, void *ctx)
1355 {
1356     (void)eloop;
1357     if (ctx == NULL) {
1358         return;
1359     }
1360     wpa_supplicant_event(ctx, EVENT_SCAN_RESULTS, NULL);
1361 }
1362 
WifiWpaScan2(void *priv, struct wpa_driver_scan_params *params)1363 static int32_t WifiWpaScan2(void *priv, struct wpa_driver_scan_params *params)
1364 {
1365     WifiScan *scan = NULL;
1366     WifiDriverData *drv = NULL;
1367     int32_t timeout;
1368     int32_t ret;
1369 
1370     if ((priv == NULL) || (params == NULL) || (params->num_ssids > WPAS_MAX_SCAN_SSIDS)) {
1371         return -EFAIL;
1372     }
1373     drv = (WifiDriverData *)priv;
1374     scan = (WifiScan *)os_zalloc(sizeof(WifiScan));
1375     if (scan == NULL) {
1376         return -EFAIL;
1377     }
1378     if ((WifiWpaScanProcessSsid(params, scan) != SUCC) || (WifiWpaScanProcessBssid(params, scan) != SUCC) ||
1379         (WifiWpaScanProcessExtraIes(params, scan) != SUCC) || (WifiWpaScanProcessFreq(params, scan) != SUCC)) {
1380         WifiWpaScanFree(&scan);
1381         return -EFAIL;
1382     }
1383 
1384     scan->fastConnectFlag = WPA_FLAG_OFF;
1385     scan->prefixSsidScanFlag = WPA_FLAG_OFF;
1386     ret = WifiCmdScan(drv->iface, scan);
1387     WifiWpaScanFree(&scan);
1388 
1389     timeout = SCAN_TIME_OUT;
1390     eloop_cancel_timeout(WifiWpaScanTimeout, drv, drv->ctx);
1391     eloop_register_timeout(timeout, 0, WifiWpaScanTimeout, drv, drv->ctx);
1392 
1393     return ret;
1394 }
1395 
WifiSetApFreq(WifiApSetting *apsettings, const struct wpa_driver_ap_params *params)1396 static void WifiSetApFreq(WifiApSetting *apsettings, const struct wpa_driver_ap_params *params)
1397 {
1398     if (params->freq != NULL) {
1399         apsettings->freqParams.mode = params->freq->mode;
1400         apsettings->freqParams.freq = params->freq->freq;
1401         apsettings->freqParams.channel = params->freq->channel;
1402         apsettings->freqParams.htEnabled = params->freq->ht_enabled;
1403         apsettings->freqParams.secChannelOffset = params->freq->sec_channel_offset;
1404         apsettings->freqParams.centerFreq1 = params->freq->center_freq1;
1405         apsettings->freqParams.bandwidth = params->freq->bandwidth;
1406         if (params->freq->bandwidth == WPA_BANDWIDTH_20) {
1407             apsettings->freqParams.bandwidth = WIFI_CHAN_WIDTH_20;
1408         } else {
1409             apsettings->freqParams.bandwidth = WIFI_CHAN_WIDTH_40;
1410         }
1411     }
1412 }
1413 
WifiSetApBand(WifiApSetting *apsettings, struct hostapd_data *hapd)1414 static void WifiSetApBand(WifiApSetting *apsettings, struct hostapd_data *hapd)
1415 {
1416     if ((apsettings!= NULL) && (hapd!= NULL)) {
1417         switch (hapd->conf->wps_rf_bands) {
1418             case WPS_RF_24GHZ:
1419                 apsettings->freqParams.band = IEEE80211_BAND_2GHZ;
1420                 break;
1421             case WPS_RF_50GHZ:
1422                 apsettings->freqParams.band = IEEE80211_BAND_5GHZ;
1423                 break;
1424             default:
1425                 apsettings->freqParams.band = IEEE80211_BAND_2GHZ;
1426                 break;
1427         }
1428     }
1429 }
1430 
WifiSetApBeaconData(WifiApSetting *apsettings, const struct wpa_driver_ap_params *params)1431 static int WifiSetApBeaconData(WifiApSetting *apsettings, const struct wpa_driver_ap_params *params)
1432 {
1433     if ((params->head != NULL) && (params->head_len != 0)) {
1434         apsettings->beaconData.headLen = params->head_len;
1435         apsettings->beaconData.head = (uint8_t *)os_zalloc(apsettings->beaconData.headLen);
1436         if (apsettings->beaconData.head == NULL) {
1437             return -EFAIL;
1438         }
1439         if (memcpy_s(apsettings->beaconData.head, apsettings->beaconData.headLen, params->head, params->head_len) !=
1440             EOK) {
1441             return -EFAIL;
1442         }
1443     }
1444 
1445     if ((params->tail != NULL) && (params->tail_len != 0)) {
1446         apsettings->beaconData.tailLen = params->tail_len;
1447         apsettings->beaconData.tail = (uint8_t *)os_zalloc(apsettings->beaconData.tailLen);
1448         if (apsettings->beaconData.tail == NULL) {
1449             return -EFAIL;
1450         }
1451         if (memcpy_s(apsettings->beaconData.tail, apsettings->beaconData.tailLen, params->tail, params->tail_len) !=
1452             EOK) {
1453             return -EFAIL;
1454         }
1455     }
1456     return SUCC;
1457 }
1458 
WifiApSettingsFree(WifiApSetting **apsettings)1459 static void WifiApSettingsFree(WifiApSetting **apsettings)
1460 {
1461     if (apsettings == NULL || *apsettings == NULL) {
1462         return;
1463     }
1464 
1465     if ((*apsettings)->meshSsid != NULL) {
1466         os_free((*apsettings)->meshSsid);
1467         (*apsettings)->meshSsid = NULL;
1468     }
1469 
1470     if ((*apsettings)->ssid != NULL) {
1471         os_free((*apsettings)->ssid);
1472         (*apsettings)->ssid = NULL;
1473     }
1474 
1475     if ((*apsettings)->beaconData.head != NULL) {
1476         os_free((*apsettings)->beaconData.head);
1477         (*apsettings)->beaconData.head = NULL;
1478     }
1479 
1480     if ((*apsettings)->beaconData.tail != NULL) {
1481         os_free((*apsettings)->beaconData.tail);
1482         (*apsettings)->beaconData.tail = NULL;
1483     }
1484 
1485     os_free(*apsettings);
1486     *apsettings = NULL;
1487 }
1488 
WifiGetApAuthType(const struct wpa_driver_ap_params *params)1489 static WifiAuthType WifiGetApAuthType(const struct wpa_driver_ap_params *params)
1490 {
1491     WifiAuthType type;
1492 
1493     if ((params->auth_algs & (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) == (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) {
1494         type = WIFI_AUTHTYPE_AUTOMATIC;
1495     } else if ((params->auth_algs & WPA_AUTH_ALG_SHARED) == WPA_AUTH_ALG_SHARED) {
1496         type = WIFI_AUTHTYPE_SHARED_KEY;
1497     } else {
1498         type = WIFI_AUTHTYPE_OPEN_SYSTEM;
1499     }
1500     return type;
1501 }
1502 
WifiWpaSetAp(void *priv, struct wpa_driver_ap_params *params)1503 static int32_t WifiWpaSetAp(void *priv, struct wpa_driver_ap_params *params)
1504 {
1505     int32_t ret;
1506     WifiApSetting *apsettings = NULL;
1507     WifiDriverData *drv = (WifiDriverData *)priv;
1508     if ((priv == NULL) || (params == NULL) || (params->freq == NULL)) {
1509         return -EFAIL;
1510     }
1511     if ((params->freq->bandwidth != WPA_BANDWIDTH_20) && (params->freq->bandwidth != WPA_BANDWIDTH_40)) {
1512         return -EFAIL;
1513     }
1514 
1515     apsettings = os_zalloc(sizeof(WifiApSetting));
1516     if (apsettings == NULL) {
1517         return -EFAIL;
1518     }
1519     apsettings->beaconInterval = params->beacon_int;
1520     apsettings->dtimPeriod = params->dtim_period;
1521     apsettings->hiddenSsid = params->hide_ssid;
1522     apsettings->authType = WifiGetApAuthType(params);
1523 
1524     if ((params->ssid != NULL) && (params->ssid_len != 0)) {
1525         apsettings->ssidLen = params->ssid_len;
1526         apsettings->ssid = (uint8_t *)os_zalloc(apsettings->ssidLen);
1527         if ((apsettings->ssid == NULL) ||
1528             (memcpy_s(apsettings->ssid, apsettings->ssidLen, params->ssid, params->ssid_len) != EOK)) {
1529             goto failed;
1530         }
1531     }
1532     WifiSetApFreq(apsettings, params);
1533     WifiSetApBand(apsettings, drv->hapd);
1534     if (WifiSetApBeaconData(apsettings, params) != SUCC) {
1535         goto failed;
1536     }
1537     if (drv->beaconSet == TRUE) {
1538         ret = WifiCmdChangeBeacon(drv->iface, apsettings);
1539     } else {
1540         ret = WifiCmdSetAp(drv->iface, apsettings);
1541     }
1542     if (ret == SUCC) {
1543         drv->beaconSet = TRUE;
1544     }
1545     WifiApSettingsFree(&apsettings);
1546     wpa_printf(MSG_INFO, "WifiWpaGetScanResults2 done ret=%d", ret);
1547     return ret;
1548 
1549 failed:
1550     WifiApSettingsFree(&apsettings);
1551     return -EFAIL;
1552 }
1553 
WifiHapdPreInit(const WifiDriverData *drv)1554 static void WifiHapdPreInit(const WifiDriverData *drv)
1555 {
1556     WifiSetNewDev info;
1557 
1558     if (drv == NULL) {
1559         return;
1560     }
1561     info.status = FALSE;
1562     info.ifType = WIFI_IFTYPE_STATION;
1563     info.mode = WIFI_PHY_MODE_11N;
1564     int ret = WifiCmdSetNetdev(drv->iface, &info);
1565 
1566     if (ret != SUCC) {
1567         wpa_printf(MSG_ERROR, "%s set netdev failed ret = %d.", __func__, ret);
1568     }
1569 }
1570 
WifiDrvInit(void *ctx, const struct wpa_init_params *params)1571 static WifiDriverData *WifiDrvInit(void *ctx, const struct wpa_init_params *params)
1572 {
1573     WifiDriverData *drv = NULL;
1574     errno_t rc;
1575     WifiSetNewDev info;
1576     WifiSetMode setMode;
1577     int32_t ret;
1578 #ifdef CONFIG_OHOS_P2P
1579     WifiDev *wifiDev = NULL;
1580 #endif
1581     if ((ctx == NULL) || (params == NULL)) {
1582         return NULL;
1583     }
1584     drv = os_zalloc(sizeof(WifiDriverData));
1585     if (drv == NULL) {
1586         goto failed;
1587     }
1588 
1589     drv->ctx = ctx;
1590     rc = memcpy_s(drv->iface, sizeof(drv->iface), params->ifname, sizeof(drv->iface));
1591     if (rc != EOK) {
1592         os_free(drv);
1593         drv = NULL;
1594         goto failed;
1595     }
1596 #ifdef CONFIG_OHOS_P2P
1597     wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
1598     if (wifiDev == NULL)
1599     {
1600         wpa_printf(MSG_ERROR, "%s wifiDev malloc failed.", __FUNCTION__);
1601         goto failed;
1602     }
1603     wifiDev->priv = drv;
1604     wifiDev->ifNameLen = sizeof(params->ifname);
1605     rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), drv->iface, sizeof(drv->iface));
1606     if (rc != EOK) {
1607         wpa_printf(MSG_ERROR, "%s wifiDev could not copy interface name.", __FUNCTION__);
1608         goto failed;
1609     }
1610     wpa_printf(MSG_INFO, "%s init, interface name:%s.", __FUNCTION__, wifiDev->ifName);
1611     SetWifiDev(wifiDev);
1612 #endif // CONFIG_OHOS_P2P
1613     WifiHapdPreInit(drv);
1614 
1615     setMode.iftype = WIFI_IFTYPE_AP;
1616     ret = WifiCmdSetMode(drv->iface, &setMode);
1617     if (ret != SUCC) {
1618         wpa_printf(MSG_ERROR, "WifiWpaHapdInit set mode failed, iface = %s, ret = %d.", drv->iface, ret);
1619         goto failed;
1620     }
1621     info.status = TRUE;
1622     info.ifType = WIFI_IFTYPE_AP;
1623     info.mode = WIFI_PHY_MODE_11N;
1624     ret = WifiCmdSetNetdev(drv->iface, &info);
1625     if (ret != SUCC) {
1626         wpa_printf(MSG_ERROR, "WifiDrvInit set netdev failed");
1627         goto failed;
1628     }
1629     wpa_printf(MSG_INFO, "WifiDrvInit done");
1630     return drv;
1631 
1632 failed:
1633     if (drv != NULL) {
1634         info.status = FALSE;
1635         info.ifType = WIFI_IFTYPE_STATION;
1636         info.mode = WIFI_PHY_MODE_11N;
1637         WifiCmdSetNetdev(drv->iface, &info);
1638         os_free(drv);
1639         drv = NULL;
1640     }
1641 #ifdef CONFIG_OHOS_P2P
1642     FreeWifiDev(wifiDev);
1643 #endif // CONFIG_OHOS_P2P
1644     return NULL;
1645 }
1646 
WifiWpaInitl2(struct wpa_init_params *params, WifiDriverData *drv)1647 static int32_t WifiWpaInitl2(struct wpa_init_params *params, WifiDriverData *drv)
1648 {
1649     int32_t ret;
1650     uint8_t addrTmp[ETH_ADDR_LEN] = {0};
1651 
1652     drv->eapolSock = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, WifiWpaReceiveEapol, drv, 1);
1653     if (drv->eapolSock == NULL) {
1654         wpa_printf(MSG_ERROR, "WifiDrvInit l2 packet init failed");
1655         return -EFAIL;
1656     }
1657     if (l2_packet_get_own_addr(drv->eapolSock, addrTmp)) {
1658         return -EFAIL;
1659     }
1660     ret = memcpy_s(params->own_addr, ETH_ADDR_LEN, addrTmp, ETH_ADDR_LEN);
1661     if (ret != EOK) {
1662         return -EFAIL;
1663     }
1664     ret = memcpy_s(drv->ownAddr, ETH_ADDR_LEN, addrTmp, ETH_ADDR_LEN);
1665     if (ret != EOK) {
1666         return -EFAIL;
1667     }
1668     return SUCC;
1669 }
1670 
WifiWpaHapdInit(struct hostapd_data *hapd, struct wpa_init_params *params)1671 static void *WifiWpaHapdInit(struct hostapd_data *hapd, struct wpa_init_params *params)
1672 {
1673     WifiDriverData *drv = NULL;
1674 
1675     int32_t ret;
1676 
1677     if ((hapd == NULL) || (params == NULL) || (hapd->conf == NULL)) {
1678         return NULL;
1679     }
1680 
1681     if (WifiClientInit(params->ifname) != SUCC) {
1682         wpa_printf(MSG_ERROR, "Wifi client init failed");
1683         return NULL;
1684     }
1685     drv = WifiDrvInit(hapd, params);
1686     if (drv == NULL) {
1687         wpa_printf(MSG_ERROR, "WifiWpaHapdInit drv init failed");
1688         goto failed;
1689     }
1690     drv->hapd = hapd;
1691 
1692     ret = WifiWpaInitl2(params, drv);
1693     if (ret != SUCC) {
1694         wpa_printf(MSG_ERROR, "WifiWpaInitI2 failed");
1695         goto failed;
1696     }
1697 
1698     g_wifiDriverData = drv;
1699     g_wifiDriverType = WIFI_IFTYPE_AP;
1700     wpa_printf(MSG_INFO, "WifiWpaHapdInit done");
1701     return (void *)drv;
1702 
1703 failed:
1704     if (drv != NULL && drv->eapolSock != NULL) {
1705         l2_packet_deinit(drv->eapolSock);
1706     }
1707     WifiWpaDeinit(drv);
1708     return NULL;
1709 }
1710 
WifiWpaHapdDeinit(void *priv)1711 static void WifiWpaHapdDeinit(void *priv)
1712 {
1713     int32_t ret;
1714     WifiDriverData *drv = NULL;
1715     WifiSetMode setMode;
1716     WifiSetNewDev info;
1717 
1718     if (priv == NULL) {
1719         return;
1720     }
1721 
1722     (void)memset_s(&setMode, sizeof(WifiSetMode), 0, sizeof(WifiSetMode));
1723     drv = (WifiDriverData *)priv;
1724     setMode.iftype = WIFI_IFTYPE_STATION;
1725     info.status = FALSE;
1726     info.ifType = WIFI_IFTYPE_AP;
1727     info.mode = WIFI_PHY_MODE_11N;
1728 
1729     WifiCmdSetNetdev(drv->iface, &info);
1730     ret = WifiCmdSetMode((char *)drv->iface, &setMode);
1731     if (ret != SUCC) {
1732         return;
1733     }
1734 
1735     if (drv->eapolSock != NULL) {
1736         l2_packet_deinit(drv->eapolSock);
1737     }
1738     os_free(g_wifiDriverData);
1739     g_wifiDriverData = NULL;
1740     WifiClientDeinit(drv->iface);
1741 
1742     wpa_printf(MSG_INFO, "WifiWpaHapdDeinit done");
1743 }
1744 
WifiWpaHapdSendEapol(void *priv, const uint8_t *addr, const uint8_t *data, size_t dataLen, int encrypt, const uint8_t *ownAddr, uint32_t flags)1745 static int32_t WifiWpaHapdSendEapol(void *priv, const uint8_t *addr, const uint8_t *data, size_t dataLen, int encrypt,
1746     const uint8_t *ownAddr, uint32_t flags)
1747 {
1748     WifiDriverData *drv = priv;
1749     int32_t ret;
1750     uint32_t frameLen;
1751     uint8_t *frameBuf = NULL;
1752     uint8_t *payload = NULL;
1753     struct l2_ethhdr *ethhdr = NULL;
1754 
1755     (void)encrypt;
1756     (void)flags;
1757     if ((priv == NULL) || (addr == NULL) || (data == NULL) || (ownAddr == NULL)) {
1758         return -EFAIL;
1759     }
1760 
1761     frameLen = dataLen + sizeof(struct l2_ethhdr);
1762     frameBuf = os_zalloc(frameLen);
1763     if (frameBuf == NULL) {
1764         return -EFAIL;
1765     }
1766 
1767     ethhdr = (struct l2_ethhdr *)frameBuf;
1768     if (memcpy_s(ethhdr->h_dest, ETH_ADDR_LEN, addr, ETH_ADDR_LEN) != EOK) {
1769         os_free(frameBuf);
1770         frameBuf = NULL;
1771         return -EFAIL;
1772     }
1773     if (memcpy_s(ethhdr->h_source, ETH_ADDR_LEN, ownAddr, ETH_ADDR_LEN) != EOK) {
1774         os_free(frameBuf);
1775         frameBuf = NULL;
1776         return -EFAIL;
1777     }
1778     ethhdr->h_proto = host_to_be16(ETH_P_PAE);
1779     payload = (uint8_t *)(ethhdr + 1);
1780     if (memcpy_s(payload, dataLen, data, dataLen) != EOK) {
1781         os_free(frameBuf);
1782         frameBuf = NULL;
1783         return -EFAIL;
1784     }
1785     ret = l2_packet_send(drv->eapolSock, addr, ETH_P_EAPOL, frameBuf, frameLen);
1786     os_free(frameBuf);
1787     frameBuf = NULL;
1788     wpa_printf(MSG_INFO, "WifiWpaHapdSendEapol done, ret=%d", ret);
1789     return ret;
1790 }
1791 
WifiWpaStaRemove(void *priv, const uint8_t *addr)1792 static int32_t WifiWpaStaRemove(void *priv, const uint8_t *addr)
1793 {
1794     WifiDriverData *drv = NULL;
1795     int32_t ret;
1796 
1797     if ((priv == NULL) || (addr == NULL)) {
1798         return -EFAIL;
1799     }
1800     drv = (WifiDriverData *)priv;
1801     ret = WifiCmdStaRemove(drv->iface, addr, ETH_ADDR_LEN);
1802     if (ret != SUCC) {
1803         return -EFAIL;
1804     }
1805     wpa_printf(MSG_INFO, "WifiWpaStaRemove done, ret=%d", ret);
1806     return ret;
1807 }
1808 
WifiDuplicateStr(const uint8_t *src, size_t len)1809 static uint8_t *WifiDuplicateStr(const uint8_t *src, size_t len)
1810 {
1811     uint8_t *res = NULL;
1812 
1813     if (src == NULL) {
1814         return NULL;
1815     }
1816     res = os_malloc(len + 1);
1817     if (res == NULL) {
1818         return NULL;
1819     }
1820     if (memcpy_s(res, len, src, len) != EOK) {
1821         os_free(res);
1822         return NULL;
1823     }
1824     res[len] = '\0';
1825 
1826     return res;
1827 }
1828 
WifiActionDataBufFree(WifiActionData *actionData)1829 static void WifiActionDataBufFree(WifiActionData *actionData)
1830 {
1831     if (actionData == NULL) {
1832         return;
1833     }
1834     if (actionData->data != NULL) {
1835         os_free(actionData->data);
1836         actionData->data = NULL;
1837     }
1838 }
1839 
WifiWpaSendAction(void *priv, uint32_t freq, uint32_t wait, const uint8_t *dst, const uint8_t *src, const uint8_t *bssid, const uint8_t *data, size_t dataLen, int32_t noCck)1840 static int32_t WifiWpaSendAction(void *priv, uint32_t freq, uint32_t wait, const uint8_t *dst, const uint8_t *src,
1841     const uint8_t *bssid, const uint8_t *data, size_t dataLen, int32_t noCck)
1842 {
1843     WifiActionData actionData = {
1844         .dst = {0},
1845         .src = {0},
1846         .bssid = {0},
1847         .data = NULL,
1848         .dataLen = 0,
1849         .freq = 0,
1850         .wait = 0,
1851         .noCck = 0,
1852     };
1853     WifiDriverData *drv = NULL;
1854     int32_t ret;
1855 
1856     if ((priv == NULL) || (data == NULL) || (dst == NULL) || (src == NULL) || (bssid == NULL)) {
1857         return -EFAIL;
1858     }
1859     drv = (WifiDriverData *)priv;
1860 
1861     if (memcpy_s(actionData.dst, ETH_ADDR_LEN, dst, ETH_ADDR_LEN) != EOK) {
1862         return -EFAIL;
1863     }
1864     if (memcpy_s(actionData.src, ETH_ADDR_LEN, src, ETH_ADDR_LEN) != EOK) {
1865         return -EFAIL;
1866     }
1867     if (memcpy_s(actionData.bssid, ETH_ADDR_LEN, bssid, ETH_ADDR_LEN) != EOK) {
1868         return -EFAIL;
1869     }
1870 
1871     actionData.dataLen = dataLen;
1872     actionData.freq = freq;
1873     actionData.wait = wait;
1874     actionData.noCck = noCck;
1875     actionData.data = WifiDuplicateStr(data, dataLen);
1876     if (actionData.data == NULL) {
1877         return -EFAIL;
1878     }
1879     ret = WifiCmdSendAction(drv->iface, &actionData);
1880     WifiActionDataBufFree(&actionData);
1881     wpa_printf(MSG_INFO, "WifiWpaSendAction done, ret=%d", ret);
1882     return ret;
1883 }
1884 
DeinitWifiServicenull1885 __attribute__ ((visibility ("default"))) void DeinitWifiService()
1886 {
1887     if (g_wifiDriverType == WIFI_IFTYPE_STATION) {
1888         WifiWpaDeinit(g_wifiDriverData);
1889     } else if (g_wifiDriverType == WIFI_IFTYPE_AP) {
1890         WifiWpaHapdDeinit(g_wifiDriverData);
1891     } else {
1892         printf("no need to cleanup \n");
1893     }
1894 }
1895 
1896 #ifdef CONFIG_OHOS_P2P
WifiProbeReqReport(void *priv, int32_t report)1897 static int32_t WifiProbeReqReport(void *priv, int32_t report)
1898 {
1899     WifiDriverData *drv = NULL;
1900     wpa_printf(MSG_INFO, "%s enter.", __FUNCTION__);
1901     if (priv == NULL) {
1902         wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
1903         return -EFAIL;
1904     }
1905     drv = (WifiDriverData *)priv;
1906     return WifiCmdProbeReqReport(drv->iface, &report);
1907 }
1908 
WifiRemainOnChannel(void *priv, uint32_t freq, uint32_t duration)1909 static int32_t WifiRemainOnChannel(void *priv, uint32_t freq, uint32_t duration)
1910 {
1911     int32_t ret;
1912     WifiDriverData *drv = priv;
1913     WifiOnChannel *onChannel = NULL;
1914     if (priv == NULL) {
1915         wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
1916         return -EFAIL;
1917     }
1918     onChannel = (WifiOnChannel *)os_zalloc(sizeof(WifiOnChannel));
1919     if (onChannel == NULL)
1920     {
1921         wpa_printf(MSG_ERROR, "%s failed to alloc channel.", __FUNCTION__);
1922         return -EFAIL;
1923     }
1924     onChannel->freq = freq;
1925     onChannel->duration = duration;
1926 
1927     ret = WifiCmdRemainOnChannel(drv->iface, onChannel);
1928 
1929     os_free(onChannel);
1930     onChannel = NULL;
1931 
1932     return ret;
1933 }
1934 
WifiCancelRemainOnChannel(void *priv)1935 static int32_t WifiCancelRemainOnChannel(void *priv)
1936 {
1937     WifiDriverData *drv = priv;
1938     if (drv == NULL) {
1939         wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
1940         return -EFAIL;
1941     }
1942 
1943     return WifiCmdCancelRemainOnChannel(drv->iface);
1944 }
1945 
WifiAddIf(void *priv, enum wpa_driver_if_type type, const char *ifName, const uint8_t *addr, void *bss_ctx, void **drv_priv, char *force_ifname, uint8_t *if_addr, const char *bridge, int32_t use_existing, int32_t setup_ap)1946 static int32_t WifiAddIf(void *priv, enum wpa_driver_if_type type, const char *ifName, const uint8_t *addr, void *bss_ctx,
1947                          void **drv_priv, char *force_ifname, uint8_t *if_addr, const char *bridge, int32_t use_existing, int32_t setup_ap)
1948 {
1949     WifiDriverData *drv = priv;
1950     WifiIfAdd *ifAdd = NULL;
1951     int32_t ret;
1952     WifiDev *wifiDev = NULL;
1953     if (priv == NULL) {
1954         wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
1955         return -EFAIL;
1956     }
1957     ifAdd = (WifiIfAdd *)os_zalloc(sizeof(WifiIfAdd));
1958     if (ifAdd == NULL) {
1959         wpa_printf(MSG_ERROR, "%s failed to alloc ifAdd.", __FUNCTION__);
1960         return -EFAIL;
1961     }
1962     switch (type) {
1963     case WPA_IF_STATION:
1964         ifAdd->type = WIFI_IFTYPE_STATION;
1965         break;
1966     case WPA_IF_P2P_GROUP:
1967     case WPA_IF_P2P_CLIENT:
1968         ifAdd->type = WIFI_IFTYPE_P2P_CLIENT;
1969         break;
1970     case WPA_IF_AP_VLAN:
1971         ifAdd->type = WIFI_IFTYPE_AP_VLAN;
1972         break;
1973     case WPA_IF_AP_BSS:
1974         ifAdd->type = WIFI_IFTYPE_AP;
1975         break;
1976     case WPA_IF_P2P_GO:
1977         ifAdd->type = WIFI_IFTYPE_P2P_GO;
1978         break;
1979     case WPA_IF_P2P_DEVICE:
1980         ifAdd->type = WIFI_IFTYPE_P2P_DEVICE;
1981         break;
1982     case WPA_IF_MESH:
1983         ifAdd->type = WIFI_IFTYPE_MESH_POINT;
1984         break;
1985     default:
1986         wpa_printf(MSG_ERROR, "%s unsuportted interface type %d.", __FUNCTION__, type);
1987     }
1988 
1989     ret = WifiRegisterEventCallback(OnWpaWiFiEvents, WIFI_KERNEL_TO_WPA_CLIENT, ifName);
1990     if (ret != SUCC) {
1991         wpa_printf(MSG_ERROR, "WifiWpa register event listener faild");
1992     }
1993     ret = memcpy_s(ifAdd->ifName, IFNAMSIZ, ifName, IFNAMSIZ);
1994     if (ret != SUCC) {
1995         wpa_printf(MSG_ERROR, "%s memcpy_s ifName faild", __FUNCTION__);
1996         return -EFAIL;
1997     }
1998 
1999     ret = WifiCmdAddIf(drv->iface, ifAdd);
2000     if (ret == SUCC) {
2001         wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
2002         if (wifiDev == NULL) {
2003             wpa_printf(MSG_ERROR, "%s failed to malloc wifiDev.", __FUNCTION__);
2004             return -EFAIL;
2005         }
2006         wifiDev->priv = drv;
2007         wifiDev->ifNameLen = sizeof(ifName);
2008         errno_t rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), ifName, sizeof(drv->iface));
2009         if (rc != EOK) {
2010             wpa_printf(MSG_ERROR, "Could not copy wifi device name.");
2011             FreeWifiDev(wifiDev);
2012             return ret;
2013         }
2014         wpa_printf(MSG_INFO, "%s ifName:%s, type:%d", __FUNCTION__, wifiDev->ifName, ifAdd->type);
2015         SetWifiDev(wifiDev);
2016     }
2017     os_free(ifAdd);
2018     ifAdd = NULL;
2019     return ret;
2020 }
2021 
WifiRemoveIf(void *priv, enum wpa_driver_if_type type, const char *ifName)2022 static int32_t WifiRemoveIf(void *priv, enum wpa_driver_if_type type, const char *ifName)
2023 {
2024     WifiDriverData *drv = priv;
2025     WifiIfRemove ifRemove = {0};
2026     int32_t ret;
2027     errno_t rc;
2028     WifiDev *wifiDev = NULL;
2029     if (priv == NULL || ifName == NULL) {
2030         wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
2031         return -EFAIL;
2032     }
2033     if (os_strlen(ifName) > IFNAMSIZ) {
2034         wpa_printf(MSG_ERROR, "%s ifName invalid:%s.", __FUNCTION__, ifName);
2035         return -EFAIL;
2036     }
2037     rc = memcpy_s(ifRemove.ifName, IFNAMSIZ, ifName, IFNAMSIZ);
2038     if (rc != EOK) {
2039         wpa_printf(MSG_ERROR, "%s can not copy interface name.", __FUNCTION__);
2040         return -EFAIL;
2041     }
2042 
2043     ret = WifiCmdRemoveIf(drv->iface, &ifRemove);
2044     wifiDev = GetWifiDevByName(ifName);
2045     if (wifiDev == NULL) {
2046         wpa_printf(MSG_INFO, "%s: GetWifiDevByName is null, already free.", __FUNCTION__);
2047         return SUCC;
2048     }
2049     FreeWifiDev(wifiDev);
2050     return SUCC;
2051 }
2052 
WifiSetApWpsP2pIe(void *priv, const struct wpabuf *beacon, const struct wpabuf *probresp, const struct wpabuf *assocresp)2053 int32_t WifiSetApWpsP2pIe(void *priv, const struct wpabuf *beacon, const struct wpabuf *probresp, const struct wpabuf *assocresp)
2054 {
2055     int32_t loops;
2056     int32_t ret = SUCC;
2057     WifiAppIe *appIe = NULL;
2058     struct wpabuf *wpabufTmp = NULL;
2059     WifiDriverData *drv = (WifiDriverData *)priv;
2060     WifiCmd cmdAddr[4] = {{0x1, beacon}, {0x2, probresp}, {0x4, assocresp}, {-1, NULL}};
2061     errno_t rc;
2062     appIe = (WifiAppIe *)os_zalloc(sizeof(WifiAppIe));
2063     if (appIe == NULL) {
2064         wpa_printf(MSG_ERROR, "%s:failed to malloc WifiAppIe.", __FUNCTION__);
2065         return -EFAIL;
2066     }
2067     for (loops = 0; cmdAddr[loops].cmd != -1; loops++) {
2068         wpabufTmp = (struct wpabuf *)cmdAddr[loops].src;
2069         if (wpabufTmp != NULL) {
2070             appIe->appIeType = cmdAddr[loops].cmd;
2071             appIe->ieLen = wpabuf_len(wpabufTmp);
2072             if ((wpabufTmp->buf != NULL) && (appIe->ieLen != 0)) {
2073                 appIe->ie = os_zalloc(appIe->ieLen);
2074                 if (appIe->ie == NULL) {
2075                     wpa_printf(MSG_ERROR, "%s appIe->ie malloc failed.", __FUNCTION__);
2076                     os_free(appIe);
2077                     return -EFAIL;
2078                 }
2079                 rc = memcpy_s(appIe->ie, appIe->ieLen, wpabuf_head(wpabufTmp), wpabuf_len(wpabufTmp));
2080                 if (rc != EOK) {
2081                     wpa_printf(MSG_ERROR, "%s: ", __FUNCTION__);
2082                     os_free(appIe->ie);
2083                     os_free(appIe);
2084                     return -EFAIL;
2085                 }
2086             }
2087             wpa_printf(MSG_INFO, "%s type %d, ie_len %d.", __FUNCTION__, appIe->appIeType, appIe->ieLen);
2088 
2089             ret = WifiCmdSetApWpsP2pIe(drv->iface, appIe);
2090             os_free(appIe->ie);
2091             appIe->ie = NULL;
2092             if (ret < 0) {
2093                 break;
2094             }
2095         }
2096     }
2097     os_free(appIe);
2098     appIe = NULL;
2099     return ret;
2100 }
2101 
WifiWpaGetDrvFlags(void *priv, uint64_t *drvFlags)2102 int32_t WifiWpaGetDrvFlags(void *priv, uint64_t *drvFlags)
2103 {
2104     WifiDriverData *drv = NULL;
2105     WifiGetDrvFlags *params = NULL;
2106     int32_t ret;
2107     if (priv == NULL || drvFlags == NULL)
2108     {
2109         return -EFAIL;
2110     }
2111     drv = (WifiDriverData *)priv;
2112     params = (WifiGetDrvFlags *)os_zalloc(sizeof(WifiGetDrvFlags));
2113     if (params == NULL)
2114     {
2115         return -EFAIL;
2116     }
2117     params->drvFlags = 0;
2118     ret = WifiCmdGetDrvFlags(drv->iface, params);
2119     if (ret != SUCC)
2120     {
2121         wpa_printf(MSG_ERROR, "%s WifiCmdGetDrvFlags failed, ret is %d.", __FUNCTION__, ret);
2122         os_free(params);
2123         return -EFAIL;
2124     }
2125     *drvFlags = params->drvFlags;
2126     wpa_printf(MSG_INFO, "%s Get drvFlags done.", __FUNCTION__);
2127     os_free(params);
2128     return ret;
2129 }
2130 #endif // CONFIG_OHOS_P2P
2131 
2132 const struct wpa_driver_ops g_wifiDriverOps = {
2133     .name = "hdf wifi",
2134     .desc = "wpa hdf adaptor layer",
2135     .get_bssid = WifiWpaGetBssid,
2136     .get_ssid = WifiWpaGetSsid,
2137     .set_key = WifiWpaSetKey,
2138     .scan2 = WifiWpaScan2,
2139     .get_scan_results2 = WifiWpaGetScanResults2,
2140     .deauthenticate = WifiWpaDeauthenticate,
2141     .associate = WifiWpaAssociate,
2142     .send_eapol = WifiWpaWpaSendEapol,
2143     .init2 = WifiWpaInit2,
2144     .deinit = WifiWpaDeinit,
2145     .set_ap = WifiWpaSetAp,
2146     .send_mlme = WifiWpaSendMlme,
2147     .get_hw_feature_data = WifiWpaGetHwFeatureData,
2148     .sta_remove = WifiWpaStaRemove,
2149     .hapd_init = WifiWpaHapdInit,
2150     .hapd_deinit = WifiWpaHapdDeinit,
2151     .hapd_send_eapol = WifiWpaHapdSendEapol,
2152     .send_action = WifiWpaSendAction,
2153     .get_mac_addr = WifiWpaGetMacAddr,
2154 #ifdef CONFIG_OHOS_P2P
2155     .remain_on_channel = WifiRemainOnChannel,
2156     .cancel_remain_on_channel = WifiCancelRemainOnChannel,
2157     .probe_req_report = WifiProbeReqReport,
2158     .if_add = WifiAddIf,
2159     .if_remove = WifiRemoveIf,
2160     .set_ap_wps_ie = WifiSetApWpsP2pIe,
2161 #endif // CONFIG_OHOS_P2P
2162 };
2163 
2164 #ifdef __cplusplus
2165 #if __cplusplus
2166 }
2167 #endif
2168 #endif
2169