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