1 /*
2 * Copyright (c) 2023 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 #include "wpa_common_cmd.h"
16 #include "wpa_p2p_cmd.h"
17 #include <securec.h>
18 #include <hdf_base.h>
19 #include <hdf_log.h>
20 #include <osal_time.h>
21 #include <osal_mem.h>
22 #include <arpa/inet.h>
23 #include "utils/common.h"
24 #include "wpa_supplicant_i.h"
25 #include "ctrl_iface.h"
26 #include "main.h"
27 #include "wps_supplicant.h"
28 #include "bssid_ignore.h"
29 #include "wpa_supplicant/config.h"
30 #include "common/defs.h"
31 #include "v1_0/iwpa_callback.h"
32 #include "v1_0/iwpa_interface.h"
33 #include "wpa_client.h"
34 #include <unistd.h>
35 #include <stdlib.h>
36 #include <dlfcn.h>
37 #include <string.h>
38
39 pthread_t g_tid;
40 const int QUOTATION_MARKS_FLAG_YES = 0;
41 const int QUOTATION_MARKS_FLAG_NO = 1;
42
43 static WpaSsidField g_wpaSsidFields[] = {
44 {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES},
45 {DEVICE_CONFIG_PSK, "psk", QUOTATION_MARKS_FLAG_YES},
46 {DEVICE_CONFIG_KEYMGMT, "key_mgmt", QUOTATION_MARKS_FLAG_NO},
47 {DEVICE_CONFIG_PRIORITY, "priority", QUOTATION_MARKS_FLAG_NO},
48 {DEVICE_CONFIG_SCAN_SSID, "scan_ssid", QUOTATION_MARKS_FLAG_NO},
49 {DEVICE_CONFIG_EAP, "eap", QUOTATION_MARKS_FLAG_NO},
50 {DEVICE_CONFIG_IDENTITY, "identity", QUOTATION_MARKS_FLAG_YES},
51 {DEVICE_CONFIG_PASSWORD, "password", QUOTATION_MARKS_FLAG_YES},
52 {DEVICE_CONFIG_BSSID, "bssid", QUOTATION_MARKS_FLAG_NO},
53 {DEVICE_CONFIG_AUTH_ALGORITHMS, "auth_alg", QUOTATION_MARKS_FLAG_NO},
54 {DEVICE_CONFIG_WEP_KEY_IDX, "wep_tx_keyidx", QUOTATION_MARKS_FLAG_NO},
55 {DEVICE_CONFIG_WEP_KEY_0, "wep_key0", QUOTATION_MARKS_FLAG_NO},
56 {DEVICE_CONFIG_WEP_KEY_1, "wep_key1", QUOTATION_MARKS_FLAG_NO},
57 {DEVICE_CONFIG_WEP_KEY_2, "wep_key2", QUOTATION_MARKS_FLAG_NO},
58 {DEVICE_CONFIG_WEP_KEY_3, "wep_key3", QUOTATION_MARKS_FLAG_NO},
59 {DEVICE_CONFIG_EAP_CLIENT_CERT, "client_cert", QUOTATION_MARKS_FLAG_YES},
60 {DEVICE_CONFIG_EAP_PRIVATE_KEY, "private_key", QUOTATION_MARKS_FLAG_YES},
61 {DEVICE_CONFIG_EAP_PHASE2METHOD, "phase2", QUOTATION_MARKS_FLAG_YES},
62 {DEVICE_CONFIG_IEEE80211W, "ieee80211w", QUOTATION_MARKS_FLAG_NO},
63 {DEVICE_CONFIG_ALLOW_PROTOCOLS, "proto", QUOTATION_MARKS_FLAG_NO},
64 {DEVICE_CONFIG_GROUP_CIPHERS, "group", QUOTATION_MARKS_FLAG_NO},
65 {DEVICE_CONFIG_PAIRWISE_CIPHERS, "pairwise", QUOTATION_MARKS_FLAG_NO},
66 {DEVICE_CONFIG_SAE_PASSWD, "sae_password", QUOTATION_MARKS_FLAG_YES},
67 };
68
CalcQuotationMarksFlag(int pos,const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH])69 int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH])
70 {
71 int flag = g_wpaSsidFields[pos].flag;
72 const int hexPskMaxLen = 64;
73 int len = strlen(value);
74 /* if the psk length is 64, it's hex format and don't need quotation marks */
75 if (pos == DEVICE_CONFIG_PSK && len >= hexPskMaxLen) {
76 flag = QUOTATION_MARKS_FLAG_NO;
77 }
78 if (pos == DEVICE_CONFIG_WEP_KEY_0 ||
79 pos == DEVICE_CONFIG_WEP_KEY_1 ||
80 pos == DEVICE_CONFIG_WEP_KEY_2 ||
81 pos == DEVICE_CONFIG_WEP_KEY_3) {
82 const int wepKeyLen1 = 5;
83 const int wepKeyLen2 = 13;
84 const int wepKeyLen3 = 16;
85 /* For wep key, ASCII format need quotation marks, hex format is not required */
86 if (len == wepKeyLen1 || len == wepKeyLen2 || len == wepKeyLen3) {
87 flag = QUOTATION_MARKS_FLAG_YES;
88 }
89 }
90 return flag;
91 }
92
StrSafeCopy(char * dst,unsigned len,const char * src)93 void StrSafeCopy(char *dst, unsigned len, const char *src)
94 {
95 if (dst == NULL) {
96 return;
97 }
98 if (src == NULL) {
99 dst[0] = '\0';
100 return;
101 }
102 unsigned i = 0;
103 while (i + 1 < len && src[i] != '\0') {
104 dst[i] = src[i];
105 ++i;
106 }
107 dst[i] = '\0';
108 return;
109 }
110
FillData(uint8_t ** dst,uint32_t * dstLen,uint8_t * src,uint32_t srcLen)111 int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen)
112 {
113 if (src == NULL || dst == NULL || dstLen == NULL) {
114 HDF_LOGE("%{public}s: Invalid parameter!", __func__);
115 return HDF_ERR_INVALID_PARAM;
116 }
117 HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen);
118 if (srcLen > 0) {
119 *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen);
120 if (*dst == NULL) {
121 HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__);
122 return HDF_FAILURE;
123 }
124 if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) {
125 HDF_LOGE("%{public}s: memcpy_s fail!", __func__);
126 return HDF_FAILURE;
127 }
128 }
129 *dstLen = srcLen;
130 return HDF_SUCCESS;
131 }
132
HdfWpaStubDriver(void)133 struct HdfWpaStubData *HdfWpaStubDriver(void)
134 {
135 static struct HdfWpaStubData registerManager;
136 return ®isterManager;
137 }
138
WpaInterfaceScan(struct IWpaInterface * self,const char * ifName)139 int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName)
140 {
141 struct wpa_supplicant *wpaSupp;
142 char reply[REPLY_SIZE] = {0};
143 int32_t replyLen = 0;
144 int32_t ret = HDF_FAILURE;
145
146 (void)self;
147 HDF_LOGD("%{public}s scan!", __func__);
148 if (ifName == NULL) {
149 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
150 return HDF_ERR_INVALID_PARAM;
151 }
152 wpaSupp = getWpaWlan();
153 if (wpaSupp == NULL) {
154 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
155 return HDF_FAILURE;
156 }
157 wpas_ctrl_scan(wpaSupp, NULL, reply, REPLY_SIZE, &replyLen);
158 if (replyLen == -1) {
159 HDF_LOGE("%{public}s scan network fail!", __func__);
160 ret = HDF_FAILURE;
161 } else {
162 HDF_LOGE("%{public}s scan network reply = %s", __func__, reply);
163 ret = HDF_SUCCESS;
164 }
165 return ret;
166 }
167
WpaInterfaceScanResult(struct IWpaInterface * self,const char * ifName,unsigned char * resultBuf,uint32_t * resultBufLen)168 int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf,
169 uint32_t *resultBufLen)
170 {
171 struct wpa_supplicant *wpaSupp;
172 int32_t ret = HDF_FAILURE;
173
174 (void)self;
175 if (ifName == NULL || resultBuf == NULL) {
176 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
177 return HDF_ERR_INVALID_PARAM;
178 }
179 wpaSupp = getWpaWlan();
180 if (wpaSupp == NULL) {
181 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
182 return HDF_FAILURE;
183 }
184 *resultBufLen = (uint32_t)wpa_supplicant_ctrl_iface_scan_results(wpaSupp, (char *)resultBuf,
185 REPLY_SIZE * REPLY_SIZE_FACTOR_FIRST * REPLY_SIZE_FACTOR_SECOND);
186 HDF_LOGE("%{public}s ScanResult resultBufLen = %d", __func__, *resultBufLen);
187 ret = HDF_SUCCESS;
188 return ret;
189 }
190
WpaInterfaceAddNetwork(struct IWpaInterface * self,const char * ifName,int32_t * networkId)191 int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId)
192 {
193 struct wpa_supplicant *wpaSupp;
194 char reply[REPLY_SIZE] = {0};
195 int32_t ret = HDF_FAILURE;
196
197 (void)self;
198 HDF_LOGE("%{public}s add network", __func__);
199 if (ifName == NULL || networkId == NULL) {
200 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
201 return HDF_ERR_INVALID_PARAM;
202 }
203 wpaSupp = getWpaWlan();
204 if (wpaSupp == NULL) {
205 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
206 return HDF_FAILURE;
207 }
208 ret = wpa_supplicant_ctrl_iface_add_network(wpaSupp, reply, REPLY_SIZE);
209 if (ret != HDF_FAILURE) {
210 HDF_LOGE("%{public}s add network reply= %{public}s", __func__, reply);
211 *networkId = atoi(reply);
212 ret = HDF_SUCCESS;
213 HDF_LOGE("%{public}s add network success! *networkId = %{public}d", __func__, *networkId);
214 } else {
215 HDF_LOGE("%{public}s add network fail!", __func__);
216 }
217 return ret;
218 }
219
WpaInterfaceRemoveNetwork(struct IWpaInterface * self,const char * ifName,int32_t networkId)220 int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId)
221 {
222 struct wpa_supplicant *wpaSupp;
223 char cmd[CMD_SIZE] = {0};
224 int32_t ret = HDF_FAILURE;
225
226 (void)self;
227 if (ifName == NULL) {
228 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
229 return HDF_ERR_INVALID_PARAM;
230 }
231 wpaSupp = getWpaWlan();
232 if (wpaSupp == NULL) {
233 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
234 return HDF_FAILURE;
235 }
236 if (networkId == -1) {
237 strcpy_s(cmd, CMD_SIZE, "all");
238 } else {
239 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", networkId);
240 }
241 ret = wpa_supplicant_ctrl_iface_remove_network(wpaSupp, cmd);
242 if (ret != HDF_SUCCESS) {
243 HDF_LOGE("%{public}s remove network fail!", __func__);
244 }
245 return ret;
246 }
247
WpaInterfaceDisableNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId)248 int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId)
249 {
250 struct wpa_supplicant *wpaSupp;
251 char cmd[CMD_SIZE] = {0};
252 int32_t ret = HDF_FAILURE;
253
254 (void)self;
255 if (ifName == NULL) {
256 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
257 return HDF_ERR_INVALID_PARAM;
258 }
259 wpaSupp = getWpaWlan();
260 if (wpaSupp == NULL) {
261 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
262 return HDF_FAILURE;
263 }
264 if (networkId == -1) {
265 strcpy_s(cmd, CMD_SIZE, "all");
266 } else {
267 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", networkId);
268 }
269 ret = wpa_supplicant_ctrl_iface_disable_network(wpaSupp, cmd);
270 if (ret != HDF_SUCCESS) {
271 HDF_LOGE("%{public}s disable network fail!", __func__);
272 }
273 return ret;
274 }
275
WpaInterfaceSetNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * name,const char * value)276 int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName,
277 const int32_t networkId, const char *name, const char *value)
278 {
279 struct wpa_supplicant *wpaSupp;
280 char cmd[CMD_SIZE] = {0};
281 int32_t ret = HDF_FAILURE;
282
283 (void)self;
284 if (ifName == NULL || name == NULL || value == NULL) {
285 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
286 return HDF_ERR_INVALID_PARAM;
287 }
288 wpaSupp = getWpaWlan();
289 if (wpaSupp == NULL) {
290 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
291 return HDF_FAILURE;
292 }
293 HDF_LOGE("%{public}s networkId =%{public}d", __func__, networkId);
294 if (name != NULL) {
295 HDF_LOGE("%{public}s name =%{public}s", __func__, name);
296 }
297 if (value != NULL) {
298 HDF_LOGE("%{public}s value =%{public}s", __func__, value);
299 }
300 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %s %s",
301 networkId, name, value);
302 ret = wpa_supplicant_ctrl_iface_set_network(wpaSupp, cmd);
303 if (ret != HDF_SUCCESS) {
304 HDF_LOGE("%{public}s set network fail!", __func__);
305 }
306 return ret;
307 }
308
WpaFillWpaListNetworkParam(struct WifiNetworkInfo * wifiWpaNetworkInfo,struct HdiWifiWpaNetworkInfo * hdiWifiWpaNetworkInfo)309 static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo,
310 struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo)
311 {
312 int32_t ret = HDF_SUCCESS;
313
314 if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) {
315 HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__);
316 return HDF_ERR_INVALID_PARAM;
317 }
318 do {
319 uint8_t tmpBssid[ETH_ADDR_LEN] = {0};
320 hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid);
321 if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen,
322 tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
323 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
324 ret = HDF_FAILURE;
325 break;
326 }
327 if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen,
328 (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) {
329 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
330 ret = HDF_FAILURE;
331 }
332 if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen,
333 (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) {
334 HDF_LOGE("%{public}s: fill flags fail!", __func__);
335 ret = HDF_FAILURE;
336 }
337 } while (0);
338 if (ret != HDF_SUCCESS) {
339 if (hdiWifiWpaNetworkInfo->bssid != NULL) {
340 OsalMemFree(hdiWifiWpaNetworkInfo->bssid);
341 }
342 if (hdiWifiWpaNetworkInfo->ssid != NULL) {
343 OsalMemFree(hdiWifiWpaNetworkInfo->ssid);
344 }
345 if (hdiWifiWpaNetworkInfo->flags != NULL) {
346 OsalMemFree(hdiWifiWpaNetworkInfo->flags);
347 }
348 }
349 return ret;
350 }
351
HdiListNetworkProcess(struct HdiWifiWpaNetworkInfo * pcmd,char * tmpBuf,int bufLeng)352 static void HdiListNetworkProcess(struct HdiWifiWpaNetworkInfo *pcmd, char *tmpBuf, int bufLeng)
353 {
354 int start = 0; /* start pos */
355 int end = 0; /* end pos */
356 int i = 0;
357
358 WifiNetworkInfo wifiNetworkInfo;
359 memset_s(&wifiNetworkInfo, sizeof(struct WifiNetworkInfo), 0, sizeof(struct WifiNetworkInfo));
360 while (end < bufLeng) {
361 if (tmpBuf[end] != '\t') {
362 ++end;
363 continue;
364 }
365 tmpBuf[end] = '\0';
366 if (i == COLUMN_INDEX_ZERO) {
367 pcmd->id = atoi(tmpBuf);
368 } else if (i == COLUMN_INDEX_ONE) {
369 if (strcpy_s(wifiNetworkInfo.ssid, sizeof(wifiNetworkInfo.ssid), tmpBuf + start) != EOK) {
370 break;
371 }
372 printf_decode((u8 *)wifiNetworkInfo.ssid, sizeof(wifiNetworkInfo.ssid), wifiNetworkInfo.ssid);
373 } else if (i == COLUMN_INDEX_TWO) {
374 if (strcpy_s(wifiNetworkInfo.bssid, sizeof(wifiNetworkInfo.bssid), tmpBuf + start) != EOK) {
375 break;
376 }
377 start = end + 1;
378 if (strcpy_s(wifiNetworkInfo.flags, sizeof(wifiNetworkInfo.flags), tmpBuf + start) != EOK) {
379 break;
380 }
381 break;
382 }
383 WpaFillWpaListNetworkParam(&wifiNetworkInfo, pcmd);
384 ++i;
385 end++;
386 start = end;
387 }
388 return;
389 }
390
391 //need to check
WpaInterfaceListNetworks(struct IWpaInterface * self,const char * ifName,struct HdiWifiWpaNetworkInfo * networkInfo,uint32_t * networkInfoLen)392 int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName,
393 struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen)
394 {
395 struct wpa_supplicant *wpaSupp;
396 char reply[REPLY_SIZE] = {0};
397 char cmd[CMD_SIZE] = {0};
398 int32_t ret = HDF_FAILURE;
399
400 (void)self;
401 if (ifName == NULL || networkInfo == NULL || networkInfoLen == NULL) {
402 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
403 return HDF_ERR_INVALID_PARAM;
404 }
405 wpaSupp = getWpaWlan();
406 if (wpaSupp == NULL) {
407 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
408 return HDF_FAILURE;
409 }
410 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "LIST_NETWORKS");
411 if (ret < 0) {
412 HDF_LOGE("%{public}s set network fail!", __func__);
413 return HDF_FAILURE;
414 }
415 wpa_supplicant_ctrl_iface_list_networks(wpaSupp, cmd, reply, REPLY_SIZE);
416
417 char *savedPtr = NULL;
418 strtok_r(reply, "\n", &savedPtr); /* skip first line */
419 char *token = strtok_r(NULL, "\n", &savedPtr);
420 int32_t j = 0;
421 while (token != NULL) {
422 if (j >= *networkInfoLen) {
423 *networkInfoLen = j;
424 HDF_LOGI("%{public}s list_networks full!", __func__);
425 return HDF_SUCCESS;
426 }
427 int length = strlen(token);
428 if (length <= 0) {
429 break;
430 }
431 HdiListNetworkProcess(networkInfo + j, token, length);
432 token = strtok_r(NULL, "\n", &savedPtr);
433 j++;
434 }
435 *networkInfoLen = j;
436 if (*networkInfoLen <= 0) {
437 HDF_LOGI("%{public}s list_networks empty!", __func__);
438 }
439 return HDF_SUCCESS;
440 }
441
WpaInterfaceSelectNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId)442 int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName,
443 const int32_t networkId)
444 {
445 struct wpa_supplicant *wpaSupp;
446 char cmd[CMD_SIZE];
447 int32_t ret = HDF_FAILURE;
448
449 (void)self;
450 if (ifName == NULL) {
451 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
452 return HDF_ERR_INVALID_PARAM;
453 }
454 wpaSupp = getWpaWlan();
455 if (wpaSupp == NULL) {
456 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
457 return HDF_FAILURE;
458 }
459 HDF_LOGE("%{public}s networkId =%{public}d", __func__, networkId);
460 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", networkId);
461 ret = wpa_supplicant_ctrl_iface_select_network(wpaSupp, cmd);
462 if (ret != HDF_SUCCESS) {
463 HDF_LOGE("%{public}s select network fail!", __func__);
464 }
465 return ret;
466 }
467
WpaInterfaceEnableNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId)468 int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId)
469 {
470 struct wpa_supplicant *wpaSupp;
471 char cmd[CMD_SIZE];
472 int32_t ret = HDF_FAILURE;
473
474 (void)self;
475 if (ifName == NULL) {
476 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
477 return HDF_ERR_INVALID_PARAM;
478 }
479 wpaSupp = getWpaWlan();
480 if (wpaSupp == NULL) {
481 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
482 return HDF_FAILURE;
483 }
484 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", networkId);
485 ret = wpa_supplicant_ctrl_iface_enable_network(wpaSupp, cmd);
486 if (ret != HDF_SUCCESS) {
487 HDF_LOGE("%{public}s enable network fail!", __func__);
488 }
489 return ret;
490 }
491
WpaInterfaceReconnect(struct IWpaInterface * self,const char * ifName)492 int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName)
493 {
494 struct wpa_supplicant *wpaSupp;
495
496 (void)self;
497 if (ifName == NULL) {
498 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
499 return HDF_ERR_INVALID_PARAM;
500 }
501 wpaSupp = getWpaWlan();
502 if (wpaSupp == NULL) {
503 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
504 return HDF_FAILURE;
505 }
506 wpas_request_connection(wpaSupp);
507 return HDF_SUCCESS;
508 }
509
WpaInterfaceDisconnect(struct IWpaInterface * self,const char * ifName)510 int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName)
511 {
512 struct wpa_supplicant *wpaSupp;
513
514 (void)self;
515 if (ifName == NULL) {
516 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
517 return HDF_ERR_INVALID_PARAM;
518 }
519 wpaSupp = getWpaWlan();
520 if (wpaSupp == NULL) {
521 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
522 return HDF_FAILURE;
523 }
524 wpas_request_disconnection(wpaSupp);
525 return HDF_SUCCESS;
526 }
527
WpaInterfaceSetPowerSave(struct IWpaInterface * self,const char * ifName,const int32_t enable)528 int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, const int32_t enable)
529 {
530 struct wpa_supplicant *wpaSupp;
531 int32_t ret = HDF_FAILURE;
532
533 (void)self;
534 if (ifName == NULL) {
535 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
536 return HDF_ERR_INVALID_PARAM;
537 }
538 wpaSupp = getWpaWlan();
539 if (wpaSupp == NULL) {
540 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
541 return HDF_FAILURE;
542 }
543 if (!wpaSupp->driver->set_p2p_powersave) {
544 return HDF_FAILURE;
545 }
546 ret = wpaSupp->driver->set_p2p_powersave(wpaSupp->drv_priv, enable, -1, -1);
547 if (ret != HDF_SUCCESS) {
548 HDF_LOGE("%{public}s set powersave fail!", __func__);
549 }
550 return ret;
551 }
552
WpaInterfaceAutoConnect(struct IWpaInterface * self,const char * ifName,const int32_t enable)553 int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable)
554 {
555 struct wpa_supplicant *wpaSupp;
556
557 (void)self;
558 if (ifName == NULL) {
559 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
560 return HDF_ERR_INVALID_PARAM;
561 }
562 wpaSupp = getWpaWlan();
563 if (wpaSupp == NULL) {
564 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
565 return HDF_FAILURE;
566 }
567 wpaSupp->auto_reconnect_disabled = enable == 0;
568 return HDF_SUCCESS;
569 }
570
WapDealWifiStatus(char * reply,struct HdiWpaCmdStatus * status)571 static void WapDealWifiStatus(char *reply, struct HdiWpaCmdStatus *status)
572 {
573 char *savedPtr = NULL;
574 char *key = strtok_r(reply, "=", &savedPtr);
575 while (key != NULL) {
576 char *value = strtok_r(NULL, "\n", &savedPtr);
577 if (strcmp(key, "bssid") == 0) {
578 uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0};
579 HDF_LOGI("%{public}s key include bssid value=%{public}s", __func__, value);
580 hwaddr_aton(value, tmpBssid);
581 status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1));
582 status->bssidLen = ETH_ADDR_LEN + 1;
583 StrSafeCopy((char *)status->bssid, ETH_ADDR_LEN + 1, (char *)tmpBssid);
584 } else if (strcmp(key, "freq") == 0) {
585 status->freq = atoi(value);
586 HDF_LOGI("%{public}s status->freq= %{public}d", __func__, status->freq);
587 } else if (strcmp(key, "ssid") == 0) {
588 HDF_LOGI("%{public}s key include ssid value=%{public}s", __func__, value);
589 status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(value) + 1));
590 status->ssidLen = strlen(value);
591 StrSafeCopy((char *)status->ssid, strlen(value) + 1, value);
592 printf_decode((u8 *)status->ssid, strlen(value) + 1, (char *)status->ssid);
593 } else if (strcmp(key, "id") == 0) {
594 status->id = atoi(value);
595 HDF_LOGI("%{public}s status->id= %{public}d", __func__, status->id);
596 } else if (strcmp(key, "key_mgmt") == 0) {
597 HDF_LOGI("%{public}s key include key_mgmt value=%{public}s", __func__, value);
598 status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(value) + 1));
599 status->keyMgmtLen = strlen(value);
600 StrSafeCopy((char *)status->keyMgmt, strlen(value) + 1, value);
601 } else if (strcmp(key, "address") == 0) {
602 uint8_t tmpAddress[ETH_ADDR_LEN +1] = {0};
603 HDF_LOGD("%{public}s key include address value=%{public}s", __func__, value);
604 hwaddr_aton(value, tmpAddress);
605 HDF_LOGD("%{public}s key include tmpAddress=%{public}s", __func__, (char *)tmpAddress);
606 status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1));
607 status->addressLen = ETH_ADDR_LEN + 1;
608 StrSafeCopy((char *)status->address, ETH_ADDR_LEN + 1, (char *)tmpAddress);
609 }
610 key = strtok_r(NULL, "=", &savedPtr);
611 }
612 }
613
WpaInterfaceWifiStatus(struct IWpaInterface * self,const char * ifName,struct HdiWpaCmdStatus * status)614 int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status)
615 {
616 char cmd[CMD_SIZE] = {0};
617 char reply[REPLY_SIZE] = {0};
618 int replyLen;
619 struct wpa_supplicant *wpaSupp;
620 HDF_LOGI("%{public}s enter WpaInterfaceWifiStatus!", __func__);
621 if (ifName == NULL || status == NULL) {
622 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
623 return HDF_ERR_INVALID_PARAM;
624 }
625 if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", "STATUS") < 0) {
626 return HDF_FAILURE;
627 }
628 wpaSupp = getWpaWlan();
629 if (wpaSupp != NULL) {
630 HDF_LOGI("%{public}s call wpa_supplicant_ctrl_iface_status!", __func__);
631 replyLen = wpa_supplicant_ctrl_iface_status(wpaSupp, cmd + CMD_LEN, reply, REPLY_SIZE);
632 } else {
633 HDF_LOGE("%{public}s wpaSupp is NULL", __func__);
634 }
635 status->bssidLen = 0;
636 status->ssidLen = 0;
637 status->keyMgmtLen = 0;
638 status->addressLen = 0;
639 WapDealWifiStatus(reply, status);
640 if (status->addressLen == 0) {
641 HDF_LOGE("%{public}s key not include address", __func__);
642 }
643 if (status->bssidLen == 0) {
644 HDF_LOGE("%{public}s key not include bssid", __func__);
645 }
646 HDF_LOGI("%{public}s WpaInterfaceWifiStatus success", __func__);
647 return HDF_SUCCESS;
648 }
649
WpaInterfaceSaveConfig(struct IWpaInterface * self,const char * ifName)650 int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName)
651 {
652 struct wpa_supplicant *wpaSupp;
653 int32_t ret = HDF_FAILURE;
654
655 (void)self;
656 if (ifName == NULL) {
657 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
658 return HDF_ERR_INVALID_PARAM;
659 }
660 wpaSupp = getWpaWlan();
661 if (wpaSupp == NULL) {
662 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
663 return HDF_FAILURE;
664 }
665 ret = wpa_supplicant_ctrl_iface_save_config(wpaSupp);
666 if (ret != HDF_SUCCESS) {
667 HDF_LOGE("%{public}s set config fail!", __func__);
668 }
669 return ret;
670 }
671
macToStr(const u8 * addr)672 const char *macToStr(const u8 *addr)
673 {
674 const int macAddrIndexOne = 0;
675 const int macAddrIndexTwo = 1;
676 const int macAddrIndexThree = 2;
677 const int macAddrIndexFour = 3;
678 const int macAddrIndexFive = 4;
679 const int macAddrIndexSix = 5;
680 static char macToStr[WIFI_BSSID_LENGTH];
681 if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x",
682 addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour],
683 addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) {
684 return NULL;
685 }
686 return macToStr;
687 }
688
WpaInterfaceWpsPbcMode(struct IWpaInterface * self,const char * ifName,const struct HdiWifiWpsParam * wpaParam)689 int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam)
690 {
691 struct wpa_supplicant *wpaSupp;
692 char cmd[CMD_SIZE];
693 int32_t ret = HDF_FAILURE;
694 int res = 0;
695 int pos = 0;
696
697 (void)self;
698 if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL || wpaParam->pinCode == NULL) {
699 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
700 return HDF_ERR_INVALID_PARAM;
701 }
702 wpaSupp = getWpaWlan();
703 if (wpaSupp == NULL) {
704 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
705 return HDF_FAILURE;
706 }
707 if (wpaParam->anyFlag == 1) {
708 res = snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, "%s", "any");
709 } else if (wpaParam->bssidLen > 0) {
710 res = snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, "%s", macToStr(wpaParam->bssid));
711 }
712 if (res < 0) {
713 HDF_LOGE("%{public}s snprintf err", __func__);
714 return HDF_FAILURE;
715 }
716 pos += res;
717 if (wpaParam->multiAp > 0) { /* The value of ap needs to be determined. The value is greater than 0. */
718 res = snprintf_s(
719 cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, " multi_ap=%d", wpaParam->multiAp);
720 if (res < 0) {
721 HDF_LOGE("%{public}s snprintf err2", __func__);
722 return HDF_FAILURE;
723 }
724 }
725 ret = wpa_supplicant_ctrl_iface_wps_pbc(wpaSupp, cmd);
726 if (ret != HDF_SUCCESS) {
727 HDF_LOGE("%{public}s set wps pbcfail!", __func__);
728 }
729 return ret;
730 }
731
WpaInterfaceWpsPinMode(struct IWpaInterface * self,const char * ifName,const struct HdiWifiWpsParam * wpaParam,int * pinCode)732 int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName,
733 const struct HdiWifiWpsParam *wpaParam, int *pinCode)
734 {
735 struct wpa_supplicant *wpaSupp;
736 char cmd[CMD_SIZE];
737 char reply[REPLY_SIZE];
738 int32_t ret = HDF_FAILURE;
739 int res = 0;
740 int pos = 0;
741
742 (void)self;
743 if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL
744 || wpaParam->pinCode == NULL || pinCode == NULL) {
745 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
746 return HDF_ERR_INVALID_PARAM;
747 }
748 wpaSupp = getWpaWlan();
749 if (wpaParam->bssidLen > 0) {
750 res = snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, "%s", macToStr(wpaParam->bssid));
751 } else {
752 res = snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, "any");
753 }
754 if (res < 0) {
755 HDF_LOGE("%{public}s snprintf err", __func__);
756 return HDF_FAILURE;
757 }
758 pos += res;
759 if (wpaParam->pinCodeLen > 0) {
760 res = snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, "%s", wpaParam->pinCode);
761 if (res < 0) {
762 HDF_LOGE("%{public}s snprintf err2", __func__);
763 return HDF_FAILURE;
764 }
765 }
766 ret = wpa_supplicant_ctrl_iface_wps_pin(wpaSupp, cmd, reply, REPLY_SIZE);
767 if (ret > 0) {
768 *pinCode = atoi(reply);
769 } else {
770 HDF_LOGE("%{public}s wps pin fail!", __func__);
771 return HDF_FAILURE;
772 }
773 return HDF_SUCCESS;
774 }
775
WpaInterfaceWpsCancel(struct IWpaInterface * self,const char * ifName)776 int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName)
777 {
778 struct wpa_supplicant *wpaSupp;
779 int32_t ret = HDF_FAILURE;
780
781 (void)self;
782 if (ifName == NULL) {
783 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
784 return HDF_ERR_INVALID_PARAM;
785 }
786 wpaSupp = getWpaWlan();
787 if (wpaSupp == NULL) {
788 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
789 return HDF_FAILURE;
790 }
791 ret = wpas_wps_cancel(wpaSupp);
792 if (ret != HDF_SUCCESS) {
793 HDF_LOGE("%{public}s set wps pbc cancel fail!", __func__);
794 }
795 return ret;
796 }
797
798 //need to deal countryCodeLen
WpaInterfaceGetCountryCode(struct IWpaInterface * self,const char * ifName,char * countryCode,uint32_t countryCodeLen)799 int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName,
800 char *countryCode, uint32_t countryCodeLen)
801 {
802 struct wpa_supplicant *wpaSupp;
803 int32_t ret = HDF_FAILURE;
804
805 (void)self;
806 HDF_LOGI("enter %{public}s: ", __func__);
807 if (ifName == NULL || countryCode == NULL) {
808 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
809 return HDF_ERR_INVALID_PARAM;
810 }
811 wpaSupp = getWpaWlan();
812 if (wpaSupp == NULL) {
813 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
814 return HDF_FAILURE;
815 }
816 if (wpaSupp->conf->country[0] && wpaSupp->conf->country[1]) {
817 char tmpCountryCode[WIFI_COUNTRY_CODE_MAXLEN + 1] = {0};
818 ret = snprintf_s(tmpCountryCode, WIFI_COUNTRY_CODE_MAXLEN + 1, WIFI_COUNTRY_CODE_MAXLEN, "%c%c",
819 wpaSupp->conf->country[0], wpaSupp->conf->country[1]);
820 if (ret < 0) {
821 HDF_LOGE("%{public}s: snprintf_s is fail", __func__);
822 return HDF_FAILURE;
823 }
824 HDF_LOGI("%{public}s: tmpCountryCode = %s", __func__, tmpCountryCode);
825 if (strcpy_s(countryCode, countryCodeLen, tmpCountryCode) != EOK) {
826 HDF_LOGE("%{public}s: copy countryCode failed!", __func__);
827 return HDF_FAILURE;
828 }
829 }
830 return HDF_SUCCESS;
831 }
832
833 //need to deal valueLen
WpaInterfaceGetNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * param,char * value,uint32_t valueLen)834 int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName,
835 const int32_t networkId, const char *param, char *value, uint32_t valueLen)
836 {
837 struct wpa_supplicant *wpaSupp;
838 char cmd[CMD_SIZE];
839 char reply[REPLY_SIZE] = {0};
840 int replyLen;
841 int32_t ret = HDF_FAILURE;
842
843 (void)self;
844 if (ifName == NULL || param == NULL || value == NULL) {
845 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
846 return HDF_ERR_INVALID_PARAM;
847 }
848 wpaSupp = getWpaWlan();
849 if (wpaSupp == NULL) {
850 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
851 return HDF_FAILURE;
852 }
853 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %s", networkId, param);
854 if (ret < 0) {
855 HDF_LOGE("%{public}s get network fail!", __func__);
856 return HDF_FAILURE;
857 }
858 replyLen = wpa_supplicant_ctrl_iface_get_network(wpaSupp, cmd, reply, REPLY_SIZE);
859 if (strncpy_s(value, valueLen, reply, strlen(reply)) != EOK) {
860 HDF_LOGE("%{public}s copy get_network result failed!", __func__);
861 return HDF_FAILURE;
862 }
863 return HDF_SUCCESS;
864 }
865
WpaInterfaceBlocklistClear(struct IWpaInterface * self,const char * ifName)866 int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName)
867 {
868 struct wpa_supplicant *wpaSupp;
869
870 (void)self;
871 if (ifName == NULL) {
872 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
873 return HDF_ERR_INVALID_PARAM;
874 }
875 wpaSupp = getWpaWlan();
876 if (wpaSupp == NULL) {
877 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
878 return HDF_FAILURE;
879 }
880 wpa_bssid_ignore_clear(wpaSupp);
881 return HDF_SUCCESS;
882 }
883
WpaInterfaceSetSuspendMode(struct IWpaInterface * self,const char * ifName,const int32_t mode)884 int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode)
885 {
886 struct wpa_supplicant *wpaSupp;
887 char cmd[CMD_SIZE];
888 int32_t ret = HDF_FAILURE;
889
890 (void)self;
891 if (ifName == NULL) {
892 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
893 return HDF_ERR_INVALID_PARAM;
894 }
895 wpaSupp = getWpaWlan();
896 if (wpaSupp == NULL) {
897 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
898 return HDF_FAILURE;
899 }
900 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, " %s %d ", "SETSUSPENDMODE", mode);
901 if (ret < 0) {
902 HDF_LOGE("%{public}s set suspend mode fail!", __func__);
903 return HDF_FAILURE;
904 }
905
906 char reply[REPLY_SIZE] = {0};
907 ret = wpa_supplicant_driver_cmd(wpaSupp, cmd, reply, REPLY_SIZE);
908 if (ret >= 0) {
909 ret = HDF_SUCCESS;
910 HDF_LOGI("%{public}s SetSuspendMode success", __func__);
911 } else {
912 ret = HDF_FAILURE;
913 HDF_LOGE("%{public}s SetSuspendMode fail", __func__);
914 }
915 return ret;
916 }
917
WpaGetConnectionCapabilities(struct wpa_supplicant * wpaSupp,struct ConnectionCapabilities * connectionCap)918 static void WpaGetConnectionCapabilities(struct wpa_supplicant *wpaSupp,
919 struct ConnectionCapabilities *connectionCap)
920 {
921 if (wpaSupp->connection_set) {
922 connectionCap->legacyMode = UNKNOWN_MODE;
923 if (wpaSupp->connection_he) {
924 connectionCap->technology = HE;
925 } else if (wpaSupp->connection_vht) {
926 connectionCap->technology = VHT;
927 } else if (wpaSupp->connection_ht) {
928 connectionCap->technology = HT;
929 } else {
930 connectionCap->technology = LEGACY;
931 if (wpas_freq_to_band(wpaSupp->assoc_freq) == BAND_2_4_GHZ) {
932 connectionCap->legacyMode = (wpaSupp->connection_11b_only) ? B_MODE
933 : G_MODE;
934 } else {
935 connectionCap->legacyMode = A_MODE;
936 }
937 }
938 switch (wpaSupp->connection_channel_bandwidth) {
939 case CHAN_WIDTH_20:
940 connectionCap->channelBandwidth = WIDTH_20;
941 break;
942 case CHAN_WIDTH_40:
943 connectionCap->channelBandwidth = WIDTH_40;
944 break;
945 case CHAN_WIDTH_80:
946 connectionCap->channelBandwidth = WIDTH_80;
947 break;
948 case CHAN_WIDTH_160:
949 connectionCap->channelBandwidth = WIDTH_160;
950 break;
951 case CHAN_WIDTH_80P80:
952 connectionCap->channelBandwidth = WIDTH_80P80;
953 break;
954 default:
955 connectionCap->channelBandwidth = WIDTH_20;
956 break;
957 }
958 connectionCap->maxNumberRxSpatialStreams = wpaSupp->connection_max_nss_rx;
959 connectionCap->maxNumberTxSpatialStreams = wpaSupp->connection_max_nss_tx;
960 } else {
961 connectionCap->technology = UNKNOWN_TECHNOLOGY;
962 connectionCap->channelBandwidth = WIDTH_20;
963 connectionCap->maxNumberTxSpatialStreams = 1;
964 connectionCap->maxNumberRxSpatialStreams = 1;
965 connectionCap->legacyMode = UNKNOWN_MODE;
966 }
967 }
968
WpaInterfaceGetConnectionCapabilities(struct IWpaInterface * self,const char * ifName,struct ConnectionCapabilities * connectionCap)969 int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName,
970 struct ConnectionCapabilities *connectionCap)
971 {
972 struct wpa_supplicant *wpaSupp;
973
974 (void)self;
975 if (ifName == NULL || connectionCap == NULL) {
976 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
977 return HDF_ERR_INVALID_PARAM;
978 }
979 wpaSupp = getWpaWlan();
980 if (wpaSupp == NULL) {
981 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
982 return HDF_FAILURE;
983 }
984 WpaGetConnectionCapabilities(wpaSupp, connectionCap);
985 return HDF_SUCCESS;
986 }
987
WpaInterfaceGetScanSsid(struct IWpaInterface * self,const char * ifName,int32_t * enable)988 int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable)
989 {
990 struct wpa_supplicant *wpaSupp;
991 int scanSsid = 0;
992 int32_t ret = HDF_FAILURE;
993
994 (void)self;
995 HDF_LOGI("%{public}s GetScanSsid !", __func__);
996 if (ifName == NULL || enable == NULL) {
997 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
998 return HDF_ERR_INVALID_PARAM;
999 }
1000 wpaSupp = getWpaWlan();
1001 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL)) {
1002 scanSsid = wpaSupp->current_ssid->scan_ssid;
1003 *enable = (scanSsid == 1);
1004 HDF_LOGI("%{public}s GetScanSsid *enable = %{public}d", __func__, *enable);
1005 ret = HDF_SUCCESS ;
1006 } else {
1007 HDF_LOGE("%{public}s GetScanSsid fail", __func__);
1008 }
1009 return ret;
1010 }
1011
WpaInterfaceGetPskPassphrase(struct IWpaInterface * self,const char * ifName,char * psk,uint32_t pskLen)1012 int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName,
1013 char *psk, uint32_t pskLen)
1014 {
1015 struct wpa_supplicant *wpaSupp;
1016 int32_t ret = HDF_FAILURE;
1017
1018 (void)self;
1019 HDF_LOGI("%{public}s GetPskPassphrase !", __func__);
1020 if (ifName == NULL || psk == NULL) {
1021 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1022 return HDF_ERR_INVALID_PARAM;
1023 }
1024 wpaSupp = getWpaWlan();
1025 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL) &&
1026 (wpaSupp->current_ssid->passphrase != NULL)) {
1027 if (strncpy_s(psk, pskLen, wpaSupp->current_ssid->passphrase,
1028 strlen(wpaSupp->current_ssid->passphrase)) != EOK) {
1029 HDF_LOGE("%{public}s copy passphrase failed!", __func__);
1030 return HDF_FAILURE;
1031 }
1032 HDF_LOGI("%{public}s GetPskPassphrase psk = %{public}s", __func__, psk);
1033 ret = HDF_SUCCESS ;
1034 } else {
1035 HDF_LOGE("%{public}s GetPskPassphrase fail", __func__);
1036 }
1037 return ret;
1038 }
WpaInterfaceGetPsk(struct IWpaInterface * self,const char * ifName,uint8_t * psk,uint32_t * pskLen)1039 int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen)
1040 {
1041 struct wpa_supplicant *wpaSupp;
1042 int32_t ret = HDF_FAILURE;
1043
1044 (void)self;
1045 HDF_LOGI("%{public}s WpaInterfaceGetPsk !", __func__);
1046 if (ifName == NULL || psk == NULL || pskLen == NULL) {
1047 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1048 return HDF_ERR_INVALID_PARAM;
1049 }
1050 wpaSupp = getWpaWlan();
1051 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL)) {
1052 *pskLen = sizeof(wpaSupp->current_ssid->psk);
1053 memcpy_s(psk, *pskLen, wpaSupp->current_ssid->psk, *pskLen);
1054 HDF_LOGI("%{public}s GetPsk psk[0] = %{public}d", __func__, psk[0]);
1055 HDF_LOGI("%{public}s GetPsk psk[1] = %{public}d", __func__, psk[1]);
1056 ret = HDF_SUCCESS ;
1057 } else {
1058 HDF_LOGE("%{public}s GetPsk fail", __func__);
1059 }
1060 return ret;
1061 }
1062
WpaInterfaceGetWepKey(struct IWpaInterface * self,const char * ifName,int keyIdx,uint8_t * wepKey,uint32_t * wepKeyLen)1063 int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx,
1064 uint8_t *wepKey, uint32_t *wepKeyLen)
1065 {
1066 struct wpa_supplicant *wpaSupp;
1067 int32_t ret = HDF_FAILURE;
1068
1069 (void)self;
1070 HDF_LOGI("%{public}s WpaInterfaceGetWepKey !", __func__);
1071 if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) {
1072 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1073 return HDF_ERR_INVALID_PARAM;
1074 }
1075 wpaSupp = getWpaWlan();
1076 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL)) {
1077 *wepKeyLen = wpaSupp->current_ssid->wep_key_len[keyIdx];
1078 memcpy_s(wepKey, *wepKeyLen, wpaSupp->current_ssid->wep_key[keyIdx], *wepKeyLen);
1079 HDF_LOGI("%{public}s GetWepKey wepKey[0] = %{public}d", __func__, wepKey[0]);
1080 HDF_LOGI("%{public}s GetWepKey wepKey[1] = %{public}d", __func__, wepKey[1]);
1081 ret = HDF_SUCCESS ;
1082 } else {
1083 HDF_LOGE("%{public}s GetWepKey fail", __func__);
1084 }
1085 return ret;
1086 }
1087
WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface * self,const char * ifName,int * keyIdx)1088 int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx)
1089 {
1090 struct wpa_supplicant *wpaSupp;
1091 int32_t ret = HDF_FAILURE;
1092
1093 (void)self;
1094 HDF_LOGI("%{public}s WpaInterfaceGetWepTxKeyIdx !", __func__);
1095 if (ifName == NULL || keyIdx == NULL) {
1096 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1097 return HDF_ERR_INVALID_PARAM;
1098 }
1099 wpaSupp = getWpaWlan();
1100 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL)) {
1101 *keyIdx = wpaSupp->current_ssid->wep_tx_keyidx;
1102 HDF_LOGI("%{public}s GetWepTxKeyIdx *keyIdx = %{public}d", __func__, *keyIdx);
1103 ret = HDF_SUCCESS ;
1104 } else {
1105 HDF_LOGE("%{public}s GetWepTxKeyIdx fail", __func__);
1106 }
1107 return ret;
1108 }
1109
WpaInterfaceGetRequirePmf(struct IWpaInterface * self,const char * ifName,int * enable)1110 int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable)
1111 {
1112 struct wpa_supplicant *wpaSupp;
1113 int32_t ret = HDF_FAILURE;
1114
1115 (void)self;
1116 HDF_LOGI("%{public}s WpaInterfaceGetWepTxKeyIdx !", __func__);
1117 if (ifName == NULL || enable == NULL) {
1118 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1119 return HDF_ERR_INVALID_PARAM;
1120 }
1121 wpaSupp = getWpaWlan();
1122 if ((wpaSupp != NULL) && (wpaSupp->current_ssid != NULL)) {
1123 *enable = (wpaSupp->current_ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED);
1124 HDF_LOGI("%{public}s GetRequirePmf *enable = %{public}d", __func__, *enable);
1125 ret = HDF_SUCCESS ;
1126 } else {
1127 HDF_LOGE("%{public}s GetRequirePmf fail", __func__);
1128 }
1129 return ret;
1130 }
1131
WpaInterfaceSetCountryCode(struct IWpaInterface * self,const char * ifName,const char * countryCode)1132 int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode)
1133 {
1134 struct wpa_supplicant *wpaSupp;
1135 char cmd[CMD_SIZE] = {0};
1136 int32_t ret = HDF_FAILURE;
1137
1138 (void)self;
1139 if (ifName == NULL || countryCode == NULL) {
1140 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1141 return HDF_ERR_INVALID_PARAM;
1142 }
1143 wpaSupp = getWpaWlan();
1144 if (wpaSupp == NULL) {
1145 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
1146 return HDF_FAILURE;
1147 }
1148 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "COUNTRY %s", countryCode);
1149 if (ret < 0) {
1150 HDF_LOGE("%{public}s set country code fail!", __func__);
1151 return HDF_FAILURE;
1152 }
1153 char reply[REPLY_SIZE] = {0};
1154 ret = wpa_supplicant_driver_cmd(wpaSupp, cmd, reply, REPLY_SIZE);
1155 if (ret >= 0) {
1156 ret = HDF_SUCCESS;
1157 HDF_LOGI("%{public}s SetCountryCode success", __func__);
1158 } else {
1159 ret = HDF_FAILURE;
1160 HDF_LOGE("%{public}s SetCountryCode fail", __func__);
1161 }
1162 return ret;
1163 }
1164
HdfWpaAddRemoteObj(struct IWpaCallback * self)1165 static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self)
1166 {
1167 struct HdfWpaRemoteNode *pos = NULL;
1168 struct DListHead *head = &HdfWpaStubDriver()->remoteListHead;
1169
1170 if (self == NULL) {
1171 HDF_LOGE("%{public}s:self == NULL", __func__);
1172 return HDF_ERR_INVALID_PARAM;
1173 }
1174 if (!DListIsEmpty(head)) {
1175 DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) {
1176 if (pos->service == self->AsObject(self)) {
1177 HDF_LOGE("%{public}s: pos->service == self", __func__);
1178 return HDF_FAILURE;
1179 }
1180 }
1181 }
1182 struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode));
1183 if (newRemoteNode == NULL) {
1184 HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__);
1185 return HDF_FAILURE;
1186 }
1187 newRemoteNode->callbackObj = self;
1188 newRemoteNode->service = self->AsObject(self);
1189 DListInsertTail(&newRemoteNode->node, head);
1190 return HDF_SUCCESS;
1191 }
1192
HdfWpaDelRemoteObj(struct IWpaCallback * self)1193 static void HdfWpaDelRemoteObj(struct IWpaCallback *self)
1194 {
1195 struct HdfWpaRemoteNode *pos = NULL;
1196 struct HdfWpaRemoteNode *tmp = NULL;
1197 struct DListHead *head = &HdfWpaStubDriver()->remoteListHead;
1198
1199 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) {
1200 if (pos->service->index == self->AsObject(self)->index) {
1201 DListRemove(&(pos->node));
1202 IWpaCallbackRelease(pos->callbackObj);
1203 OsalMemFree(pos);
1204 break;
1205 }
1206 }
1207 IWpaCallbackRelease(self);
1208 }
1209
WpaFillWpaDisconnectParam(struct WpaDisconnectParam * disconnectParam,struct HdiWpaDisconnectParam * hdiWpaDisconnectParam)1210 static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam,
1211 struct HdiWpaDisconnectParam *hdiWpaDisconnectParam)
1212 {
1213 int32_t ret = HDF_SUCCESS;
1214
1215 if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) {
1216 HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__);
1217 return HDF_ERR_INVALID_PARAM;
1218 }
1219 hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated;
1220 hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode;
1221 if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen,
1222 disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1223 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1224 ret = HDF_FAILURE;
1225 }
1226 if (ret != HDF_SUCCESS) {
1227 if (hdiWpaDisconnectParam->bssid != NULL) {
1228 OsalMemFree(hdiWpaDisconnectParam->bssid);
1229 }
1230 }
1231 return ret;
1232 }
1233
WpaFillWpaConnectParam(struct WpaConnectParam * connectParam,struct HdiWpaConnectParam * hdiWpaConnectParam)1234 static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam,
1235 struct HdiWpaConnectParam *hdiWpaConnectParam)
1236 {
1237 int32_t ret = HDF_SUCCESS;
1238
1239 if (connectParam == NULL || hdiWpaConnectParam == NULL) {
1240 HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__);
1241 return HDF_ERR_INVALID_PARAM;
1242 }
1243 hdiWpaConnectParam->networkId = connectParam->networkId;
1244 if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen,
1245 connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1246 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1247 ret = HDF_FAILURE;
1248 }
1249 if (ret != HDF_SUCCESS) {
1250 if (hdiWpaConnectParam->bssid != NULL) {
1251 OsalMemFree(hdiWpaConnectParam->bssid);
1252 }
1253 }
1254 return ret;
1255 }
1256
WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam * bssidChangedParam,struct HdiWpaBssidChangedParam * hdiWpaBssidChangedParam)1257 static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam,
1258 struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam)
1259 {
1260 int32_t ret = HDF_SUCCESS;
1261
1262 if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) {
1263 HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__);
1264 return HDF_ERR_INVALID_PARAM;
1265 }
1266 do {
1267 if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen,
1268 bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1269 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1270 ret = HDF_FAILURE;
1271 break;
1272 }
1273 if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen,
1274 bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) {
1275 HDF_LOGE("%{public}s: fill reason fail!", __func__);
1276 ret = HDF_FAILURE;
1277 }
1278 } while (0);
1279 if (ret != HDF_SUCCESS) {
1280 if (hdiWpaBssidChangedParam->bssid != NULL) {
1281 OsalMemFree(hdiWpaBssidChangedParam->bssid);
1282 }
1283 if (hdiWpaBssidChangedParam->reason != NULL) {
1284 OsalMemFree(hdiWpaBssidChangedParam->reason);
1285 }
1286 }
1287 return ret;
1288 }
1289
WpaFillWpaStateChangedParam(struct WpaStateChangedParam * stateChangedParam,struct HdiWpaStateChangedParam * hdiWpaStateChangedParam)1290 static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam,
1291 struct HdiWpaStateChangedParam *hdiWpaStateChangedParam)
1292 {
1293 int32_t ret = HDF_SUCCESS;
1294
1295 if (stateChangedParam == NULL || hdiWpaStateChangedParam == NULL) {
1296 HDF_LOGE("%{public}s: stateChangedParam or hdiWpaStateChangedParam is NULL!", __func__);
1297 return HDF_ERR_INVALID_PARAM;
1298 }
1299 hdiWpaStateChangedParam->networkId = stateChangedParam->networkId;
1300 HDF_LOGD("%{public}s: hdiWpaStateChangedParam->networkId =%d", __func__, hdiWpaStateChangedParam->networkId);
1301 hdiWpaStateChangedParam->status = stateChangedParam->status;
1302 HDF_LOGD("%{public}s: hdiWpaStateChangedParam->status =%d", __func__, hdiWpaStateChangedParam->status);
1303 do {
1304 HDF_LOGD("%{public}s: stateChangedParam->bssid[0] = %x", __func__, stateChangedParam->bssid[0]);
1305 HDF_LOGD("%{public}s: stateChangedParam->bssid[5] = %x", __func__,
1306 stateChangedParam->bssid[WIFI_BSSID_LEN - 1]);
1307 if (FillData(&hdiWpaStateChangedParam->bssid, &hdiWpaStateChangedParam->bssidLen,
1308 stateChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1309 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1310 ret = HDF_FAILURE;
1311 break;
1312 }
1313 HDF_LOGD("%{public}s: stateChangedParam->ssid[0] = %x", __func__, stateChangedParam->ssid[0]);
1314 HDF_LOGD("%{public}s: stateChangedParam->ssid[WIFI_SSID_LENGTH-1] = %x", __func__,
1315 stateChangedParam->ssid[WIFI_SSID_LENGTH - 1]);
1316 if (memcmp(stateChangedParam->ssid, "\0", 1) == 0) {
1317 hdiWpaStateChangedParam->ssidLen = 0;
1318 HDF_LOGE("%{public}s: hdiWpaStateChangedParam->ssidLen =%d", __func__, hdiWpaStateChangedParam->ssidLen);
1319 } else {
1320 if (FillData(&hdiWpaStateChangedParam->ssid, &hdiWpaStateChangedParam->ssidLen,
1321 stateChangedParam->ssid, strlen((char*)stateChangedParam->ssid)) != HDF_SUCCESS) {
1322 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1323 ret = HDF_FAILURE;
1324 }
1325 }
1326 } while (0);
1327 if (ret != HDF_SUCCESS) {
1328 if (hdiWpaStateChangedParam->bssid != NULL) {
1329 OsalMemFree(hdiWpaStateChangedParam->bssid);
1330 }
1331 if (hdiWpaStateChangedParam->ssid != NULL) {
1332 OsalMemFree(hdiWpaStateChangedParam->ssid);
1333 }
1334 }
1335 return ret;
1336 }
1337
WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam * tempDisabledParam,struct HdiWpaTempDisabledParam * hdiWpaTempDisabledParam)1338 static int32_t WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam *tempDisabledParam,
1339 struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam)
1340 {
1341 int32_t ret = HDF_SUCCESS;
1342
1343 if (tempDisabledParam == NULL || hdiWpaTempDisabledParam == NULL) {
1344 HDF_LOGE("%{public}s: tempDisabledParam or hdiWpaTempDisabledParam is NULL!", __func__);
1345 return HDF_ERR_INVALID_PARAM;
1346 }
1347 hdiWpaTempDisabledParam->networkId = tempDisabledParam->networkId;
1348 hdiWpaTempDisabledParam->authFailures = tempDisabledParam->authFailures;
1349 hdiWpaTempDisabledParam->duration = tempDisabledParam->duration;
1350 do {
1351 if (FillData(&hdiWpaTempDisabledParam->reason, &hdiWpaTempDisabledParam->reasonLen,
1352 tempDisabledParam->reason, strlen((char*)tempDisabledParam->reason)) != HDF_SUCCESS) {
1353 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1354 ret = HDF_FAILURE;
1355 break;
1356 }
1357 if (FillData(&hdiWpaTempDisabledParam->ssid, &hdiWpaTempDisabledParam->ssidLen,
1358 tempDisabledParam->ssid, strlen((char*)tempDisabledParam->ssid)) != HDF_SUCCESS) {
1359 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1360 ret = HDF_FAILURE;
1361 }
1362 } while (0);
1363 if (ret != HDF_SUCCESS) {
1364 if (hdiWpaTempDisabledParam->reason != NULL) {
1365 OsalMemFree(hdiWpaTempDisabledParam->reason);
1366 }
1367 if (hdiWpaTempDisabledParam->ssid != NULL) {
1368 OsalMemFree(hdiWpaTempDisabledParam->ssid);
1369 }
1370 }
1371 return ret;
1372 }
1373
WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam * associateRejectParam,struct HdiWpaAssociateRejectParam * hdiWpaAssociateRejectParam)1374 static int32_t WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam *associateRejectParam,
1375 struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam)
1376 {
1377 int32_t ret = HDF_SUCCESS;
1378
1379 if (associateRejectParam == NULL || hdiWpaAssociateRejectParam == NULL) {
1380 HDF_LOGE("%{public}s: associateRejectParam or hdiWpaAssociateRejectParam is NULL!", __func__);
1381 return HDF_ERR_INVALID_PARAM;
1382 }
1383 hdiWpaAssociateRejectParam->statusCode = associateRejectParam->statusCode;
1384 hdiWpaAssociateRejectParam->timeOut = associateRejectParam->timeOut;
1385 if (FillData(&hdiWpaAssociateRejectParam->bssid, &hdiWpaAssociateRejectParam->bssidLen,
1386 associateRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1387 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1388 ret = HDF_FAILURE;
1389 }
1390 if (ret != HDF_SUCCESS) {
1391 if (hdiWpaAssociateRejectParam->bssid != NULL) {
1392 OsalMemFree(hdiWpaAssociateRejectParam->bssid);
1393 }
1394 }
1395 return ret;
1396 }
1397
WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam * recvScanResultParam,struct HdiWpaRecvScanResultParam * hdiWpaRecvScanResultParam)1398 static int32_t WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam *recvScanResultParam,
1399 struct HdiWpaRecvScanResultParam *hdiWpaRecvScanResultParam)
1400 {
1401 int32_t ret = HDF_SUCCESS;
1402
1403 if (recvScanResultParam == NULL || hdiWpaRecvScanResultParam == NULL) {
1404 HDF_LOGE("%{public}s: recvScanResultParam or hdiWpaRecvScanResultParam is NULL!", __func__);
1405 return HDF_ERR_INVALID_PARAM;
1406 }
1407 hdiWpaRecvScanResultParam->scanId = recvScanResultParam->scanId;
1408 return ret;
1409 }
1410
WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam * authRejectParam,struct HdiWpaAuthRejectParam * hdiWpaAuthRejectParam)1411 static int32_t WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam *authRejectParam,
1412 struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam)
1413 {
1414 int32_t ret = HDF_SUCCESS;
1415
1416 if (authRejectParam == NULL || hdiWpaAuthRejectParam == NULL) {
1417 HDF_LOGE("%{public}s: authRejectParam or hdiWpaAuthRejectParam is NULL!", __func__);
1418 return HDF_ERR_INVALID_PARAM;
1419 }
1420 hdiWpaAuthRejectParam->statusCode = authRejectParam->statusCode;
1421 hdiWpaAuthRejectParam->authType = authRejectParam->authType;
1422 hdiWpaAuthRejectParam->authTransaction = authRejectParam->authTransaction;
1423 if (FillData(&hdiWpaAuthRejectParam->bssid, &hdiWpaAuthRejectParam->bssidLen,
1424 authRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1425 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1426 ret = HDF_FAILURE;
1427 }
1428 if (ret != HDF_SUCCESS) {
1429 if (hdiWpaAuthRejectParam->bssid != NULL) {
1430 OsalMemFree(hdiWpaAuthRejectParam->bssid);
1431 }
1432 }
1433 return ret;
1434 }
1435
ProcessEventWpaDisconnect(struct HdfWpaRemoteNode * node,struct WpaDisconnectParam * disconnectParam,const char * ifName)1436 static int32_t ProcessEventWpaDisconnect(struct HdfWpaRemoteNode *node,
1437 struct WpaDisconnectParam *disconnectParam, const char *ifName)
1438 {
1439 struct HdiWpaDisconnectParam *hdiWpaDisconnectParam = NULL;
1440 int32_t ret = HDF_FAILURE;
1441
1442 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDisconnected == NULL) {
1443 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1444 return HDF_ERR_INVALID_PARAM;
1445 }
1446 hdiWpaDisconnectParam = (struct HdiWpaDisconnectParam *)OsalMemCalloc(sizeof(struct HdiWpaDisconnectParam));
1447 if ((hdiWpaDisconnectParam == NULL) || (WpaFillWpaDisconnectParam(disconnectParam,
1448 hdiWpaDisconnectParam) != HDF_SUCCESS)) {
1449 HDF_LOGE("%{public}s: hdiWpaDisconnectParam is NULL or disconnectParam fialed!", __func__);
1450 } else {
1451 ret = node->callbackObj->OnEventDisconnected(node->callbackObj, hdiWpaDisconnectParam, ifName);
1452 }
1453 HdiWpaDisconnectParamFree(hdiWpaDisconnectParam, true);
1454 return ret;
1455 }
1456
ProcessEventWpaConnect(struct HdfWpaRemoteNode * node,struct WpaConnectParam * connectParam,const char * ifName)1457 static int32_t ProcessEventWpaConnect(struct HdfWpaRemoteNode *node,
1458 struct WpaConnectParam *connectParam, const char *ifName)
1459 {
1460 struct HdiWpaConnectParam *hdiWpaConnectParam = NULL;
1461 int32_t ret = HDF_FAILURE;
1462
1463 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventConnected == NULL) {
1464 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1465 return HDF_ERR_INVALID_PARAM;
1466 }
1467 hdiWpaConnectParam = (struct HdiWpaConnectParam *)OsalMemCalloc(sizeof(struct HdiWpaConnectParam));
1468 if ((hdiWpaConnectParam == NULL) || (WpaFillWpaConnectParam(connectParam, hdiWpaConnectParam) != HDF_SUCCESS)) {
1469 HDF_LOGE("%{public}s: HdiWpaConnectParam is NULL or connectParam fialed!", __func__);
1470 } else {
1471 ret = node->callbackObj->OnEventConnected(node->callbackObj, hdiWpaConnectParam, ifName);
1472 }
1473 HdiWpaConnectParamFree(hdiWpaConnectParam, true);
1474 return ret;
1475 }
1476
ProcessEventWpaBssidChange(struct HdfWpaRemoteNode * node,struct WpaBssidChangedParam * bssidChangeParam,const char * ifName)1477 static int32_t ProcessEventWpaBssidChange(struct HdfWpaRemoteNode *node,
1478 struct WpaBssidChangedParam *bssidChangeParam, const char *ifName)
1479 {
1480 struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam = NULL;
1481 int32_t ret = HDF_FAILURE;
1482 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventBssidChanged == NULL) {
1483 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1484 return HDF_ERR_INVALID_PARAM;
1485 }
1486 hdiWpaBssidChangedParam = (struct HdiWpaBssidChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaBssidChangedParam));
1487 if ((hdiWpaBssidChangedParam == NULL) || (WpaFillWpaBssidChangedParam(bssidChangeParam,
1488 hdiWpaBssidChangedParam) != HDF_SUCCESS)) {
1489 HDF_LOGE("%{public}s: hdiWpaBssidChangedParam is NULL or bssidChangeParam fialed!", __func__);
1490 } else {
1491 ret = node->callbackObj->OnEventBssidChanged(node->callbackObj, hdiWpaBssidChangedParam, ifName);
1492 }
1493 HdiWpaBssidChangedParamFree(hdiWpaBssidChangedParam, true);
1494 return ret;
1495 }
1496
ProcessEventWpaStateChange(struct HdfWpaRemoteNode * node,struct WpaStateChangedParam * stateChangeParam,const char * ifName)1497 static int32_t ProcessEventWpaStateChange(struct HdfWpaRemoteNode *node,
1498 struct WpaStateChangedParam *stateChangeParam, const char *ifName)
1499 {
1500 struct HdiWpaStateChangedParam *hdiWpaStateChangedParam = NULL;
1501 int32_t ret = HDF_FAILURE;
1502
1503 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStateChanged == NULL) {
1504 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1505 return HDF_ERR_INVALID_PARAM;
1506 }
1507 hdiWpaStateChangedParam = (struct HdiWpaStateChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaStateChangedParam));
1508 if ((hdiWpaStateChangedParam == NULL) || (WpaFillWpaStateChangedParam(stateChangeParam,
1509 hdiWpaStateChangedParam) != HDF_SUCCESS)) {
1510 HDF_LOGE("%{public}s: hdiWpaStateChangedParam is NULL or stateChangeParam fialed!", __func__);
1511 } else {
1512 ret = node->callbackObj->OnEventStateChanged(node->callbackObj, hdiWpaStateChangedParam, ifName);
1513 }
1514 HdiWpaStateChangedParamFree(hdiWpaStateChangedParam, true);
1515 return ret;
1516 }
1517
ProcessEventWpaTempDisable(struct HdfWpaRemoteNode * node,struct WpaTempDisabledParam * tempDisabledParam,const char * ifName)1518 static int32_t ProcessEventWpaTempDisable(struct HdfWpaRemoteNode *node,
1519 struct WpaTempDisabledParam *tempDisabledParam, const char *ifName)
1520 {
1521 struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam = NULL;
1522 int32_t ret = HDF_FAILURE;
1523
1524 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventTempDisabled == NULL) {
1525 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1526 return HDF_ERR_INVALID_PARAM;
1527 }
1528 hdiWpaTempDisabledParam = (struct HdiWpaTempDisabledParam *)OsalMemCalloc(sizeof(struct HdiWpaTempDisabledParam));
1529 if ((hdiWpaTempDisabledParam == NULL) || (WpaFillWpaTempDisabledParam(tempDisabledParam,
1530 hdiWpaTempDisabledParam) != HDF_SUCCESS)) {
1531 HDF_LOGE("%{public}s: hdiWpaTempDisabledParam is NULL or tempDisabledParam fialed!", __func__);
1532 } else {
1533 ret = node->callbackObj->OnEventTempDisabled(node->callbackObj, hdiWpaTempDisabledParam, ifName);
1534 }
1535 HdiWpaTempDisabledParamFree(hdiWpaTempDisabledParam, true);
1536 return ret;
1537 }
1538
ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode * node,struct WpaAssociateRejectParam * associateRejectParam,const char * ifName)1539 static int32_t ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode *node,
1540 struct WpaAssociateRejectParam *associateRejectParam, const char *ifName)
1541 {
1542 struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam = NULL;
1543 int32_t ret = HDF_FAILURE;
1544
1545 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAssociateReject == NULL) {
1546 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1547 return HDF_ERR_INVALID_PARAM;
1548 }
1549 hdiWpaAssociateRejectParam = (struct HdiWpaAssociateRejectParam *)
1550 OsalMemCalloc(sizeof(struct HdiWpaAssociateRejectParam));
1551 if ((hdiWpaAssociateRejectParam == NULL) || (WpaFillWpaAssociateRejectParam(associateRejectParam,
1552 hdiWpaAssociateRejectParam) != HDF_SUCCESS)) {
1553 HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__);
1554 } else {
1555 ret = node->callbackObj->OnEventAssociateReject(node->callbackObj, hdiWpaAssociateRejectParam, ifName);
1556 }
1557 HdiWpaAssociateRejectParamFree(hdiWpaAssociateRejectParam, true);
1558 return ret;
1559 }
1560
ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode * node,const char * ifName)1561 static int32_t ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode *node,
1562 const char *ifName)
1563 {
1564 int32_t ret = HDF_FAILURE;
1565
1566 if (node == NULL || node->callbackObj == NULL) {
1567 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1568 return HDF_ERR_INVALID_PARAM;
1569 }
1570 ret = node->callbackObj->OnEventWpsOverlap(node->callbackObj, ifName);
1571 return ret;
1572 }
1573
ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode * node,const char * ifName)1574 static int32_t ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode *node,
1575 const char *ifName)
1576 {
1577 int32_t ret = HDF_FAILURE;
1578
1579 if (node == NULL || node->callbackObj == NULL) {
1580 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1581 return HDF_ERR_INVALID_PARAM;
1582 }
1583 ret = node->callbackObj->OnEventWpsTimeout(node->callbackObj, ifName);
1584 return ret;
1585 }
1586
ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode * node,struct WpaRecvScanResultParam * recvScanResultParam,const char * ifName)1587 static int32_t ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode *node,
1588 struct WpaRecvScanResultParam *recvScanResultParam, const char *ifName)
1589 {
1590 struct HdiWpaRecvScanResultParam *hdiRecvScanResultParam = NULL;
1591 int32_t ret = HDF_FAILURE;
1592
1593 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventScanResult == NULL) {
1594 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1595 return HDF_ERR_INVALID_PARAM;
1596 }
1597 hdiRecvScanResultParam = (struct HdiWpaRecvScanResultParam *)
1598 OsalMemCalloc(sizeof(struct HdiWpaRecvScanResultParam));
1599 if ((hdiRecvScanResultParam == NULL) || (WpaFillWpaRecvScanResultParam(recvScanResultParam,
1600 hdiRecvScanResultParam) != HDF_SUCCESS)) {
1601 HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__);
1602 } else {
1603 ret = node->callbackObj->OnEventScanResult(node->callbackObj, hdiRecvScanResultParam, ifName);
1604 }
1605 HdiWpaRecvScanResultParamFree(hdiRecvScanResultParam, true);
1606 return ret;
1607 }
1608
ProcessEventWpaAuthReject(struct HdfWpaRemoteNode * node,struct WpaAuthRejectParam * authRejectParam,const char * ifName)1609 static int32_t ProcessEventWpaAuthReject(
1610 struct HdfWpaRemoteNode *node, struct WpaAuthRejectParam *authRejectParam, const char *ifName)
1611 {
1612 struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam = NULL;
1613 int32_t ret = HDF_FAILURE;
1614
1615 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAuthReject == NULL) {
1616 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1617 return HDF_ERR_INVALID_PARAM;
1618 }
1619 hdiWpaAuthRejectParam =
1620 (struct HdiWpaAuthRejectParam *)OsalMemCalloc(sizeof(struct HdiWpaAuthRejectParam));
1621 if ((hdiWpaAuthRejectParam == NULL) ||
1622 (WpaFillWpaAuthRejectParam(authRejectParam, hdiWpaAuthRejectParam) != HDF_SUCCESS)) {
1623 HDF_LOGE("%{public}s: hdiWpaAuthRejectParam is NULL or authRejectParam fialed!", __func__);
1624 } else {
1625 ret = node->callbackObj->OnEventAuthReject(node->callbackObj, hdiWpaAuthRejectParam, ifName);
1626 }
1627 HdiWpaAuthRejectParamFree(hdiWpaAuthRejectParam, true);
1628 return ret;
1629 }
1630
ProcessEventStaNotify(struct HdfWpaRemoteNode * node,char * notifyParam,const char * ifName)1631 int32_t ProcessEventStaNotify(struct HdfWpaRemoteNode *node, char *notifyParam, const char *ifName)
1632 {
1633 int32_t ret = HDF_FAILURE;
1634 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaNotify == NULL) {
1635 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
1636 return HDF_ERR_INVALID_PARAM;
1637 }
1638 return ret;
1639 }
1640
HdfWpaDealEvent(uint32_t event,struct HdfWpaRemoteNode * pos,void * data,const char * ifName)1641 static int32_t HdfWpaDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName)
1642 {
1643 int32_t ret = HDF_FAILURE;
1644 switch (event) {
1645 case WPA_EVENT_DISCONNECT:
1646 ret = ProcessEventWpaDisconnect(pos, (struct WpaDisconnectParam *)data, ifName);
1647 break;
1648 case WPA_EVENT_CONNECT:
1649 ret = ProcessEventWpaConnect(pos, (struct WpaConnectParam *)data, ifName);
1650 break;
1651 case WPA_EVENT_BSSID_CHANGE:
1652 ret = ProcessEventWpaBssidChange(pos, (struct WpaBssidChangedParam *)data, ifName);
1653 break;
1654 case WPA_EVENT_STATE_CHANGED:
1655 ret = ProcessEventWpaStateChange(pos, (struct WpaStateChangedParam *)data, ifName);
1656 break;
1657 case WPA_EVENT_TEMP_DISABLE:
1658 ret = ProcessEventWpaTempDisable(pos, (struct WpaTempDisabledParam *)data, ifName);
1659 break;
1660 case WPA_EVENT_ASSOCIATE_REJECT:
1661 ret = ProcessEventWpaAssociateReject(pos, (struct WpaAssociateRejectParam *)data, ifName);
1662 break;
1663 case WPA_EVENT_WPS_OVERLAP:
1664 ret = ProcessEventWpaWpsOverlap(pos, ifName);
1665 break;
1666 case WPA_EVENT_WPS_TIMEMOUT:
1667 ret = ProcessEventWpaWpsTimeout(pos, ifName);
1668 break;
1669 case WPA_EVENT_RECV_SCAN_RESULT:
1670 ret = ProcessEventWpaRecvScanResult(pos, (struct WpaRecvScanResultParam *)data, ifName);
1671 break;
1672 case WPA_EVENT_DEVICE_FOUND:
1673 ret = ProcessEventP2pDeviceFound(pos, (struct P2pDeviceInfoParam *)data, ifName);
1674 break;
1675 case WPA_EVENT_DEVICE_LOST:
1676 ret = ProcessEventP2pDeviceLost(pos, (struct P2pDeviceLostParam *)data, ifName);
1677 break;
1678 case WPA_EVENT_GO_NEGOTIATION_REQUEST:
1679 ret = ProcessEventP2pGoNegotiationRequest(pos, (struct P2pGoNegotiationRequestParam *)data, ifName);
1680 break;
1681 case WPA_EVENT_GO_NEGOTIATION_COMPLETED:
1682 ret = ProcessEventP2pGoNegotiationCompleted(pos, (struct P2pGoNegotiationCompletedParam *)data, ifName);
1683 break;
1684 case WPA_EVENT_INVITATION_RECEIVED:
1685 ret = ProcessEventP2pInvitationReceived(pos, (struct P2pInvitationReceivedParam *)data, ifName);
1686 break;
1687 case WPA_EVENT_INVITATION_RESULT:
1688 ret = ProcessEventP2pInvitationResult(pos, (struct P2pInvitationResultParam *)data, ifName);
1689 break;
1690 case WPA_EVENT_GROUP_FORMATION_SUCCESS:
1691 ret = ProcessEventP2pGroupFormationSuccess(pos, ifName);
1692 break;
1693 case WPA_EVENT_GROUP_FORMATION_FAILURE:
1694 ret = ProcessEventP2pGroupFormationFailure(pos, (char *)data, ifName);
1695 break;
1696 case WPA_EVENT_GROUP_START:
1697 ret = ProcessEventP2pGroupStarted(pos, (struct P2pGroupStartedParam *)data, ifName);
1698 break;
1699 case WPA_EVENT_GROUP_REMOVED:
1700 ret = ProcessEventP2pGroupRemoved(pos, (struct P2pGroupRemovedParam *)data, ifName);
1701 break;
1702 case WPA_EVENT_PROVISION_DISCOVERY_COMPLETED:
1703 ret = ProcessEventP2pProvisionDiscoveryCompleted(pos, (struct P2pProvisionDiscoveryCompletedParam *)data,
1704 ifName);
1705 break;
1706 case WPA_EVENT_FIND_STOPPED:
1707 ret = ProcessEventP2pFindStopped(pos, ifName);
1708 break;
1709 case WPA_EVENT_SERV_DISC_REQ:
1710 ret = ProcessEventP2pServDiscReq(pos, (struct P2pServDiscReqInfoParam *)data, ifName);
1711 break;
1712 case WPA_EVENT_SERV_DISC_RESP:
1713 ret = ProcessEventP2pServDiscResp(pos, (struct P2pServDiscRespParam *)data, ifName);
1714 break;
1715 case WPA_EVENT_STA_CONNECT_STATE:
1716 ret = ProcessEventP2pStaConnectState(pos, (struct P2pStaConnectStateParam *)data, ifName);
1717 break;
1718 case WPA_EVENT_IFACE_CREATED:
1719 ret = ProcessEventP2pIfaceCreated(pos, (struct P2pIfaceCreatedParam *)data, ifName);
1720 break;
1721 case WPA_EVENT_STA_AUTH_REJECT:
1722 ret = ProcessEventWpaAuthReject(pos, (struct WpaAuthRejectParam *)data, ifName);
1723 break;
1724 case WPA_EVENT_STA_NOTIFY:
1725 ret = ProcessEventStaNotify(pos, (char *)data, ifName);
1726 break;
1727 default:
1728 HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event);
1729 break;
1730 }
1731 return ret;
1732 }
1733
HdfWpaCallbackFun(uint32_t event,void * data,const char * ifName)1734 static int32_t HdfWpaCallbackFun(uint32_t event, void *data, const char *ifName)
1735 {
1736 struct HdfWpaRemoteNode *pos = NULL;
1737 struct DListHead *head = NULL;
1738 int32_t ret = HDF_FAILURE;
1739
1740 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex);
1741 head = &HdfWpaStubDriver()->remoteListHead;
1742 HDF_LOGD("%s: enter HdfWpaCallbackFun event =%d", __FUNCTION__, event);
1743 if (ifName == NULL) {
1744 HDF_LOGE("%{public}s: data or ifName is NULL!", __func__);
1745 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex);
1746 return HDF_ERR_INVALID_PARAM;
1747 }
1748 DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) {
1749 if (pos == NULL) {
1750 HDF_LOGE("%{public}s: pos is NULL", __func__);
1751 break;
1752 }
1753 if (pos->service == NULL || pos->callbackObj == NULL) {
1754 HDF_LOGW("%{public}s: pos->service or pos->callbackObj NULL", __func__);
1755 continue;
1756 }
1757 ret = HdfWpaDealEvent(event, pos, data, ifName);
1758 if (ret != HDF_SUCCESS) {
1759 HDF_LOGE("%{public}s: dispatch code fialed, error code: %{public}d", __func__, ret);
1760 }
1761 }
1762 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex);
1763 return ret;
1764 }
1765
WpaInterfaceRegisterEventCallback(struct IWpaInterface * self,struct IWpaCallback * cbFunc,const char * ifName)1766 int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc,
1767 const char *ifName)
1768 {
1769 int32_t ret = HDF_FAILURE;
1770
1771 (void)self;
1772 if (cbFunc == NULL || ifName == NULL) {
1773 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1774 return HDF_ERR_INVALID_PARAM;
1775 }
1776 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex);
1777 do {
1778 HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__);
1779 ret = HdfWpaAddRemoteObj(cbFunc);
1780 if (ret != HDF_SUCCESS) {
1781 HDF_LOGE("%{public}s: HdfSensorAddRemoteObj false", __func__);
1782 break;
1783 }
1784 ret = WpaRegisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName);
1785 if (ret != HDF_SUCCESS) {
1786 HDF_LOGE("%{public}s: Register failed!, error code: %{public}d", __func__, ret);
1787 HdfWpaDelRemoteObj(cbFunc);
1788 break;
1789 }
1790 } while (0);
1791 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex);
1792 return ret;
1793 }
1794
WpaInterfaceUnregisterEventCallback(struct IWpaInterface * self,struct IWpaCallback * cbFunc,const char * ifName)1795 int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc,
1796 const char *ifName)
1797 {
1798 int32_t ret = HDF_FAILURE;
1799
1800 (void)self;
1801 if (cbFunc == NULL || ifName == NULL) {
1802 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1803 return HDF_ERR_INVALID_PARAM;
1804 }
1805 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex);
1806 HdfWpaDelRemoteObj(cbFunc);
1807 if (DListIsEmpty(&HdfWpaStubDriver()->remoteListHead)) {
1808 ret = WpaUnregisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName);
1809 if (ret != HDF_SUCCESS) {
1810 HDF_LOGE("%{public}s: Unregister failed!, error code: %{public}d", __func__, ret);
1811 }
1812 }
1813 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex);
1814 return HDF_SUCCESS;
1815 }
1816
SplitCmdString(const char * startCmd,struct StWpaMainParam * pParam)1817 static void SplitCmdString(const char *startCmd, struct StWpaMainParam *pParam)
1818 {
1819 if (pParam == NULL) {
1820 return;
1821 }
1822 if (startCmd == NULL) {
1823 pParam->argc = 0;
1824 return;
1825 }
1826 const char *p = startCmd;
1827 int i = 0;
1828 int j = 0;
1829 while (*p != '\0') {
1830 if (*p == ' ') {
1831 if (j <= MAX_WPA_MAIN_ARGV_LEN - 1) {
1832 pParam->argv[i][j] = '\0';
1833 } else {
1834 pParam->argv[i][MAX_WPA_MAIN_ARGV_LEN - 1] = '\0';
1835 }
1836 ++i;
1837 j = 0;
1838 if (i >= MAX_WPA_MAIN_ARGC_NUM) {
1839 break;
1840 }
1841 } else {
1842 if (j < MAX_WPA_MAIN_ARGV_LEN - 1) {
1843 pParam->argv[i][j] = *p;
1844 ++j;
1845 }
1846 }
1847 ++p;
1848 }
1849 if (i >= MAX_WPA_MAIN_ARGC_NUM) {
1850 pParam->argc = MAX_WPA_MAIN_ARGC_NUM;
1851 } else {
1852 pParam->argc = i + 1;
1853 }
1854 return;
1855 }
1856
1857
WpaThreadMain(void * p)1858 static void *WpaThreadMain(void *p)
1859 {
1860 const char *startCmd;
1861 struct StWpaMainParam param = {0};
1862 char *tmpArgv[MAX_WPA_MAIN_ARGC_NUM] = {0};
1863
1864 if (p == NULL) {
1865 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1866 return NULL;
1867 }
1868 startCmd = (const char *)p;
1869 SplitCmdString(startCmd, ¶m);
1870 for (int i = 0; i < param.argc; i++) {
1871 tmpArgv[i] = param.argv[i];
1872 }
1873 int ret = wpa_main(param.argc, tmpArgv);
1874 HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret);
1875 return NULL;
1876 }
1877
StartWpaSupplicant(const char * moduleName,const char * startCmd)1878 static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd)
1879 {
1880 int32_t ret;
1881
1882 if (moduleName == NULL || startCmd == NULL) {
1883 HDF_LOGE("%{public}s input parameter invalid!", __func__);
1884 return HDF_ERR_INVALID_PARAM ;
1885 }
1886 ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd);
1887 if (ret != HDF_SUCCESS) {
1888 HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret);
1889 return HDF_FAILURE;
1890 }
1891 pthread_setname_np(g_tid, "WpaMainThread");
1892 HDF_LOGI("%{public}s: pthread_create ID: %{public}p.", __func__, (void*)g_tid);
1893 usleep(WPA_SLEEP_TIME);
1894 return HDF_SUCCESS;
1895 }
1896
WpaInterfaceAddWpaIface(struct IWpaInterface * self,const char * ifName,const char * confName)1897 int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName)
1898 {
1899 HDF_LOGI("%{public}s Ready to add iface, ifName: %{public}s, confName: %{public}s", __func__, ifName, confName);
1900 struct wpa_global *wpa_g;
1901 int32_t ret;
1902 int32_t result;
1903 char cmd[WPA_CMD_BUF_LEN] = {0};
1904
1905 (void)self;
1906 if (ifName == NULL || confName == NULL) {
1907 HDF_LOGE("%{public}s input parameter invalid!", __func__);
1908 return HDF_ERR_INVALID_PARAM ;
1909 }
1910 wpa_g = getWpaGlobal();
1911 if (wpa_g == NULL) {
1912 HDF_LOGE("%{public}s: wpa_g is null.", __func__);
1913 return HDF_FAILURE;
1914 }
1915 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s\t%s", ifName, confName);
1916 if (ret < 0) {
1917 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1918 return HDF_FAILURE;
1919 }
1920 result = wpa_supplicant_global_iface_add(wpa_g, cmd);
1921 if (result != HDF_SUCCESS) {
1922 HDF_LOGE("%{public}s add interface failed, cmd: %{public}s, result: %{public}d", __func__, cmd, result);
1923 return HDF_FAILURE;
1924 }
1925 HDF_LOGI("%{public}s Add interface finish, cmd: %{public}s", __func__, cmd);
1926 return HDF_SUCCESS;
1927 }
1928
WpaInterfaceRemoveWpaIface(struct IWpaInterface * self,const char * ifName)1929 int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName)
1930 {
1931 struct wpa_global *wpa_g;
1932 char *name;
1933
1934 (void)self;
1935 if (ifName == NULL) {
1936 HDF_LOGE("%{public}s input parameter invalid!", __func__);
1937 return HDF_ERR_INVALID_PARAM ;
1938 }
1939 wpa_g = getWpaGlobal();
1940 if (wpa_g == NULL) {
1941 HDF_LOGE("%{public}s: wpa_g is null.", __func__);
1942 return HDF_FAILURE;
1943 }
1944 name = strdup(ifName);
1945 if (wpa_supplicant_global_iface_remove(wpa_g, name) != HDF_SUCCESS) {
1946 HDF_LOGE("%{public}s: Failed to remove wpa iface!", __func__);
1947 free(name);
1948 return HDF_FAILURE;
1949 }
1950 free(name);
1951 HDF_LOGI("%{public}s remove wpa interface finish, ifName: %{public}s", __func__, ifName);
1952 return HDF_SUCCESS;
1953 }
1954
StopWpaSupplicant(void)1955 static int32_t StopWpaSupplicant(void)
1956 {
1957 struct wpa_global *wpa_g;
1958 int32_t ret;
1959
1960 wpa_g = getWpaGlobal();
1961 if (wpa_g == NULL) {
1962 HDF_LOGE("%{public}s: wpa_g is null.", __func__);
1963 return HDF_FAILURE;
1964 }
1965 wpa_supplicant_terminate_proc(wpa_g);
1966 ret = pthread_join(g_tid, NULL);
1967 if (ret == HDF_SUCCESS) {
1968 HDF_LOGI("%{public}s: WpaMainThread has been killed.", __func__);
1969 }
1970 HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__);
1971 return HDF_SUCCESS;
1972 }
1973
WpaInterfaceStart(struct IWpaInterface * self)1974 int32_t WpaInterfaceStart(struct IWpaInterface *self)
1975 {
1976 int32_t ret;
1977
1978 (void)self;
1979 ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD);
1980 if (ret != HDF_SUCCESS) {
1981 HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret);
1982 return HDF_FAILURE;
1983 }
1984 HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__);
1985 return HDF_SUCCESS;
1986 }
1987
WpaInterfaceStop(struct IWpaInterface * self)1988 int32_t WpaInterfaceStop(struct IWpaInterface *self)
1989 {
1990 int32_t ret;
1991
1992 (void)self;
1993 ret = StopWpaSupplicant();
1994 if (ret != HDF_SUCCESS) {
1995 HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret);
1996 return HDF_FAILURE;
1997 }
1998 HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__);
1999 return HDF_SUCCESS;
2000 }
2001
WpaInterfaceReassociate(struct IWpaInterface * self,const char * ifName)2002 int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName)
2003 {
2004 struct wpa_supplicant *wpaSupp;
2005
2006 (void)self;
2007 if (ifName == NULL) {
2008 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
2009 return HDF_ERR_INVALID_PARAM;
2010 }
2011 wpaSupp = getWpaWlan();
2012 if (wpaSupp == NULL) {
2013 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
2014 return HDF_FAILURE;
2015 }
2016 if (wpaSupp->wpa_state == WPA_INTERFACE_DISABLED) {
2017 return HDF_FAILURE;
2018 }
2019 wpas_request_connection(wpaSupp);
2020 return HDF_SUCCESS;
2021 }
2022
WpaInterfaceStaShellCmd(struct IWpaInterface * self,const char * ifName,const char * cmd)2023 int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd)
2024 {
2025 struct wpa_supplicant *wpaSupp;
2026 size_t replyLen = 0;
2027 char *buf;
2028
2029 (void)self;
2030 if (ifName == NULL || cmd == NULL) {
2031 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
2032 return HDF_ERR_INVALID_PARAM;
2033 }
2034 wpaSupp = getWpaWlan();
2035 if (wpaSupp == NULL) {
2036 HDF_LOGE("%{public}s wpaSupp == NULL", __func__);
2037 return HDF_FAILURE;
2038 }
2039
2040 buf = (char *)malloc(CMD_SIZE);
2041 if (buf == NULL) {
2042 HDF_LOGE("%{public}s malloc failed!", __func__);
2043 return HDF_FAILURE;
2044 }
2045 if (memcpy_s(buf, CMD_SIZE, cmd, strlen(cmd)) != EOK) {
2046 HDF_LOGE("%{public}s memcpy_s is fail", __func__);
2047 free(buf);
2048 return HDF_FAILURE;
2049 }
2050 char *reply = wpa_supplicant_ctrl_iface_process(wpaSupp, buf, &replyLen);
2051 if (reply == NULL || strcmp(reply, "FAIL\n") == 0) {
2052 HDF_LOGE("%{public}s reply is NULL or FAIL!", __func__);
2053 free(buf);
2054 return HDF_FAILURE;
2055 }
2056 free(buf);
2057 return HDF_SUCCESS;
2058 }