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 GetInterfaceLock()101 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 void 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; 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 return; 494 } 495 } 496 return; 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 GetWpaCmdStatus(&(status->keyMgmt), &(status->keyMgmtLen), halStatus->keyMgmt); 508 GetWpaCmdStatus(&(status->ssid), &(status->ssidLen), halStatus->ssid); 509 if (strcmp(halStatus->address, "") != 0) { 510 HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); 511 uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; 512 hwaddr_aton(halStatus->address, tmpAddress); 513 status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); 514 if (status->address == NULL) { 515 HDF_LOGE("%{public}s status->address is NULL", __func__); 516 status->addressLen = 0; 517 return; 518 } 519 status->addressLen = ETH_ADDR_LEN + 1 ; 520 if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { 521 HDF_LOGE("%{public}s strcpy memcpy", __func__); 522 } 523 } 524 if (strcmp(halStatus->bssid, "") != 0) { 525 HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); 526 uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; 527 hwaddr_aton(halStatus->bssid, tmpBssid); 528 status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); 529 if (status->bssid == NULL) { 530 HDF_LOGE("%{public}s status->bssid is NULL", __func__); 531 status->bssidLen = 0; 532 return; 533 } 534 status->bssidLen = ETH_ADDR_LEN + 1 ; 535 if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { 536 HDF_LOGE("%{public}s strcpy failed", __func__); 537 } 538 } 539 } 540 WpaInterfaceWifiStatus(struct IWpaInterface * self,const char * ifName,struct HdiWpaCmdStatus * status)541 int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) 542 { 543 HDF_LOGI("enter %{public}s", __func__); 544 if (ifName == NULL || status == NULL) { 545 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 546 return HDF_ERR_INVALID_PARAM; 547 } 548 pthread_mutex_lock(&g_interfaceLock); 549 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 550 if (pStaIfc == NULL) { 551 pthread_mutex_unlock(&g_interfaceLock); 552 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 553 return HDF_FAILURE; 554 } 555 struct WpaHalCmdStatus halStatus; 556 if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { 557 pthread_mutex_unlock(&g_interfaceLock); 558 return HDF_FAILURE; 559 } 560 int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); 561 if (ret < 0) { 562 pthread_mutex_unlock(&g_interfaceLock); 563 HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); 564 return HDF_FAILURE; 565 } 566 status->bssidLen = 0; 567 status->ssidLen = 0; 568 status->keyMgmtLen = 0; 569 status->addressLen = 0; 570 WpaProcessWifiStatus(&halStatus, status); 571 if (status->addressLen == 0) { 572 HDF_LOGE("%{public}s key not include address", __func__); 573 } 574 if (status->bssidLen == 0) { 575 HDF_LOGE("%{public}s key not include bssid", __func__); 576 } 577 pthread_mutex_unlock(&g_interfaceLock); 578 HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); 579 return HDF_SUCCESS; 580 } 581 WpaInterfaceSaveConfig(struct IWpaInterface * self,const char * ifName)582 int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) 583 { 584 (void)self; 585 HDF_LOGI("enter %{public}s ", __func__); 586 if (ifName == NULL) { 587 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 588 return HDF_ERR_INVALID_PARAM; 589 } 590 pthread_mutex_lock(&g_interfaceLock); 591 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 592 if (pStaIfc == NULL) { 593 pthread_mutex_unlock(&g_interfaceLock); 594 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 595 return HDF_FAILURE; 596 } 597 int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); 598 if (ret < 0) { 599 pthread_mutex_unlock(&g_interfaceLock); 600 HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); 601 return HDF_FAILURE; 602 } 603 pthread_mutex_unlock(&g_interfaceLock); 604 HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); 605 return HDF_SUCCESS; 606 } 607 WpaInterfaceWpsPbcMode(struct IWpaInterface * self,const char * ifName,const struct HdiWifiWpsParam * wpaParam)608 int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) 609 { 610 HDF_LOGI("enter %{public}s ", __func__); 611 (void)self; 612 if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL) { 613 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 614 return HDF_ERR_INVALID_PARAM; 615 } 616 pthread_mutex_lock(&g_interfaceLock); 617 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 618 if (pStaIfc == NULL) { 619 pthread_mutex_unlock(&g_interfaceLock); 620 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 621 return HDF_FAILURE; 622 } 623 int ret; 624 if (wpaParam->anyFlag < 0 && wpaParam->multiAp <= 0 && wpaParam->bssidLen == 0) { 625 ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, NULL); 626 } else { 627 struct WpaWpsPbcArgv config = {0}; 628 config.anyFlag = wpaParam->anyFlag; 629 config.multiAp = wpaParam->multiAp; 630 if (wpaParam->bssidLen > 0) { 631 if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, 632 wpaParam->bssidLen) != 0) { 633 pthread_mutex_unlock(&g_interfaceLock); 634 HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); 635 return HDF_FAILURE; 636 } 637 } 638 ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); 639 } 640 if (ret < 0) { 641 pthread_mutex_unlock(&g_interfaceLock); 642 HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); 643 return HDF_FAILURE; 644 } else if (ret == WIFI_HAL_PBC_OVERLAP) { 645 pthread_mutex_unlock(&g_interfaceLock); 646 HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); 647 return HDF_FAILURE; 648 } 649 pthread_mutex_unlock(&g_interfaceLock); 650 HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); 651 return HDF_SUCCESS; 652 } 653 WpaInterfaceWpsPinMode(struct IWpaInterface * self,const char * ifName,const struct HdiWifiWpsParam * wpaParam,int * pinCode)654 int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, 655 const struct HdiWifiWpsParam *wpaParam, int *pinCode) 656 { 657 HDF_LOGI("enter %{public}s ", __func__); 658 (void)self; 659 if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL 660 || wpaParam->pinCode == NULL || pinCode == NULL) { 661 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 662 return HDF_ERR_INVALID_PARAM; 663 } 664 pthread_mutex_lock(&g_interfaceLock); 665 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 666 if (pStaIfc == NULL) { 667 pthread_mutex_unlock(&g_interfaceLock); 668 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 669 return HDF_FAILURE; 670 } 671 struct WpaWpsPinArgv config = {{0}, {0}}; 672 if (strncpy_s(config.bssid, sizeof(config.bssid), MacToStr(wpaParam->bssid), 673 strlen(MacToStr(wpaParam->bssid))) != 0) { 674 pthread_mutex_unlock(&g_interfaceLock); 675 HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); 676 return HDF_FAILURE; 677 } 678 int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); 679 if (ret < 0) { 680 pthread_mutex_unlock(&g_interfaceLock); 681 HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); 682 return HDF_FAILURE; 683 } 684 pthread_mutex_unlock(&g_interfaceLock); 685 HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); 686 return HDF_SUCCESS; 687 } 688 WpaInterfaceWpsCancel(struct IWpaInterface * self,const char * ifName)689 int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) 690 { 691 HDF_LOGI("enter %{public}s ", __func__); 692 (void)self; 693 if (ifName == NULL) { 694 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 695 return HDF_ERR_INVALID_PARAM; 696 } 697 pthread_mutex_lock(&g_interfaceLock); 698 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 699 if (pStaIfc == NULL) { 700 pthread_mutex_unlock(&g_interfaceLock); 701 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 702 return HDF_FAILURE; 703 } 704 705 int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); 706 if (ret < 0) { 707 pthread_mutex_unlock(&g_interfaceLock); 708 HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); 709 return HDF_FAILURE; 710 } 711 pthread_mutex_unlock(&g_interfaceLock); 712 HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); 713 return HDF_SUCCESS; 714 } 715 716 //need to deal countryCodeLen WpaInterfaceGetCountryCode(struct IWpaInterface * self,const char * ifName,char * countryCode,uint32_t countryCodeLen)717 int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName, 718 char *countryCode, uint32_t countryCodeLen) 719 { 720 HDF_LOGI("enter %{public}s: ", __func__); 721 (void)self; 722 if (ifName == NULL || countryCode == NULL) { 723 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 724 return HDF_ERR_INVALID_PARAM; 725 } 726 pthread_mutex_lock(&g_interfaceLock); 727 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 728 if (pStaIfc == NULL) { 729 pthread_mutex_unlock(&g_interfaceLock); 730 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 731 return HDF_FAILURE; 732 } 733 int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); 734 if (ret < 0) { 735 pthread_mutex_unlock(&g_interfaceLock); 736 HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); 737 return HDF_FAILURE; 738 } 739 pthread_mutex_unlock(&g_interfaceLock); 740 HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); 741 return HDF_SUCCESS; 742 } 743 744 //need to deal valueLen WpaInterfaceGetNetwork(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * param,char * value,uint32_t valueLen)745 int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, 746 const int32_t networkId, const char *param, char *value, uint32_t valueLen) 747 { 748 HDF_LOGI("enter %{public}s ", __func__); 749 (void)self; 750 if (ifName == NULL || param == NULL || value == NULL || valueLen == 0) { 751 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 752 return HDF_ERR_INVALID_PARAM; 753 } 754 pthread_mutex_lock(&g_interfaceLock); 755 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 756 if (pStaIfc == NULL) { 757 pthread_mutex_unlock(&g_interfaceLock); 758 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 759 return HDF_FAILURE; 760 } 761 struct WpaGetNetworkArgv getNetwork = {0}; 762 getNetwork.id = networkId; 763 if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { 764 pthread_mutex_unlock(&g_interfaceLock); 765 HDF_LOGE("%{public}s: strncpy_s param fail", __func__); 766 return HDF_FAILURE; 767 } 768 int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); 769 if (ret < 0) { 770 pthread_mutex_unlock(&g_interfaceLock); 771 HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); 772 return HDF_FAILURE; 773 } 774 pthread_mutex_unlock(&g_interfaceLock); 775 HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); 776 return HDF_SUCCESS; 777 } 778 WpaInterfaceBlocklistClear(struct IWpaInterface * self,const char * ifName)779 int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName) 780 { 781 HDF_LOGI("enter %{public}s ", __func__); 782 (void)self; 783 if (ifName == NULL) { 784 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 785 return HDF_ERR_INVALID_PARAM; 786 } 787 pthread_mutex_lock(&g_interfaceLock); 788 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 789 if (pStaIfc == NULL) { 790 pthread_mutex_unlock(&g_interfaceLock); 791 HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); 792 return HDF_FAILURE; 793 } 794 int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); 795 if (ret < 0) { 796 pthread_mutex_unlock(&g_interfaceLock); 797 HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); 798 return HDF_FAILURE; 799 } 800 pthread_mutex_unlock(&g_interfaceLock); 801 HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); 802 return HDF_SUCCESS; 803 } 804 WpaInterfaceSetSuspendMode(struct IWpaInterface * self,const char * ifName,const int32_t mode)805 int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode) 806 { 807 HDF_LOGI("enter %{public}s: mode = %{public}d", __func__, mode); 808 (void)self; 809 if (ifName == NULL) { 810 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 811 return HDF_ERR_INVALID_PARAM; 812 } 813 pthread_mutex_lock(&g_interfaceLock); 814 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 815 if (pStaIfc == NULL) { 816 pthread_mutex_unlock(&g_interfaceLock); 817 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 818 return HDF_FAILURE; 819 } 820 int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); 821 if (ret != 0) { 822 pthread_mutex_unlock(&g_interfaceLock); 823 HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); 824 return HDF_FAILURE; 825 } 826 pthread_mutex_unlock(&g_interfaceLock); 827 HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); 828 return HDF_SUCCESS; 829 } 830 WpaInterfaceGetConnectionCapabilities(struct IWpaInterface * self,const char * ifName,struct ConnectionCapabilities * connectionCap)831 int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName, 832 struct ConnectionCapabilities *connectionCap) 833 { 834 HDF_LOGI("enter %{public}s: ", __func__); 835 (void)self; 836 if (ifName == NULL || connectionCap == NULL) { 837 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 838 return HDF_ERR_INVALID_PARAM; 839 } 840 pthread_mutex_lock(&g_interfaceLock); 841 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 842 if (pStaIfc == NULL) { 843 pthread_mutex_unlock(&g_interfaceLock); 844 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 845 return HDF_FAILURE; 846 } 847 int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); 848 if (ret != 0) { 849 pthread_mutex_unlock(&g_interfaceLock); 850 HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); 851 return HDF_FAILURE; 852 } 853 pthread_mutex_unlock(&g_interfaceLock); 854 HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); 855 return HDF_SUCCESS; 856 } 857 WpaInterfaceGetScanSsid(struct IWpaInterface * self,const char * ifName,int32_t * enable)858 int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable) 859 { 860 HDF_LOGI("enter %{public}s ", __func__); 861 (void)self; 862 if (ifName == NULL || enable == NULL) { 863 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 864 return HDF_ERR_INVALID_PARAM; 865 } 866 pthread_mutex_lock(&g_interfaceLock); 867 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 868 if (pStaIfc == NULL) { 869 pthread_mutex_unlock(&g_interfaceLock); 870 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 871 return HDF_FAILURE; 872 } 873 int scanSsid = 0; 874 int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); 875 if (ret != 0) { 876 pthread_mutex_unlock(&g_interfaceLock); 877 HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); 878 return HDF_FAILURE; 879 } 880 *enable = (scanSsid == 1); 881 pthread_mutex_unlock(&g_interfaceLock); 882 HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); 883 return HDF_SUCCESS; 884 } 885 WpaInterfaceGetPskPassphrase(struct IWpaInterface * self,const char * ifName,char * psk,uint32_t pskLen)886 int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName, 887 char *psk, uint32_t pskLen) 888 { 889 HDF_LOGI("enter %{public}s ", __func__); 890 (void)self; 891 if (ifName == NULL || psk == NULL || pskLen == 0) { 892 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 893 return HDF_ERR_INVALID_PARAM; 894 } 895 pthread_mutex_lock(&g_interfaceLock); 896 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 897 if (pStaIfc == NULL) { 898 pthread_mutex_unlock(&g_interfaceLock); 899 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 900 return HDF_FAILURE; 901 } 902 int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); 903 if (ret < 0) { 904 pthread_mutex_unlock(&g_interfaceLock); 905 HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); 906 return HDF_FAILURE; 907 } 908 pthread_mutex_unlock(&g_interfaceLock); 909 HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); 910 return HDF_SUCCESS; 911 } 912 WpaInterfaceGetPsk(struct IWpaInterface * self,const char * ifName,uint8_t * psk,uint32_t * pskLen)913 int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen) 914 { 915 HDF_LOGI("enter %{public}s ", __func__); 916 (void)self; 917 if (ifName == NULL || psk == NULL || pskLen == NULL) { 918 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 919 return HDF_ERR_INVALID_PARAM; 920 } 921 pthread_mutex_lock(&g_interfaceLock); 922 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 923 if (pStaIfc == NULL) { 924 pthread_mutex_unlock(&g_interfaceLock); 925 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 926 return HDF_FAILURE; 927 } 928 int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); 929 if (ret < 0) { 930 pthread_mutex_unlock(&g_interfaceLock); 931 HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); 932 return HDF_FAILURE; 933 } 934 pthread_mutex_unlock(&g_interfaceLock); 935 HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); 936 return HDF_SUCCESS; 937 } 938 WpaInterfaceGetWepKey(struct IWpaInterface * self,const char * ifName,int keyIdx,uint8_t * wepKey,uint32_t * wepKeyLen)939 int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx, 940 uint8_t *wepKey, uint32_t *wepKeyLen) 941 { 942 HDF_LOGI("enter %{public}s keyIdx = %{public}d", __func__, keyIdx); 943 (void)self; 944 if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) { 945 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 946 return HDF_ERR_INVALID_PARAM; 947 } 948 pthread_mutex_lock(&g_interfaceLock); 949 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 950 if (pStaIfc == NULL) { 951 pthread_mutex_unlock(&g_interfaceLock); 952 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 953 return HDF_FAILURE; 954 } 955 int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); 956 if (ret < 0) { 957 pthread_mutex_unlock(&g_interfaceLock); 958 HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); 959 return HDF_FAILURE; 960 } 961 pthread_mutex_unlock(&g_interfaceLock); 962 HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); 963 return HDF_SUCCESS; 964 } 965 WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface * self,const char * ifName,int * keyIdx)966 int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx) 967 { 968 HDF_LOGI("enter %{public}s ", __func__); 969 (void)self; 970 if (ifName == NULL || keyIdx == NULL) { 971 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 972 return HDF_ERR_INVALID_PARAM; 973 } 974 pthread_mutex_lock(&g_interfaceLock); 975 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 976 if (pStaIfc == NULL) { 977 pthread_mutex_unlock(&g_interfaceLock); 978 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 979 return HDF_FAILURE; 980 } 981 int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); 982 if (ret < 0) { 983 pthread_mutex_unlock(&g_interfaceLock); 984 HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); 985 return HDF_FAILURE; 986 } 987 pthread_mutex_unlock(&g_interfaceLock); 988 HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); 989 return HDF_SUCCESS; 990 } 991 WpaInterfaceGetRequirePmf(struct IWpaInterface * self,const char * ifName,int * enable)992 int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable) 993 { 994 HDF_LOGI("enter %{public}s ", __func__); 995 (void)self; 996 if (ifName == NULL || enable == NULL) { 997 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 998 return HDF_ERR_INVALID_PARAM; 999 } 1000 pthread_mutex_lock(&g_interfaceLock); 1001 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 1002 if (pStaIfc == NULL) { 1003 pthread_mutex_unlock(&g_interfaceLock); 1004 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 1005 return HDF_FAILURE; 1006 } 1007 int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); 1008 if (ret != 0) { 1009 pthread_mutex_unlock(&g_interfaceLock); 1010 HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); 1011 return HDF_FAILURE; 1012 } 1013 pthread_mutex_unlock(&g_interfaceLock); 1014 HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); 1015 return HDF_SUCCESS; 1016 } 1017 WpaInterfaceSetCountryCode(struct IWpaInterface * self,const char * ifName,const char * countryCode)1018 int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode) 1019 { 1020 HDF_LOGI("enter %{public}s ", __func__); 1021 (void)self; 1022 if (ifName == NULL || countryCode == NULL) { 1023 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 1024 return HDF_ERR_INVALID_PARAM; 1025 } 1026 pthread_mutex_lock(&g_interfaceLock); 1027 WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); 1028 if (pStaIfc == NULL) { 1029 pthread_mutex_unlock(&g_interfaceLock); 1030 HDF_LOGE("%{public}s pStaIfc = NULL", __func__); 1031 return HDF_FAILURE; 1032 } 1033 int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); 1034 if (ret < 0) { 1035 pthread_mutex_unlock(&g_interfaceLock); 1036 HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); 1037 return HDF_FAILURE; 1038 } 1039 pthread_mutex_unlock(&g_interfaceLock); 1040 HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); 1041 return HDF_SUCCESS; 1042 } 1043 OnRemoteServiceDied(struct HdfDeathRecipient * deathRecipient,struct HdfRemoteService * remote)1044 static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) 1045 { 1046 HDF_LOGI("enter %{public}s ", __func__); 1047 WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); 1048 if (pWpaInterface == NULL) { 1049 HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); 1050 return; 1051 } 1052 int ret = pWpaInterface->wpaCliTerminate(); 1053 if (ret != 0) { 1054 HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); 1055 } else { 1056 HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); 1057 } 1058 ReleaseWpaGlobalInterface(); 1059 HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); 1060 ReleaseWifiStaInterface(0); 1061 HDF_LOGI("%{public}s: call ReleaseWifiStaInterface finish", __func__); 1062 } 1063 1064 static struct RemoteServiceDeathRecipient g_deathRecipient = { 1065 .recipient = { 1066 .OnRemoteDied = OnRemoteServiceDied, 1067 } 1068 }; 1069 AddDeathRecipientForService(struct IWpaCallback * cbFunc)1070 static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) 1071 { 1072 HDF_LOGI("enter %{public}s ", __func__); 1073 if (cbFunc == NULL) { 1074 HDF_LOGE("invalid parameter"); 1075 return; 1076 } 1077 struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); 1078 if (remote == NULL) { 1079 HDF_LOGE("remote is NULL"); 1080 return; 1081 } 1082 HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); 1083 } 1084 HdfWpaAddRemoteObj(struct IWpaCallback * self,const char * ifName)1085 static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) 1086 { 1087 struct HdfWpaRemoteNode *pos = NULL; 1088 struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; 1089 1090 if (self == NULL) { 1091 HDF_LOGE("%{public}s:self == NULL", __func__); 1092 return HDF_ERR_INVALID_PARAM; 1093 } 1094 if (!DListIsEmpty(head)) { 1095 DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { 1096 if (pos->service == self->AsObject(self)) { 1097 HDF_LOGE("%{public}s: pos->service == self", __func__); 1098 return HDF_FAILURE; 1099 } 1100 } 1101 } 1102 struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); 1103 if (newRemoteNode == NULL) { 1104 HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); 1105 return HDF_FAILURE; 1106 } 1107 newRemoteNode->callbackObj = self; 1108 newRemoteNode->service = self->AsObject(self); 1109 DListInsertTail(&newRemoteNode->node, head); 1110 if (strncmp(ifName, "wlan0", strlen("wlan0")) == 0) { 1111 AddDeathRecipientForService(self); 1112 } 1113 return HDF_SUCCESS; 1114 } 1115 WpaFillWpaDisconnectParam(struct WpaDisconnectParam * disconnectParam,struct HdiWpaDisconnectParam * hdiWpaDisconnectParam)1116 static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, 1117 struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) 1118 { 1119 int32_t ret = HDF_SUCCESS; 1120 1121 if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { 1122 HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); 1123 return HDF_ERR_INVALID_PARAM; 1124 } 1125 hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; 1126 hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; 1127 if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, 1128 disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1129 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1130 ret = HDF_FAILURE; 1131 } 1132 if (ret != HDF_SUCCESS) { 1133 if (hdiWpaDisconnectParam->bssid != NULL) { 1134 OsalMemFree(hdiWpaDisconnectParam->bssid); 1135 hdiWpaDisconnectParam->bssid = NULL; 1136 } 1137 } 1138 return ret; 1139 } 1140 WpaFillWpaConnectParam(struct WpaConnectParam * connectParam,struct HdiWpaConnectParam * hdiWpaConnectParam)1141 static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, 1142 struct HdiWpaConnectParam *hdiWpaConnectParam) 1143 { 1144 int32_t ret = HDF_SUCCESS; 1145 1146 if (connectParam == NULL || hdiWpaConnectParam == NULL) { 1147 HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); 1148 return HDF_ERR_INVALID_PARAM; 1149 } 1150 hdiWpaConnectParam->networkId = connectParam->networkId; 1151 if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, 1152 connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1153 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1154 ret = HDF_FAILURE; 1155 } 1156 if (ret != HDF_SUCCESS) { 1157 if (hdiWpaConnectParam->bssid != NULL) { 1158 OsalMemFree(hdiWpaConnectParam->bssid); 1159 hdiWpaConnectParam->bssid = NULL; 1160 } 1161 } 1162 return ret; 1163 } 1164 WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam * bssidChangedParam,struct HdiWpaBssidChangedParam * hdiWpaBssidChangedParam)1165 static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, 1166 struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) 1167 { 1168 int32_t ret = HDF_SUCCESS; 1169 1170 if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { 1171 HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); 1172 return HDF_ERR_INVALID_PARAM; 1173 } 1174 do { 1175 if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, 1176 bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1177 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1178 ret = HDF_FAILURE; 1179 break; 1180 } 1181 if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, 1182 bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { 1183 HDF_LOGE("%{public}s: fill reason fail!", __func__); 1184 ret = HDF_FAILURE; 1185 } 1186 } while (0); 1187 if (ret != HDF_SUCCESS) { 1188 if (hdiWpaBssidChangedParam->bssid != NULL) { 1189 OsalMemFree(hdiWpaBssidChangedParam->bssid); 1190 hdiWpaBssidChangedParam->bssid = NULL; 1191 } 1192 if (hdiWpaBssidChangedParam->reason != NULL) { 1193 OsalMemFree(hdiWpaBssidChangedParam->reason); 1194 hdiWpaBssidChangedParam->reason = NULL; 1195 } 1196 } 1197 return ret; 1198 } 1199 WpaFillWpaStateChangedParam(struct WpaStateChangedParam * stateChangedParam,struct HdiWpaStateChangedParam * hdiWpaStateChangedParam)1200 static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam, 1201 struct HdiWpaStateChangedParam *hdiWpaStateChangedParam) 1202 { 1203 int32_t ret = HDF_SUCCESS; 1204 1205 if (stateChangedParam == NULL || hdiWpaStateChangedParam == NULL) { 1206 HDF_LOGE("%{public}s: stateChangedParam or hdiWpaStateChangedParam is NULL!", __func__); 1207 return HDF_ERR_INVALID_PARAM; 1208 } 1209 hdiWpaStateChangedParam->networkId = stateChangedParam->networkId; 1210 HDF_LOGD("%{public}s: hdiWpaStateChangedParam->networkId =%d", __func__, hdiWpaStateChangedParam->networkId); 1211 hdiWpaStateChangedParam->status = stateChangedParam->status; 1212 HDF_LOGD("%{public}s: hdiWpaStateChangedParam->status =%d", __func__, hdiWpaStateChangedParam->status); 1213 do { 1214 HDF_LOGD("%{public}s: stateChangedParam->bssid[0] = %x", __func__, stateChangedParam->bssid[0]); 1215 HDF_LOGD("%{public}s: stateChangedParam->bssid[5] = %x", __func__, 1216 stateChangedParam->bssid[WIFI_BSSID_LEN - 1]); 1217 if (FillData(&hdiWpaStateChangedParam->bssid, &hdiWpaStateChangedParam->bssidLen, 1218 stateChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1219 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1220 ret = HDF_FAILURE; 1221 break; 1222 } 1223 HDF_LOGD("%{public}s: stateChangedParam->ssid[0] = %x", __func__, stateChangedParam->ssid[0]); 1224 HDF_LOGD("%{public}s: stateChangedParam->ssid[WIFI_SSID_LENGTH-1] = %x", __func__, 1225 stateChangedParam->ssid[WIFI_SSID_LENGTH - 1]); 1226 if (memcmp(stateChangedParam->ssid, "\0", 1) == 0) { 1227 hdiWpaStateChangedParam->ssidLen = 0; 1228 HDF_LOGE("%{public}s: hdiWpaStateChangedParam->ssidLen =%d", __func__, hdiWpaStateChangedParam->ssidLen); 1229 } else { 1230 if (FillData(&hdiWpaStateChangedParam->ssid, &hdiWpaStateChangedParam->ssidLen, 1231 stateChangedParam->ssid, strlen((char*)stateChangedParam->ssid)) != HDF_SUCCESS) { 1232 HDF_LOGE("%{public}s: fill ssid fail!", __func__); 1233 ret = HDF_FAILURE; 1234 } 1235 } 1236 } while (0); 1237 if (ret != HDF_SUCCESS) { 1238 if (hdiWpaStateChangedParam->bssid != NULL) { 1239 OsalMemFree(hdiWpaStateChangedParam->bssid); 1240 hdiWpaStateChangedParam->bssid = NULL; 1241 } 1242 if (hdiWpaStateChangedParam->ssid != NULL) { 1243 OsalMemFree(hdiWpaStateChangedParam->ssid); 1244 hdiWpaStateChangedParam->ssid = NULL; 1245 } 1246 } 1247 return ret; 1248 } 1249 WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam * tempDisabledParam,struct HdiWpaTempDisabledParam * hdiWpaTempDisabledParam)1250 static int32_t WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam *tempDisabledParam, 1251 struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam) 1252 { 1253 int32_t ret = HDF_SUCCESS; 1254 1255 if (tempDisabledParam == NULL || hdiWpaTempDisabledParam == NULL) { 1256 HDF_LOGE("%{public}s: tempDisabledParam or hdiWpaTempDisabledParam is NULL!", __func__); 1257 return HDF_ERR_INVALID_PARAM; 1258 } 1259 hdiWpaTempDisabledParam->networkId = tempDisabledParam->networkId; 1260 hdiWpaTempDisabledParam->authFailures = tempDisabledParam->authFailures; 1261 hdiWpaTempDisabledParam->duration = tempDisabledParam->duration; 1262 do { 1263 if (FillData(&hdiWpaTempDisabledParam->reason, &hdiWpaTempDisabledParam->reasonLen, 1264 tempDisabledParam->reason, strlen((char*)tempDisabledParam->reason)) != HDF_SUCCESS) { 1265 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1266 ret = HDF_FAILURE; 1267 break; 1268 } 1269 if (FillData(&hdiWpaTempDisabledParam->ssid, &hdiWpaTempDisabledParam->ssidLen, 1270 tempDisabledParam->ssid, strlen((char*)tempDisabledParam->ssid)) != HDF_SUCCESS) { 1271 HDF_LOGE("%{public}s: fill ssid fail!", __func__); 1272 ret = HDF_FAILURE; 1273 } 1274 } while (0); 1275 if (ret != HDF_SUCCESS) { 1276 if (hdiWpaTempDisabledParam->reason != NULL) { 1277 OsalMemFree(hdiWpaTempDisabledParam->reason); 1278 hdiWpaTempDisabledParam->reason = NULL; 1279 } 1280 if (hdiWpaTempDisabledParam->ssid != NULL) { 1281 OsalMemFree(hdiWpaTempDisabledParam->ssid); 1282 hdiWpaTempDisabledParam->ssid = NULL; 1283 } 1284 } 1285 return ret; 1286 } 1287 WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam * associateRejectParam,struct HdiWpaAssociateRejectParam * hdiWpaAssociateRejectParam)1288 static int32_t WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam *associateRejectParam, 1289 struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam) 1290 { 1291 int32_t ret = HDF_SUCCESS; 1292 1293 if (associateRejectParam == NULL || hdiWpaAssociateRejectParam == NULL) { 1294 HDF_LOGE("%{public}s: associateRejectParam or hdiWpaAssociateRejectParam is NULL!", __func__); 1295 return HDF_ERR_INVALID_PARAM; 1296 } 1297 hdiWpaAssociateRejectParam->statusCode = associateRejectParam->statusCode; 1298 hdiWpaAssociateRejectParam->timeOut = associateRejectParam->timeOut; 1299 if (FillData(&hdiWpaAssociateRejectParam->bssid, &hdiWpaAssociateRejectParam->bssidLen, 1300 associateRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1301 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1302 ret = HDF_FAILURE; 1303 } 1304 if (ret != HDF_SUCCESS) { 1305 if (hdiWpaAssociateRejectParam->bssid != NULL) { 1306 OsalMemFree(hdiWpaAssociateRejectParam->bssid); 1307 hdiWpaAssociateRejectParam->bssid = NULL; 1308 } 1309 } 1310 return ret; 1311 } 1312 WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam * recvScanResultParam,struct HdiWpaRecvScanResultParam * hdiWpaRecvScanResultParam)1313 static int32_t WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam *recvScanResultParam, 1314 struct HdiWpaRecvScanResultParam *hdiWpaRecvScanResultParam) 1315 { 1316 int32_t ret = HDF_SUCCESS; 1317 1318 if (recvScanResultParam == NULL || hdiWpaRecvScanResultParam == NULL) { 1319 HDF_LOGE("%{public}s: recvScanResultParam or hdiWpaRecvScanResultParam is NULL!", __func__); 1320 return HDF_ERR_INVALID_PARAM; 1321 } 1322 hdiWpaRecvScanResultParam->scanId = recvScanResultParam->scanId; 1323 return ret; 1324 } 1325 WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam * authRejectParam,struct HdiWpaAuthRejectParam * hdiWpaAuthRejectParam)1326 static int32_t WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam *authRejectParam, 1327 struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam) 1328 { 1329 int32_t ret = HDF_SUCCESS; 1330 1331 if (authRejectParam == NULL || hdiWpaAuthRejectParam == NULL) { 1332 HDF_LOGE("%{public}s: authRejectParam or hdiWpaAuthRejectParam is NULL!", __func__); 1333 return HDF_ERR_INVALID_PARAM; 1334 } 1335 hdiWpaAuthRejectParam->statusCode = authRejectParam->statusCode; 1336 hdiWpaAuthRejectParam->authType = authRejectParam->authType; 1337 hdiWpaAuthRejectParam->authTransaction = authRejectParam->authTransaction; 1338 if (FillData(&hdiWpaAuthRejectParam->bssid, &hdiWpaAuthRejectParam->bssidLen, 1339 authRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { 1340 HDF_LOGE("%{public}s: fill bssid fail!", __func__); 1341 ret = HDF_FAILURE; 1342 } 1343 if (ret != HDF_SUCCESS) { 1344 if (hdiWpaAuthRejectParam->bssid != NULL) { 1345 OsalMemFree(hdiWpaAuthRejectParam->bssid); 1346 hdiWpaAuthRejectParam->bssid = NULL; 1347 } 1348 } 1349 return ret; 1350 } 1351 ProcessEventWpaDisconnect(struct HdfWpaRemoteNode * node,struct WpaDisconnectParam * disconnectParam,const char * ifName)1352 static int32_t ProcessEventWpaDisconnect(struct HdfWpaRemoteNode *node, 1353 struct WpaDisconnectParam *disconnectParam, const char *ifName) 1354 { 1355 struct HdiWpaDisconnectParam *hdiWpaDisconnectParam = NULL; 1356 int32_t ret = HDF_FAILURE; 1357 1358 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDisconnected == NULL) { 1359 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1360 return HDF_ERR_INVALID_PARAM; 1361 } 1362 hdiWpaDisconnectParam = (struct HdiWpaDisconnectParam *)OsalMemCalloc(sizeof(struct HdiWpaDisconnectParam)); 1363 if ((hdiWpaDisconnectParam == NULL) || (WpaFillWpaDisconnectParam(disconnectParam, 1364 hdiWpaDisconnectParam) != HDF_SUCCESS)) { 1365 HDF_LOGE("%{public}s: hdiWpaDisconnectParam is NULL or disconnectParam fialed!", __func__); 1366 } else { 1367 ret = node->callbackObj->OnEventDisconnected(node->callbackObj, hdiWpaDisconnectParam, ifName); 1368 } 1369 HdiWpaDisconnectParamFree(hdiWpaDisconnectParam, true); 1370 return ret; 1371 } 1372 ProcessEventWpaConnect(struct HdfWpaRemoteNode * node,struct WpaConnectParam * connectParam,const char * ifName)1373 static int32_t ProcessEventWpaConnect(struct HdfWpaRemoteNode *node, 1374 struct WpaConnectParam *connectParam, const char *ifName) 1375 { 1376 struct HdiWpaConnectParam *hdiWpaConnectParam = NULL; 1377 int32_t ret = HDF_FAILURE; 1378 1379 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventConnected == NULL) { 1380 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1381 return HDF_ERR_INVALID_PARAM; 1382 } 1383 hdiWpaConnectParam = (struct HdiWpaConnectParam *)OsalMemCalloc(sizeof(struct HdiWpaConnectParam)); 1384 if ((hdiWpaConnectParam == NULL) || (WpaFillWpaConnectParam(connectParam, hdiWpaConnectParam) != HDF_SUCCESS)) { 1385 HDF_LOGE("%{public}s: HdiWpaConnectParam is NULL or connectParam fialed!", __func__); 1386 } else { 1387 ret = node->callbackObj->OnEventConnected(node->callbackObj, hdiWpaConnectParam, ifName); 1388 } 1389 HdiWpaConnectParamFree(hdiWpaConnectParam, true); 1390 return ret; 1391 } 1392 ProcessEventWpaBssidChange(struct HdfWpaRemoteNode * node,struct WpaBssidChangedParam * bssidChangeParam,const char * ifName)1393 static int32_t ProcessEventWpaBssidChange(struct HdfWpaRemoteNode *node, 1394 struct WpaBssidChangedParam *bssidChangeParam, const char *ifName) 1395 { 1396 struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam = NULL; 1397 int32_t ret = HDF_FAILURE; 1398 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventBssidChanged == NULL) { 1399 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1400 return HDF_ERR_INVALID_PARAM; 1401 } 1402 hdiWpaBssidChangedParam = (struct HdiWpaBssidChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaBssidChangedParam)); 1403 if ((hdiWpaBssidChangedParam == NULL) || (WpaFillWpaBssidChangedParam(bssidChangeParam, 1404 hdiWpaBssidChangedParam) != HDF_SUCCESS)) { 1405 HDF_LOGE("%{public}s: hdiWpaBssidChangedParam is NULL or bssidChangeParam fialed!", __func__); 1406 } else { 1407 ret = node->callbackObj->OnEventBssidChanged(node->callbackObj, hdiWpaBssidChangedParam, ifName); 1408 } 1409 HdiWpaBssidChangedParamFree(hdiWpaBssidChangedParam, true); 1410 return ret; 1411 } 1412 ProcessEventWpaStateChange(struct HdfWpaRemoteNode * node,struct WpaStateChangedParam * stateChangeParam,const char * ifName)1413 static int32_t ProcessEventWpaStateChange(struct HdfWpaRemoteNode *node, 1414 struct WpaStateChangedParam *stateChangeParam, const char *ifName) 1415 { 1416 struct HdiWpaStateChangedParam *hdiWpaStateChangedParam = NULL; 1417 int32_t ret = HDF_FAILURE; 1418 1419 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStateChanged == NULL) { 1420 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1421 return HDF_ERR_INVALID_PARAM; 1422 } 1423 hdiWpaStateChangedParam = (struct HdiWpaStateChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaStateChangedParam)); 1424 if ((hdiWpaStateChangedParam == NULL) || (WpaFillWpaStateChangedParam(stateChangeParam, 1425 hdiWpaStateChangedParam) != HDF_SUCCESS)) { 1426 HDF_LOGE("%{public}s: hdiWpaStateChangedParam is NULL or stateChangeParam fialed!", __func__); 1427 } else { 1428 ret = node->callbackObj->OnEventStateChanged(node->callbackObj, hdiWpaStateChangedParam, ifName); 1429 } 1430 HdiWpaStateChangedParamFree(hdiWpaStateChangedParam, true); 1431 return ret; 1432 } 1433 ProcessEventWpaTempDisable(struct HdfWpaRemoteNode * node,struct WpaTempDisabledParam * tempDisabledParam,const char * ifName)1434 static int32_t ProcessEventWpaTempDisable(struct HdfWpaRemoteNode *node, 1435 struct WpaTempDisabledParam *tempDisabledParam, const char *ifName) 1436 { 1437 struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam = NULL; 1438 int32_t ret = HDF_FAILURE; 1439 1440 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventTempDisabled == NULL) { 1441 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1442 return HDF_ERR_INVALID_PARAM; 1443 } 1444 hdiWpaTempDisabledParam = (struct HdiWpaTempDisabledParam *)OsalMemCalloc(sizeof(struct HdiWpaTempDisabledParam)); 1445 if ((hdiWpaTempDisabledParam == NULL) || (WpaFillWpaTempDisabledParam(tempDisabledParam, 1446 hdiWpaTempDisabledParam) != HDF_SUCCESS)) { 1447 HDF_LOGE("%{public}s: hdiWpaTempDisabledParam is NULL or tempDisabledParam fialed!", __func__); 1448 } else { 1449 ret = node->callbackObj->OnEventTempDisabled(node->callbackObj, hdiWpaTempDisabledParam, ifName); 1450 } 1451 HdiWpaTempDisabledParamFree(hdiWpaTempDisabledParam, true); 1452 return ret; 1453 } 1454 ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode * node,struct WpaAssociateRejectParam * associateRejectParam,const char * ifName)1455 static int32_t ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode *node, 1456 struct WpaAssociateRejectParam *associateRejectParam, const char *ifName) 1457 { 1458 struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam = NULL; 1459 int32_t ret = HDF_FAILURE; 1460 1461 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAssociateReject == NULL) { 1462 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1463 return HDF_ERR_INVALID_PARAM; 1464 } 1465 hdiWpaAssociateRejectParam = (struct HdiWpaAssociateRejectParam *) 1466 OsalMemCalloc(sizeof(struct HdiWpaAssociateRejectParam)); 1467 if ((hdiWpaAssociateRejectParam == NULL) || (WpaFillWpaAssociateRejectParam(associateRejectParam, 1468 hdiWpaAssociateRejectParam) != HDF_SUCCESS)) { 1469 HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); 1470 } else { 1471 ret = node->callbackObj->OnEventAssociateReject(node->callbackObj, hdiWpaAssociateRejectParam, ifName); 1472 } 1473 HdiWpaAssociateRejectParamFree(hdiWpaAssociateRejectParam, true); 1474 return ret; 1475 } 1476 ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode * node,const char * ifName)1477 static int32_t ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode *node, 1478 const char *ifName) 1479 { 1480 int32_t ret = HDF_FAILURE; 1481 1482 if (node == NULL || node->callbackObj == NULL) { 1483 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1484 return HDF_ERR_INVALID_PARAM; 1485 } 1486 ret = node->callbackObj->OnEventWpsOverlap(node->callbackObj, ifName); 1487 return ret; 1488 } 1489 ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode * node,const char * ifName)1490 static int32_t ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode *node, 1491 const char *ifName) 1492 { 1493 int32_t ret = HDF_FAILURE; 1494 1495 if (node == NULL || node->callbackObj == NULL) { 1496 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1497 return HDF_ERR_INVALID_PARAM; 1498 } 1499 ret = node->callbackObj->OnEventWpsTimeout(node->callbackObj, ifName); 1500 return ret; 1501 } 1502 ProcessEventWpaAuthTimeout(struct HdfWpaRemoteNode * node,const char * ifName)1503 static int32_t ProcessEventWpaAuthTimeout(struct HdfWpaRemoteNode *node, const char *ifName) 1504 { 1505 int32_t ret = HDF_FAILURE; 1506 if (node == NULL || node->callbackObj == NULL) { 1507 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1508 return HDF_ERR_INVALID_PARAM; 1509 } 1510 ret = node->callbackObj->OnEventAuthTimeout(node->callbackObj, ifName); 1511 return ret; 1512 } 1513 ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode * node,struct WpaRecvScanResultParam * recvScanResultParam,const char * ifName)1514 static int32_t ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode *node, 1515 struct WpaRecvScanResultParam *recvScanResultParam, const char *ifName) 1516 { 1517 struct HdiWpaRecvScanResultParam *hdiRecvScanResultParam = NULL; 1518 int32_t ret = HDF_FAILURE; 1519 1520 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventScanResult == NULL) { 1521 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1522 return HDF_ERR_INVALID_PARAM; 1523 } 1524 hdiRecvScanResultParam = (struct HdiWpaRecvScanResultParam *) 1525 OsalMemCalloc(sizeof(struct HdiWpaRecvScanResultParam)); 1526 if ((hdiRecvScanResultParam == NULL) || (WpaFillWpaRecvScanResultParam(recvScanResultParam, 1527 hdiRecvScanResultParam) != HDF_SUCCESS)) { 1528 HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); 1529 } else { 1530 ret = node->callbackObj->OnEventScanResult(node->callbackObj, hdiRecvScanResultParam, ifName); 1531 } 1532 HdiWpaRecvScanResultParamFree(hdiRecvScanResultParam, true); 1533 return ret; 1534 } 1535 ProcessEventWpaAuthReject(struct HdfWpaRemoteNode * node,struct WpaAuthRejectParam * authRejectParam,const char * ifName)1536 static int32_t ProcessEventWpaAuthReject( 1537 struct HdfWpaRemoteNode *node, struct WpaAuthRejectParam *authRejectParam, const char *ifName) 1538 { 1539 struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam = NULL; 1540 int32_t ret = HDF_FAILURE; 1541 1542 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAuthReject == NULL) { 1543 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1544 return HDF_ERR_INVALID_PARAM; 1545 } 1546 hdiWpaAuthRejectParam = 1547 (struct HdiWpaAuthRejectParam *)OsalMemCalloc(sizeof(struct HdiWpaAuthRejectParam)); 1548 if ((hdiWpaAuthRejectParam == NULL) || 1549 (WpaFillWpaAuthRejectParam(authRejectParam, hdiWpaAuthRejectParam) != HDF_SUCCESS)) { 1550 HDF_LOGE("%{public}s: hdiWpaAuthRejectParam is NULL or authRejectParam fialed!", __func__); 1551 } else { 1552 ret = node->callbackObj->OnEventAuthReject(node->callbackObj, hdiWpaAuthRejectParam, ifName); 1553 } 1554 HdiWpaAuthRejectParamFree(hdiWpaAuthRejectParam, true); 1555 return ret; 1556 } 1557 ProcessEventStaNotify(struct HdfWpaRemoteNode * node,char * notifyParam,const char * ifName)1558 int32_t ProcessEventStaNotify(struct HdfWpaRemoteNode *node, char *notifyParam, const char *ifName) 1559 { 1560 int32_t ret = HDF_FAILURE; 1561 if (notifyParam == NULL || ifName == NULL) { 1562 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 1563 return HDF_FAILURE; 1564 } 1565 char *notifyStr = (char*)malloc(BUF_SIZE); 1566 if (notifyStr == NULL) { 1567 HDF_LOGE("%{public}s notifyStr malloc failed", __func__); 1568 return HDF_FAILURE; 1569 } 1570 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaNotify == NULL) { 1571 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1572 free(notifyStr); 1573 return HDF_ERR_INVALID_PARAM; 1574 } 1575 if (memset_s(notifyStr, BUF_SIZE, 0, BUF_SIZE) != EOK) { 1576 HDF_LOGE("%{public}s memset failed", __func__); 1577 free(notifyStr); 1578 return HDF_FAILURE; 1579 } 1580 if (strcpy_s(notifyStr, BUF_SIZE, notifyParam) != EOK) { 1581 HDF_LOGE("%{public}s strcpy failed", __func__); 1582 free(notifyStr); 1583 return HDF_FAILURE; 1584 } 1585 ret = node->callbackObj->OnEventStaNotify(node->callbackObj, notifyStr, ifName); 1586 free(notifyStr); 1587 return ret; 1588 } 1589 WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo * wpaVendorExtInfo,struct WpaVendorInfo * wpaVendorInfo)1590 static int32_t WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo *wpaVendorExtInfo, 1591 struct WpaVendorInfo *wpaVendorInfo) 1592 { 1593 if (wpaVendorExtInfo == NULL || wpaVendorInfo == NULL) { 1594 HDF_LOGE("%{public}s: wpaVendorExtInfo or wpaVendorInfo is NULL!", __func__); 1595 return HDF_ERR_INVALID_PARAM; 1596 } 1597 wpaVendorInfo->data = NULL; 1598 wpaVendorInfo->type = wpaVendorExtInfo->type; 1599 wpaVendorInfo->freq = wpaVendorExtInfo->freq; 1600 wpaVendorInfo->width = wpaVendorExtInfo->width; 1601 wpaVendorInfo->id = wpaVendorExtInfo->id; 1602 wpaVendorInfo->status = wpaVendorExtInfo->status; 1603 wpaVendorInfo->reason = wpaVendorExtInfo->reason; 1604 if (FillData(&wpaVendorInfo->ssid, &wpaVendorInfo->ssidLen, 1605 wpaVendorExtInfo->ssid, strlen((char *)wpaVendorExtInfo->ssid)) != EOK) { 1606 HDF_LOGE("%{public}s: memcpy_s ssid fail !", __func__); 1607 return HDF_FAILURE; 1608 } 1609 1610 if (FillData(&wpaVendorInfo->psk, &wpaVendorInfo->pskLen, 1611 wpaVendorExtInfo->psk, strlen((char *)wpaVendorExtInfo->psk)) != EOK) { 1612 HDF_LOGE("%{public}s: memcpy_s psk fail !", __func__); 1613 return HDF_FAILURE; 1614 } 1615 1616 if (FillData(&wpaVendorInfo->devAddr, &wpaVendorInfo->devAddrLen, 1617 wpaVendorExtInfo->devAddr, ETH_ADDR_LEN) != EOK) { 1618 HDF_LOGE("%{public}s: memcpy_s devAddr fail !", __func__); 1619 return HDF_FAILURE; 1620 } 1621 1622 if (FillData(&wpaVendorInfo->data, &wpaVendorInfo->dataLen, 1623 wpaVendorExtInfo->data, strlen((char *)wpaVendorExtInfo->data)) != EOK) { 1624 HDF_LOGE("%{public}s: memcpy_s data fail !", __func__); 1625 return HDF_FAILURE; 1626 } 1627 1628 HDF_LOGI("wpaVendorInfo type %{public}d, freq %{public}d, reason %{public}d, " 1629 "id %{public}d status %{public}d!", 1630 wpaVendorInfo->type, wpaVendorInfo->freq, wpaVendorInfo->reason, 1631 wpaVendorInfo->id, wpaVendorInfo->status); 1632 return HDF_SUCCESS; 1633 } 1634 ProcessEventWpaVendorExt(struct HdfWpaRemoteNode * node,struct WpaVendorExtInfo * wpaVendorExtInfo,const char * ifName)1635 static int32_t ProcessEventWpaVendorExt(struct HdfWpaRemoteNode *node, 1636 struct WpaVendorExtInfo *wpaVendorExtInfo, const char *ifName) 1637 { 1638 HDF_LOGI("%{public}s: ifName => %{public}s ; ", __func__, ifName); 1639 struct WpaVendorInfo wpaVendorInfo; 1640 int32_t ret = HDF_FAILURE; 1641 if (wpaVendorExtInfo == NULL) { 1642 HDF_LOGE("%{public}s: wpaVendorExtInfo is NULL !", __func__); 1643 return HDF_ERR_INVALID_PARAM; 1644 } 1645 1646 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventVendorCb == NULL) { 1647 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); 1648 return HDF_ERR_INVALID_PARAM; 1649 } 1650 1651 if (WpaFillWpaVendorExtInfo(wpaVendorExtInfo, &wpaVendorInfo) != HDF_SUCCESS) { 1652 ret = HDF_FAILURE; 1653 HDF_LOGE("%{public}s: wpaVendorInfo is NULL or associateRejectParam fialed!", __func__); 1654 } else { 1655 ret = node->callbackObj->OnEventVendorCb(node->callbackObj, &wpaVendorInfo, ifName); 1656 } 1657 HDF_LOGI("%{public}s: res %{public}d!", __func__, ret); 1658 return ret; 1659 } HdfStaDealEvent(uint32_t event,struct HdfWpaRemoteNode * pos,void * data,const char * ifName)1660 static int32_t HdfStaDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) 1661 { 1662 int32_t ret = HDF_FAILURE; 1663 switch (event) { 1664 case WPA_EVENT_DISCONNECT: 1665 ret = ProcessEventWpaDisconnect(pos, (struct WpaDisconnectParam *)data, ifName); 1666 break; 1667 case WPA_EVENT_CONNECT: 1668 ret = ProcessEventWpaConnect(pos, (struct WpaConnectParam *)data, ifName); 1669 break; 1670 case WPA_EVENT_BSSID_CHANGE: 1671 ret = ProcessEventWpaBssidChange(pos, (struct WpaBssidChangedParam *)data, ifName); 1672 break; 1673 case WPA_EVENT_STATE_CHANGED: 1674 ret = ProcessEventWpaStateChange(pos, (struct WpaStateChangedParam *)data, ifName); 1675 break; 1676 case WPA_EVENT_TEMP_DISABLE: 1677 ret = ProcessEventWpaTempDisable(pos, (struct WpaTempDisabledParam *)data, ifName); 1678 break; 1679 case WPA_EVENT_ASSOCIATE_REJECT: 1680 ret = ProcessEventWpaAssociateReject(pos, (struct WpaAssociateRejectParam *)data, ifName); 1681 break; 1682 case WPA_EVENT_WPS_OVERLAP: 1683 ret = ProcessEventWpaWpsOverlap(pos, ifName); 1684 break; 1685 case WPA_EVENT_WPS_TIMEMOUT: 1686 ret = ProcessEventWpaWpsTimeout(pos, ifName); 1687 break; 1688 case WPA_EVENT_AUTH_TIMEOUT: 1689 ProcessEventWpaAuthTimeout(pos, ifName); 1690 break; 1691 case WPA_EVENT_RECV_SCAN_RESULT: 1692 ret = ProcessEventWpaRecvScanResult(pos, (struct WpaRecvScanResultParam *)data, ifName); 1693 break; 1694 case WPA_EVENT_STA_AUTH_REJECT: 1695 ret = ProcessEventWpaAuthReject(pos, (struct WpaAuthRejectParam *)data, ifName); 1696 break; 1697 case WPA_EVENT_STA_NOTIFY: 1698 ret = ProcessEventStaNotify(pos, (char *)data, ifName); 1699 break; 1700 default: 1701 HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); 1702 break; 1703 } 1704 return ret; 1705 } 1706 HdfP2pDealEvent(uint32_t event,struct HdfWpaRemoteNode * pos,void * data,const char * ifName)1707 static int32_t HdfP2pDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) 1708 { 1709 int32_t ret = HDF_FAILURE; 1710 switch (event) { 1711 case WPA_EVENT_DEVICE_FOUND: 1712 ret = ProcessEventP2pDeviceFound(pos, (struct P2pDeviceInfoParam *)data, ifName); 1713 break; 1714 case WPA_EVENT_DEVICE_LOST: 1715 ret = ProcessEventP2pDeviceLost(pos, (struct P2pDeviceLostParam *)data, ifName); 1716 break; 1717 case WPA_EVENT_GO_NEGOTIATION_REQUEST: 1718 ret = ProcessEventP2pGoNegotiationRequest(pos, (struct P2pGoNegotiationRequestParam *)data, ifName); 1719 break; 1720 case WPA_EVENT_GO_NEGOTIATION_COMPLETED: 1721 ret = ProcessEventP2pGoNegotiationCompleted(pos, (struct P2pGoNegotiationCompletedParam *)data, ifName); 1722 break; 1723 case WPA_EVENT_INVITATION_RECEIVED: 1724 ret = ProcessEventP2pInvitationReceived(pos, (struct P2pInvitationReceivedParam *)data, ifName); 1725 break; 1726 case WPA_EVENT_INVITATION_RESULT: 1727 ret = ProcessEventP2pInvitationResult(pos, (struct P2pInvitationResultParam *)data, ifName); 1728 break; 1729 case WPA_EVENT_GROUP_FORMATION_SUCCESS: 1730 ret = ProcessEventP2pGroupFormationSuccess(pos, ifName); 1731 break; 1732 case WPA_EVENT_GROUP_FORMATION_FAILURE: 1733 ret = ProcessEventP2pGroupFormationFailure(pos, (char *)data, ifName); 1734 break; 1735 case WPA_EVENT_GROUP_START: 1736 ret = ProcessEventP2pGroupStarted(pos, (struct P2pGroupStartedParam *)data, ifName); 1737 break; 1738 case WPA_EVENT_GROUP_REMOVED: 1739 ret = ProcessEventP2pGroupRemoved(pos, (struct P2pGroupRemovedParam *)data, ifName); 1740 break; 1741 case WPA_EVENT_PROVISION_DISCOVERY_COMPLETED: 1742 ret = ProcessEventP2pProvisionDiscoveryCompleted(pos, (struct P2pProvisionDiscoveryCompletedParam *)data, 1743 ifName); 1744 break; 1745 case WPA_EVENT_FIND_STOPPED: 1746 ret = ProcessEventP2pFindStopped(pos, ifName); 1747 break; 1748 case WPA_EVENT_SERV_DISC_REQ: 1749 ret = ProcessEventP2pServDiscReq(pos, (struct P2pServDiscReqInfoParam *)data, ifName); 1750 break; 1751 case WPA_EVENT_SERV_DISC_RESP: 1752 ret = ProcessEventP2pServDiscResp(pos, (struct P2pServDiscRespParam *)data, ifName); 1753 break; 1754 case WPA_EVENT_STA_CONNECT_STATE: 1755 ret = ProcessEventP2pStaConnectState(pos, (struct P2pStaConnectStateParam *)data, ifName); 1756 break; 1757 case WPA_EVENT_IFACE_CREATED: 1758 ret = ProcessEventP2pIfaceCreated(pos, (struct P2pIfaceCreatedParam *)data, ifName); 1759 break; 1760 case WPA_EVENT_STA_NOTIFY: 1761 ret = ProcessEventStaNotify(pos, (char *)data, ifName); 1762 break; 1763 default: 1764 HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); 1765 break; 1766 } 1767 return ret; 1768 } 1769 HdfVendorExtDealEvent(uint32_t event,struct HdfWpaRemoteNode * pos,void * data,const char * ifName)1770 static int32_t HdfVendorExtDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) 1771 { 1772 int32_t ret = HDF_FAILURE; 1773 switch (event) { 1774 case WPA_EVENT_VENDOR_EXT: 1775 ret = ProcessEventWpaVendorExt(pos, (struct WpaVendorExtInfo *)data, ifName); 1776 break; 1777 default: 1778 HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); 1779 break; 1780 } 1781 return ret; 1782 } 1783 1784 HdfWpaCallbackFun(uint32_t event,void * data,const char * ifName)1785 static int32_t HdfWpaCallbackFun(uint32_t event, void *data, const char *ifName) 1786 { 1787 struct HdfWpaRemoteNode *pos = NULL; 1788 struct DListHead *head = NULL; 1789 int32_t ret = HDF_FAILURE; 1790 1791 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); 1792 head = &HdfWpaStubDriver()->remoteListHead; 1793 HDF_LOGD("%s: enter HdfWpaCallbackFun event =%u", __FUNCTION__, event); 1794 if (ifName == NULL) { 1795 HDF_LOGE("%{public}s: data or ifName is NULL!", __func__); 1796 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); 1797 return HDF_ERR_INVALID_PARAM; 1798 } 1799 DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { 1800 if (pos == NULL) { 1801 HDF_LOGE("%{public}s: pos is NULL", __func__); 1802 break; 1803 } 1804 if (pos->callbackObj == NULL) { 1805 HDF_LOGW("%{public}s: pos->callbackObj NULL", __func__); 1806 continue; 1807 } 1808 if (pos->service == NULL) { 1809 HDF_LOGW("%{public}s: pos->service NULL", __func__); 1810 continue; 1811 } 1812 if (strncmp(ifName, "wlan", strlen("wlan")) == 0 || strncmp(ifName, "common", strlen("common")) == 0) { 1813 ret = HdfStaDealEvent(event, pos, data, ifName); 1814 } else if (strncmp(ifName, "chba", strlen("chba")) == 0 || 1815 strncmp(ifName, "p2p-chba", strlen("p2p-chba")) == 0) { 1816 ret = HdfVendorExtDealEvent(event, pos, data, ifName); 1817 } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { 1818 ret = HdfP2pDealEvent(event, pos, data, ifName); 1819 } else { 1820 HDF_LOGE("%{public}s: ifName is error %{public}s", __func__, ifName); 1821 } 1822 if (ret != HDF_SUCCESS) { 1823 HDF_LOGE("%{public}s: dispatch code fialed, error code: %{public}d", __func__, ret); 1824 } 1825 } 1826 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); 1827 return ret; 1828 } 1829 WpaInterfaceRegisterEventCallback(struct IWpaInterface * self,struct IWpaCallback * cbFunc,const char * ifName)1830 int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, 1831 const char *ifName) 1832 { 1833 int32_t ret = HDF_FAILURE; 1834 1835 (void)self; 1836 pthread_mutex_lock(&g_interfaceLock); 1837 if (cbFunc == NULL || ifName == NULL) { 1838 pthread_mutex_unlock(&g_interfaceLock); 1839 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 1840 return HDF_ERR_INVALID_PARAM; 1841 } 1842 int nameLen = strlen(ifName); 1843 if (IsSockRemoved(ifName, nameLen) == 0) { 1844 pthread_mutex_unlock(&g_interfaceLock); 1845 HDF_LOGE("invalid opt"); 1846 return HDF_FAILURE; 1847 } 1848 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); 1849 do { 1850 HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); 1851 ret = HdfWpaAddRemoteObj(cbFunc, ifName); 1852 if (ret != HDF_SUCCESS) { 1853 HDF_LOGE("%{public}s: HdfSensorAddRemoteObj false", __func__); 1854 break; 1855 } 1856 ret = WpaRegisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); 1857 if (ret != HDF_SUCCESS) { 1858 HDF_LOGE("%{public}s: Register failed!, error code: %{public}d", __func__, ret); 1859 HdfWpaDelRemoteObj(cbFunc); 1860 break; 1861 } 1862 } while (0); 1863 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); 1864 pthread_mutex_unlock(&g_interfaceLock); 1865 return ret; 1866 } 1867 WpaInterfaceUnregisterEventCallback(struct IWpaInterface * self,struct IWpaCallback * cbFunc,const char * ifName)1868 int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, 1869 const char *ifName) 1870 { 1871 (void)self; 1872 pthread_mutex_lock(&g_interfaceLock); 1873 if (cbFunc == NULL || ifName == NULL) { 1874 pthread_mutex_unlock(&g_interfaceLock); 1875 HDF_LOGE("%{public}s: input parameter invalid!", __func__); 1876 return HDF_ERR_INVALID_PARAM; 1877 } 1878 int nameLen = strlen(ifName); 1879 if (IsSockRemoved(ifName, nameLen) == 0) { 1880 pthread_mutex_unlock(&g_interfaceLock); 1881 HDF_LOGE("invalid opt"); 1882 return HDF_FAILURE; 1883 } 1884 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); 1885 if (DListIsEmpty(&HdfWpaStubDriver()->remoteListHead)) { 1886 int32_t ret = WpaUnregisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); 1887 if (ret != HDF_SUCCESS) { 1888 HDF_LOGE("%{public}s: Unregister failed!, error code: %{public}d", __func__, ret); 1889 } 1890 } 1891 HdfWpaDelRemoteObj(cbFunc); 1892 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); 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 ClearHdfWpaRemoteObj(void)1951 void ClearHdfWpaRemoteObj(void) 1952 { 1953 struct HdfWpaRemoteNode *pos = NULL; 1954 struct HdfWpaRemoteNode *tmp = NULL; 1955 1956 (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); 1957 struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; 1958 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { 1959 DListRemove(&(pos->node)); 1960 IWpaCallbackRelease(pos->callbackObj); 1961 OsalMemFree(pos); 1962 pos = NULL; 1963 } 1964 (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); 1965 } 1966