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