1/* 2 * Copyright (c) 2022 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_fuzzer.h" 16 17#define WLAN_FREQ_MAX_NUM 35 18#define ETH_ADDR_LEN 6 19#define BITS_NUM_24 24 20#define BITS_NUM_16 16 21#define BITS_NUM_8 8 22#define REPLY_SIZE 1024 23 24static uint32_t g_wpaTestSize = 0; 25struct IWpaCallback *g_wpaCallbackObj = nullptr; 26 27uint32_t SetWpaDataSize(const uint32_t *dataSize) 28{ 29 if (dataSize != nullptr) { 30 g_wpaTestSize = *dataSize; 31 return HDF_SUCCESS; 32 } 33 HDF_LOGE("%{public}s: set data size failed!", __FUNCTION__); 34 return HDF_FAILURE; 35} 36 37uint32_t GetWpaDataSize(uint32_t *dataSize) 38{ 39 if (dataSize != nullptr) { 40 *dataSize = g_wpaTestSize; 41 return HDF_SUCCESS; 42 } 43 HDF_LOGE("%{public}s: get data size failed!", __FUNCTION__); 44 return HDF_FAILURE; 45} 46 47uint32_t Convert2Uint32(const uint8_t *ptr) 48{ 49 if (ptr == nullptr) { 50 return 0; 51 } 52 /* 53 * Move the 0th digit 24 to the left, the first digit 16 to the left, the second digit 8 to the left, 54 * and the third digit no left 55 */ 56 return (ptr[0] << BITS_NUM_24) | (ptr[1] << BITS_NUM_16) | (ptr[2] << BITS_NUM_8) | (ptr[3]); 57} 58 59bool PreProcessRawData(const uint8_t *rawData, size_t size, uint8_t *tmpRawData, size_t tmpRawDataSize) 60{ 61 if (rawData == nullptr || tmpRawData == nullptr) { 62 HDF_LOGE("%{public}s: rawData or tmpRawData is nullptr!", __FUNCTION__); 63 return false; 64 } 65 uint32_t dataSize = size - OFFSET; 66 if (memcpy_s(tmpRawData, tmpRawDataSize, rawData + OFFSET, dataSize) != EOK) { 67 HDF_LOGE("%{public}s: memcpy_s failed!", __FUNCTION__); 68 return false; 69 } 70 if (SetWpaDataSize(&dataSize) != HDF_SUCCESS) { 71 HDF_LOGE("%{public}s: set data size failed!", __FUNCTION__); 72 return false; 73 } 74 return true; 75} 76 77/* **********Wpa Interface********** */ 78void FuzzWpaInterfaceStart(struct IWpaInterface *interface, const uint8_t *rawData) 79{ 80 interface->Start(interface); 81 HDF_LOGI("%{public}s: success", __FUNCTION__); 82} 83 84void FuzzWpaInterfaceStop(struct IWpaInterface *interface, const uint8_t *rawData) 85{ 86 interface->Stop(interface); 87 HDF_LOGI("%{public}s: success", __FUNCTION__); 88} 89 90void FuzzWpaInterfaceScan(struct IWpaInterface *interface, const uint8_t *rawData) 91{ 92 const char *ifName = reinterpret_cast<const char *>(rawData); 93 94 interface->Scan(interface, ifName); 95 HDF_LOGI("%{public}s: success", __FUNCTION__); 96} 97 98void FuzzWpaInterfaceScanResult(struct IWpaInterface *interface, const uint8_t *rawData) 99{ 100 const char *ifName = reinterpret_cast<const char *>(rawData); 101 unsigned char buf[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 102 uint32_t bufLen = ETH_ADDR_LEN; 103 interface->ScanResult(interface, ifName, buf, &bufLen); 104 HDF_LOGI("%{public}s: success", __FUNCTION__); 105} 106 107void FuzzWpaInterfaceAddNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 108{ 109 const char *ifName = reinterpret_cast<const char *>(rawData); 110 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 111 112 interface->AddNetwork(interface, ifName, &networkId); 113 HDF_LOGI("%{public}s: success", __FUNCTION__); 114} 115 116void FuzzWpaInterfaceRemoveNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 117{ 118 const char *ifName = reinterpret_cast<const char *>(rawData); 119 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 120 121 interface->RemoveNetwork(interface, ifName, networkId); 122 HDF_LOGI("%{public}s: success", __FUNCTION__); 123} 124 125void FuzzWpaInterfaceDisableNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 126{ 127 const char *ifName = reinterpret_cast<const char *>(rawData); 128 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 129 130 interface->DisableNetwork(interface, ifName, networkId); 131 HDF_LOGI("%{public}s: success", __FUNCTION__); 132} 133 134void FuzzWpaInterfaceSetNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 135{ 136 const char *ifName = reinterpret_cast<const char *>(rawData); 137 const char *name = reinterpret_cast<const char *>(rawData); 138 const char *value = reinterpret_cast<const char *>(rawData); 139 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 140 141 interface->SetNetwork(interface, ifName, networkId, name, value); 142 HDF_LOGI("%{public}s: success", __FUNCTION__); 143} 144 145void FuzzWpaInterfaceReconnect(struct IWpaInterface *interface, const uint8_t *rawData) 146{ 147 const char *ifName = reinterpret_cast<const char *>(rawData); 148 149 interface->Reconnect(interface, ifName); 150 HDF_LOGI("%{public}s: success", __FUNCTION__); 151} 152 153void FuzzWpaInterfaceDisconnect(struct IWpaInterface *interface, const uint8_t *rawData) 154{ 155 const char *ifName = reinterpret_cast<const char *>(rawData); 156 157 interface->Disconnect(interface, ifName); 158 HDF_LOGI("%{public}s: success", __FUNCTION__); 159} 160 161void FuzzWpaInterfaceSelectNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 162{ 163 const char *ifName = reinterpret_cast<const char *>(rawData); 164 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 165 166 interface->SelectNetwork(interface, ifName, networkId); 167 HDF_LOGI("%{public}s: success", __FUNCTION__); 168} 169 170void FuzzWpaInterfaceEnableNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 171{ 172 const char *ifName = reinterpret_cast<const char *>(rawData); 173 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 174 175 interface->EnableNetwork(interface, ifName, networkId); 176 HDF_LOGI("%{public}s: success", __FUNCTION__); 177} 178 179void FuzzWpaInterfaceSetPowerSave(struct IWpaInterface *interface, const uint8_t *rawData) 180{ 181 const char *ifName = reinterpret_cast<const char *>(rawData); 182 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 183 184 interface->SetPowerSave(interface, ifName, enable); 185 HDF_LOGI("%{public}s: success", __FUNCTION__); 186} 187 188void FuzzWpaInterfaceAutoConnect(struct IWpaInterface *interface, const uint8_t *rawData) 189{ 190 const char *ifName = reinterpret_cast<const char *>(rawData); 191 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 192 193 interface->AutoConnect(interface, ifName, enable); 194 HDF_LOGI("%{public}s: success", __FUNCTION__); 195} 196 197void FuzzWpaInterfaceSaveConfig(struct IWpaInterface *interface, const uint8_t *rawData) 198{ 199 const char *ifName = reinterpret_cast<const char *>(rawData); 200 201 interface->SaveConfig(interface, ifName); 202 HDF_LOGI("%{public}s: success", __FUNCTION__); 203} 204 205void FuzzWpaInterfaceWpsCancel(struct IWpaInterface *interface, const uint8_t *rawData) 206{ 207 const char *ifName = reinterpret_cast<const char *>(rawData); 208 209 interface->WpsCancel(interface, ifName); 210 HDF_LOGI("%{public}s: success", __FUNCTION__); 211} 212 213void FuzzWpaInterfaceGetCountryCode(struct IWpaInterface *interface, const uint8_t *rawData) 214{ 215 const char *ifName = reinterpret_cast<const char *>(rawData); 216 char countryCode[3] = {0}; 217 218 interface->GetCountryCode(interface, ifName, countryCode, 3); 219 HDF_LOGI("%{public}s: success", __FUNCTION__); 220} 221 222void FuzzWpaInterfaceGetNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 223{ 224 const char *ifName = reinterpret_cast<const char *>(rawData); 225 int networkId = 0; 226 char value[32] = {0}; 227 228 interface->GetNetwork(interface, ifName, networkId, "ssid", value, 32); 229 HDF_LOGI("%{public}s: success", __FUNCTION__); 230} 231 232void FuzzWpaInterfaceBlocklistClear(struct IWpaInterface *interface, const uint8_t *rawData) 233{ 234 const char *ifName = reinterpret_cast<const char *>(rawData); 235 236 interface->BlocklistClear(interface, ifName); 237 HDF_LOGI("%{public}s: success", __FUNCTION__); 238} 239 240void FuzzWpaInterfaceSetSuspendMode(struct IWpaInterface *interface, const uint8_t *rawData) 241{ 242 const char *ifName = reinterpret_cast<const char *>(rawData); 243 int32_t mode = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 244 245 interface->SetSuspendMode(interface, ifName, mode); 246 HDF_LOGI("%{public}s: success", __FUNCTION__); 247} 248 249void FuzzWpaInterfaceGetScanSsid(struct IWpaInterface *interface, const uint8_t *rawData) 250{ 251 const char *ifName = reinterpret_cast<const char *>(rawData); 252 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 253 254 interface->GetScanSsid(interface, ifName, &enable); 255 HDF_LOGI("%{public}s: success", __FUNCTION__); 256} 257 258void FuzzWpaInterfaceGetPskPassphrase(struct IWpaInterface *interface, const uint8_t *rawData) 259{ 260 const char *ifName = reinterpret_cast<const char *>(rawData); 261 char psk[32] = {0}; 262 263 interface->GetPskPassphrase(interface, ifName, psk, 32); 264 HDF_LOGI("%{public}s: success", __FUNCTION__); 265} 266 267void FuzzWpaInterfaceGetPsk(struct IWpaInterface *interface, const uint8_t *rawData) 268{ 269 const char *ifName = reinterpret_cast<const char *>(rawData); 270 uint8_t psk[32] = {0}; 271 uint32_t pskLen = 32; 272 273 interface->GetPsk(interface, ifName, psk, &pskLen); 274 HDF_LOGI("%{public}s: success", __FUNCTION__); 275} 276 277void FuzzWpaInterfaceGetWepKey(struct IWpaInterface *interface, const uint8_t *rawData) 278{ 279 const char *ifName = reinterpret_cast<const char *>(rawData); 280 uint8_t wepKey[16] = {0}; 281 uint32_t wepKeyLen = 16; 282 283 interface->GetWepKey(interface, ifName, 1, wepKey, &wepKeyLen); 284 HDF_LOGI("%{public}s: success", __FUNCTION__); 285} 286 287void FuzzWpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *interface, const uint8_t *rawData) 288{ 289 const char *ifName = reinterpret_cast<const char *>(rawData); 290 int keyIdx = *const_cast<int *>(reinterpret_cast<const int *>(rawData)); 291 292 interface->GetWepTxKeyIdx(interface, ifName, &keyIdx); 293 HDF_LOGI("%{public}s: success", __FUNCTION__); 294} 295 296void FuzzWpaInterfaceGetRequirePmf(struct IWpaInterface *interface, const uint8_t *rawData) 297{ 298 const char *ifName = reinterpret_cast<const char *>(rawData); 299 int enable = *const_cast<int *>(reinterpret_cast<const int *>(rawData)); 300 301 interface->GetRequirePmf(interface, ifName, &enable); 302 HDF_LOGI("%{public}s: success", __FUNCTION__); 303} 304 305void FuzzWpaInterfaceSetCountryCode(struct IWpaInterface *interface, const uint8_t *rawData) 306{ 307 const char *ifName = reinterpret_cast<const char *>(rawData); 308 const char countryCode[3] = {0}; 309 310 interface->SetCountryCode(interface, ifName, countryCode); 311 HDF_LOGI("%{public}s: success", __FUNCTION__); 312} 313 314void FuzzWpaInterfaceListNetworks(struct IWpaInterface *interface, const uint8_t *rawData) 315{ 316 const char *ifName = reinterpret_cast<const char *>(rawData); 317 struct HdiWifiWpaNetworkInfo networkInfo; 318 (void)memset_s(&networkInfo, sizeof(struct HdiWifiWpaNetworkInfo), 0, sizeof(struct HdiWifiWpaNetworkInfo)); 319 uint32_t networkInfoLen = 0; 320 321 interface->ListNetworks(interface, ifName, (struct HdiWifiWpaNetworkInfo *)&networkInfo, &networkInfoLen); 322 HDF_LOGI("%{public}s: success", __FUNCTION__); 323} 324 325void FuzzWpaInterfaceWifiStatus(struct IWpaInterface *interface, const uint8_t *rawData) 326{ 327 const char *ifName = reinterpret_cast<const char *>(rawData); 328 struct HdiWpaCmdStatus wifiStatus; 329 (void)memset_s(&wifiStatus, sizeof(struct HdiWpaCmdStatus), 0, sizeof(struct HdiWpaCmdStatus)); 330 331 interface->WifiStatus(interface, ifName, &wifiStatus); 332 HDF_LOGI("%{public}s: success", __FUNCTION__); 333} 334 335void FuzzWpaInterfaceWpsPbcMode(struct IWpaInterface *interface, const uint8_t *rawData) 336{ 337 const char *ifName = reinterpret_cast<const char *>(rawData); 338 struct HdiWifiWpsParam wpsParam; 339 (void)memset_s(&wpsParam, sizeof(struct HdiWifiWpsParam), 0, sizeof(struct HdiWifiWpsParam)); 340 wpsParam.anyFlag = 1; 341 wpsParam.multiAp = 1; 342 wpsParam.bssidLen = 6; 343 wpsParam.bssid = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * (wpsParam.bssidLen))); 344 if (wpsParam.bssid == nullptr) { 345 return; 346 } 347 wpsParam.bssid[0] = 0x12; 348 wpsParam.bssid[1] = 0x34; 349 wpsParam.bssid[2] = 0x56; 350 wpsParam.bssid[3] = 0x78; 351 wpsParam.bssid[4] = 0xab; 352 wpsParam.bssid[5] = 0xcd; 353 354 interface->WpsPbcMode(interface, ifName, &wpsParam); 355 OsalMemFree(wpsParam.bssid); 356 HDF_LOGI("%{public}s: success", __FUNCTION__); 357} 358 359void FuzzWpaInterfaceWpsPinMode(struct IWpaInterface *interface, const uint8_t *rawData) 360{ 361 const char *ifName = reinterpret_cast<const char *>(rawData); 362 struct HdiWifiWpsParam wpsParam; 363 (void)memset_s(&wpsParam, sizeof(struct HdiWifiWpsParam), 0, sizeof(struct HdiWifiWpsParam)); 364 wpsParam.anyFlag = 1; 365 wpsParam.multiAp = 1; 366 wpsParam.bssidLen = 6; 367 wpsParam.bssid = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * (wpsParam.bssidLen))); 368 if (wpsParam.bssid == nullptr) { 369 return; 370 } 371 wpsParam.bssid[0] = 0x12; 372 wpsParam.bssid[1] = 0x34; 373 wpsParam.bssid[2] = 0x56; 374 wpsParam.bssid[3] = 0x78; 375 wpsParam.bssid[4] = 0xab; 376 wpsParam.bssid[5] = 0xcd; 377 int pinCode = 0; 378 379 interface->WpsPinMode(interface, ifName, &wpsParam, &pinCode); 380 OsalMemFree(wpsParam.bssid); 381 HDF_LOGI("%{public}s: success", __FUNCTION__); 382} 383 384void FuzzWpaInterfaceRegisterEventCallback(struct IWpaInterface *interface, const uint8_t *rawData) 385{ 386 const char *ifName = reinterpret_cast<const char *>(rawData); 387 388 interface->RegisterEventCallback(interface, g_wpaCallbackObj, ifName); 389 HDF_LOGI("%{public}s: success", __FUNCTION__); 390} 391 392void FuzzWpaInterfaceUnregisterEventCallback(struct IWpaInterface *interface, const uint8_t *rawData) 393{ 394 const char *ifName = reinterpret_cast<const char *>(rawData); 395 396 interface->UnregisterEventCallback(interface, g_wpaCallbackObj, ifName); 397 HDF_LOGI("%{public}s: success", __FUNCTION__); 398} 399 400void FuzzWpaInterfaceGetConnectionCapabilities(struct IWpaInterface *interface, const uint8_t *rawData) 401{ 402 const char *ifName = reinterpret_cast<const char *>(rawData); 403 struct ConnectionCapabilities connectionCap; 404 (void)memset_s(&connectionCap, sizeof(struct ConnectionCapabilities), 0, sizeof(struct ConnectionCapabilities)); 405 406 interface->GetConnectionCapabilities(interface, ifName, &connectionCap); 407 HDF_LOGI("%{public}s: success", __FUNCTION__); 408} 409 410void FuzzWpaInterfaceAddWpaIface(struct IWpaInterface *interface, const uint8_t *rawData) 411{ 412 const char *ifName = reinterpret_cast<const char *>(rawData); 413 const char *configname = "/data/service/el1/public/wifi/wpa_supplicant/wpa_supplicant.conf"; 414 interface->AddWpaIface(interface, ifName, configname); 415 HDF_LOGI("%{public}s: success", __FUNCTION__); 416} 417 418void FuzzWpaInterfaceRemoveWpaIface(struct IWpaInterface *interface, const uint8_t *rawData) 419{ 420 const char *ifName = reinterpret_cast<const char *>(rawData); 421 422 interface->RemoveWpaIface(interface, ifName); 423 HDF_LOGI("%{public}s: success", __FUNCTION__); 424} 425 426void FuzzWpaInterfaceReassociate(struct IWpaInterface *interface, const uint8_t *rawData) 427{ 428 const char *ifName = reinterpret_cast<const char *>(rawData); 429 430 interface->Reassociate(interface, ifName); 431 HDF_LOGI("%{public}s: success", __FUNCTION__); 432} 433 434void FuzzWpaInterfaceStaShellCmd(struct IWpaInterface *interface, const uint8_t *rawData) 435{ 436 const char *ifName = reinterpret_cast<const char *>(rawData); 437 const char *cmd = reinterpret_cast<const char *>(rawData); 438 439 interface->StaShellCmd(interface, ifName, cmd); 440 HDF_LOGI("%{public}s: success", __FUNCTION__); 441} 442 443 444/* **********P2p Interface********** */ 445void FuzzWpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface *interface, const uint8_t *rawData) 446{ 447 const char *ifName = reinterpret_cast<const char *>(rawData); 448 const char *name = reinterpret_cast<const char *>(rawData); 449 450 interface->P2pSetSsidPostfixName(interface, ifName, name); 451 HDF_LOGI("%{public}s: success", __FUNCTION__); 452} 453 454void FuzzWpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface *interface, const uint8_t *rawData) 455{ 456 const char *ifName = reinterpret_cast<const char *>(rawData); 457 const char *type = reinterpret_cast<const char *>(rawData); 458 459 interface->P2pSetWpsDeviceType(interface, ifName, type); 460 HDF_LOGI("%{public}s: success", __FUNCTION__); 461} 462 463void FuzzWpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface *interface, const uint8_t *rawData) 464{ 465 const char *ifName = reinterpret_cast<const char *>(rawData); 466 const char *methods = reinterpret_cast<const char *>(rawData); 467 468 interface->P2pSetWpsConfigMethods(interface, ifName, methods); 469 HDF_LOGI("%{public}s: success", __FUNCTION__); 470} 471 472void FuzzWpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface *interface, const uint8_t *rawData) 473{ 474 const char *ifName = reinterpret_cast<const char *>(rawData); 475 int32_t time = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 476 477 interface->P2pSetGroupMaxIdle(interface, ifName, time); 478 HDF_LOGI("%{public}s: success", __FUNCTION__); 479} 480 481void FuzzWpaInterfaceP2pSetWfdEnable(struct IWpaInterface *interface, const uint8_t *rawData) 482{ 483 const char *ifName = reinterpret_cast<const char *>(rawData); 484 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 485 486 interface->P2pSetWfdEnable(interface, ifName, enable); 487 HDF_LOGI("%{public}s: success", __FUNCTION__); 488} 489 490void FuzzWpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface *interface, const uint8_t *rawData) 491{ 492 const char *ifName = reinterpret_cast<const char *>(rawData); 493 int32_t status = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 494 495 interface->P2pSetPersistentReconnect(interface, ifName, status); 496 HDF_LOGI("%{public}s: success", __FUNCTION__); 497} 498 499void FuzzWpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface *interface, const uint8_t *rawData) 500{ 501 const char *ifName = reinterpret_cast<const char *>(rawData); 502 const char *type = reinterpret_cast<const char *>(rawData); 503 504 interface->P2pSetWpsSecondaryDeviceType(interface, ifName, type); 505 HDF_LOGI("%{public}s: success", __FUNCTION__); 506} 507 508void FuzzWpaInterfaceP2pSetupWpsPbc(struct IWpaInterface *interface, const uint8_t *rawData) 509{ 510 const char *ifName = reinterpret_cast<const char *>(rawData); 511 const char *address = reinterpret_cast<const char *>(rawData); 512 513 interface->P2pSetupWpsPbc(interface, ifName, address); 514 HDF_LOGI("%{public}s: success", __FUNCTION__); 515} 516 517void FuzzWpaInterfaceP2pSetupWpsPin(struct IWpaInterface *interface, const uint8_t *rawData) 518{ 519 const char *ifName = reinterpret_cast<const char *>(rawData); 520 const char *address = reinterpret_cast<const char *>(rawData); 521 const char *pin = reinterpret_cast<const char *>(rawData); 522 char result[32] = {0}; 523 uint32_t resultLen = *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(rawData)); 524 525 526 interface->P2pSetupWpsPin(interface, ifName, address, pin, result, resultLen); 527 HDF_LOGI("%{public}s: success", __FUNCTION__); 528} 529 530void FuzzWpaInterfaceP2pSetPowerSave(struct IWpaInterface *interface, const uint8_t *rawData) 531{ 532 const char *ifName = reinterpret_cast<const char *>(rawData); 533 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 534 535 interface->P2pSetPowerSave(interface, ifName, enable); 536 HDF_LOGI("%{public}s: success", __FUNCTION__); 537} 538 539void FuzzWpaInterfaceP2pSetDeviceName(struct IWpaInterface *interface, const uint8_t *rawData) 540{ 541 const char *ifName = reinterpret_cast<const char *>(rawData); 542 const char *name = reinterpret_cast<const char *>(rawData); 543 544 interface->P2pSetDeviceName(interface, ifName, name); 545 HDF_LOGI("%{public}s: success", __FUNCTION__); 546} 547 548void FuzzWpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface *interface, const uint8_t *rawData) 549{ 550 const char *ifName = reinterpret_cast<const char *>(rawData); 551 const char *config = reinterpret_cast<const char *>(rawData); 552 553 interface->P2pSetWfdDeviceConfig(interface, ifName, config); 554 HDF_LOGI("%{public}s: success", __FUNCTION__); 555} 556 557void FuzzWpaInterfaceP2pSetRandomMac(struct IWpaInterface *interface, const uint8_t *rawData) 558{ 559 const char *ifName = reinterpret_cast<const char *>(rawData); 560 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 561 562 interface->P2pSetRandomMac(interface, ifName, networkId); 563 HDF_LOGI("%{public}s: success", __FUNCTION__); 564} 565 566void FuzzWpaInterfaceP2pStartFind(struct IWpaInterface *interface, const uint8_t *rawData) 567{ 568 const char *ifName = reinterpret_cast<const char *>(rawData); 569 int32_t timeout = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 570 571 interface->P2pStartFind(interface, ifName, timeout); 572 HDF_LOGI("%{public}s: success", __FUNCTION__); 573} 574 575void FuzzWpaInterfaceP2pSetExtListen(struct IWpaInterface *interface, const uint8_t *rawData) 576{ 577 const char *ifName = reinterpret_cast<const char *>(rawData); 578 int32_t enable = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 579 int32_t period = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 580 int32_t interval = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 581 582 interface->P2pSetExtListen(interface, ifName, enable, period, interval); 583 HDF_LOGI("%{public}s: success", __FUNCTION__); 584} 585 586void FuzzWpaInterfaceP2pSetListenChannel(struct IWpaInterface *interface, const uint8_t *rawData) 587{ 588 const char *ifName = reinterpret_cast<const char *>(rawData); 589 int32_t channel = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 590 int32_t regClass = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 591 592 interface->P2pSetListenChannel(interface, ifName, channel, regClass); 593 HDF_LOGI("%{public}s: success", __FUNCTION__); 594} 595 596void FuzzWpaInterfaceP2pProvisionDiscovery(struct IWpaInterface *interface, const uint8_t *rawData) 597{ 598 const char *ifName = reinterpret_cast<const char *>(rawData); 599 const char *peerBssid = reinterpret_cast<const char *>(rawData); 600 int32_t mode = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 601 602 interface->P2pProvisionDiscovery(interface, ifName, peerBssid, mode); 603 HDF_LOGI("%{public}s: success", __FUNCTION__); 604} 605 606void FuzzWpaInterfaceP2pAddGroup(struct IWpaInterface *interface, const uint8_t *rawData) 607{ 608 const char *ifName = reinterpret_cast<const char *>(rawData); 609 int32_t isPersistent = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 610 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 611 int32_t freq = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 612 613 interface->P2pAddGroup(interface, ifName, isPersistent, networkId, freq); 614 HDF_LOGI("%{public}s: success", __FUNCTION__); 615} 616 617void FuzzWpaInterfaceP2pAddService(struct IWpaInterface *interface, const uint8_t *rawData) 618{ 619 const char *ifName = reinterpret_cast<const char *>(rawData); 620 struct HdiP2pServiceInfo info = {0}; 621 (void)memset_s(&info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo)); 622 info.mode = 0; 623 info.version = 0; 624 const int nameLen = 32; 625 const int paramLen = 1; 626 info.nameLen = nameLen; 627 info.queryLen = paramLen; 628 info.respLen = paramLen; 629 info.name = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * nameLen)); 630 info.query = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * paramLen)); 631 info.resp = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * paramLen)); 632 if (info.name == nullptr || info.query == nullptr || info.resp == nullptr) { 633 HDF_LOGI("%{public}s: OsalMemCalloc fail", __FUNCTION__); 634 return; 635 } 636 strcpy_s((char *)info.name, sizeof(info.name), "p2p0"); 637 638 interface->P2pAddService(interface, ifName, &info); 639 OsalMemFree(info.name); 640 OsalMemFree(info.query); 641 OsalMemFree(info.resp); 642 HDF_LOGI("%{public}s: success", __FUNCTION__); 643} 644 645void FuzzWpaInterfaceP2pRemoveService(struct IWpaInterface *interface, const uint8_t *rawData) 646{ 647 const char *ifName = reinterpret_cast<const char *>(rawData); 648 struct HdiP2pServiceInfo info = {0}; 649 (void)memset_s(&info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo)); 650 info.mode = 0; 651 info.version = 0; 652 const int nameLen = 32; 653 const int paramLen = 1; 654 info.nameLen = nameLen; 655 info.queryLen = paramLen; 656 info.respLen = paramLen; 657 info.name = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * nameLen)); 658 info.query = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * paramLen)); 659 info.resp = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * paramLen)); 660 if (info.name == nullptr || info.query == nullptr || info.resp == nullptr) { 661 HDF_LOGI("%{public}s: OsalMemCalloc fail", __FUNCTION__); 662 return; 663 } 664 strcpy_s((char *)info.name, sizeof(info.name), "p2p0"); 665 666 interface->P2pRemoveService(interface, ifName, &info); 667 OsalMemFree(info.name); 668 OsalMemFree(info.query); 669 OsalMemFree(info.resp); 670 HDF_LOGI("%{public}s: success", __FUNCTION__); 671} 672 673void FuzzWpaInterfaceP2pStopFind(struct IWpaInterface *interface, const uint8_t *rawData) 674{ 675 const char *ifName = reinterpret_cast<const char *>(rawData); 676 677 interface->P2pStopFind(interface, ifName); 678 HDF_LOGI("%{public}s: success", __FUNCTION__); 679} 680 681void FuzzWpaInterfaceP2pFlush(struct IWpaInterface *interface, const uint8_t *rawData) 682{ 683 const char *ifName = reinterpret_cast<const char *>(rawData); 684 685 interface->P2pFlush(interface, ifName); 686 HDF_LOGI("%{public}s: success", __FUNCTION__); 687} 688 689void FuzzWpaInterfaceP2pFlushService(struct IWpaInterface *interface, const uint8_t *rawData) 690{ 691 const char *ifName = reinterpret_cast<const char *>(rawData); 692 693 interface->P2pFlushService(interface, ifName); 694 HDF_LOGI("%{public}s: success", __FUNCTION__); 695} 696 697void FuzzWpaInterfaceP2pRemoveNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 698{ 699 const char *ifName = reinterpret_cast<const char *>(rawData); 700 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 701 702 interface->P2pRemoveNetwork(interface, ifName, networkId); 703 HDF_LOGI("%{public}s: success", __FUNCTION__); 704} 705 706void FuzzWpaInterfaceP2pSetGroupConfig(struct IWpaInterface *interface, const uint8_t *rawData) 707{ 708 const char *ifName = reinterpret_cast<const char *>(rawData); 709 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 710 const char *name = reinterpret_cast<const char *>(rawData); 711 const char *value = reinterpret_cast<const char *>(rawData); 712 713 interface->P2pSetGroupConfig(interface, ifName, networkId, name, value); 714 HDF_LOGI("%{public}s: success", __FUNCTION__); 715} 716 717void FuzzWpaInterfaceP2pInvite(struct IWpaInterface *interface, const uint8_t *rawData) 718{ 719 const char *ifName = reinterpret_cast<const char *>(rawData); 720 const char *peerBssid = reinterpret_cast<const char *>(rawData); 721 const char *goBssid = reinterpret_cast<const char *>(rawData); 722 723 interface->P2pInvite(interface, ifName, peerBssid, goBssid); 724 HDF_LOGI("%{public}s: success", __FUNCTION__); 725} 726 727void FuzzWpaInterfaceP2pReinvoke(struct IWpaInterface *interface, const uint8_t *rawData) 728{ 729 const char *ifName = reinterpret_cast<const char *>(rawData); 730 const char *bssid = reinterpret_cast<const char *>(rawData); 731 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 732 733 interface->P2pReinvoke(interface, ifName, networkId, bssid); 734 HDF_LOGI("%{public}s: success", __FUNCTION__); 735} 736 737void FuzzWpaInterfaceP2pGetDeviceAddress(struct IWpaInterface *interface, const uint8_t *rawData) 738{ 739 const char *ifName = reinterpret_cast<const char *>(rawData); 740 char deviceAddress[32] = {0}; 741 uint32_t deviceAddressLen = *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(rawData)); 742 743 interface->P2pGetDeviceAddress(interface, ifName, deviceAddress, deviceAddressLen); 744 HDF_LOGI("%{public}s: success", __FUNCTION__); 745} 746 747void FuzzWpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface *interface, const uint8_t *rawData) 748{ 749 const char *ifName = reinterpret_cast<const char *>(rawData); 750 char *replyDisc = static_cast<char *>(calloc(REPLY_SIZE, sizeof(char))); 751 if (replyDisc == nullptr) { 752 return; 753 } 754 uint32_t replyDiscLen = REPLY_SIZE; 755 struct HdiP2pReqService reqService; 756 (void)memset_s(&reqService, sizeof(struct HdiP2pReqService), 0, sizeof(struct HdiP2pReqService)); 757 reqService.bssidLen = ETH_ADDR_LEN; 758 reqService.bssid = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * (reqService.bssidLen))); 759 if (reqService.bssid == nullptr) { 760 free(replyDisc); 761 return; 762 } 763 reqService.bssid[0] = 0x12; 764 reqService.bssid[1] = 0x34; 765 reqService.bssid[2] = 0x56; 766 reqService.bssid[3] = 0x78; 767 reqService.bssid[4] = 0xab; 768 reqService.bssid[5] = 0xcd; 769 770 interface->P2pReqServiceDiscovery(interface, ifName, &reqService, replyDisc, replyDiscLen); 771 free(replyDisc); 772 OsalMemFree(reqService.bssid); 773 HDF_LOGI("%{public}s: success", __FUNCTION__); 774} 775 776void FuzzWpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface *interface, const uint8_t *rawData) 777{ 778 const char *ifName = reinterpret_cast<const char *>(rawData); 779 const char *id = reinterpret_cast<const char *>(rawData); 780 781 interface->P2pCancelServiceDiscovery(interface, ifName, id); 782 HDF_LOGI("%{public}s: success", __FUNCTION__); 783} 784 785void FuzzWpaInterfaceP2pRespServerDiscovery(struct IWpaInterface *interface, const uint8_t *rawData) 786{ 787 const char *ifName = reinterpret_cast<const char *>(rawData); 788 struct HdiP2pServDiscReqInfo info; 789 (void)memset_s(&info, sizeof(struct HdiP2pServDiscReqInfo), 0, sizeof(struct HdiP2pServDiscReqInfo)); 790 791 interface->P2pRespServerDiscovery(interface, ifName, &info); 792 HDF_LOGI("%{public}s: success", __FUNCTION__); 793} 794 795void FuzzWpaInterfaceP2pConnect(struct IWpaInterface *interface, const uint8_t *rawData) 796{ 797 const char *ifName = reinterpret_cast<const char *>(rawData); 798 struct HdiP2pConnectInfo info; 799 (void)memset_s(&info, sizeof(struct HdiP2pConnectInfo), 0, sizeof(struct HdiP2pConnectInfo)); 800 char *replyPin = static_cast<char *>(calloc(REPLY_SIZE, sizeof(char))); 801 if (replyPin == nullptr) { 802 return; 803 } 804 uint32_t replyPinLen = REPLY_SIZE; 805 806 interface->P2pConnect(interface, ifName, &info, replyPin, replyPinLen); 807 free(replyPin); 808 HDF_LOGI("%{public}s: success", __FUNCTION__); 809} 810 811void FuzzWpaInterfaceP2pHid2dConnect(struct IWpaInterface *interface, const uint8_t *rawData) 812{ 813 const int macAddrIndexOne = 0; 814 const int macAddrIndexTwo = 1; 815 const int macAddrIndexThree = 2; 816 const int macAddrIndexFour = 3; 817 const int macAddrIndexFive = 4; 818 const int macAddrIndexSix = 5; 819 const char *ifName = reinterpret_cast<const char *>(rawData); 820 struct HdiHid2dConnectInfo info; 821 (void)memset_s(&info, sizeof(struct HdiHid2dConnectInfo), 0, sizeof(struct HdiHid2dConnectInfo)); 822 info.bssidLen = ETH_ADDR_LEN; 823 info.bssid = static_cast<uint8_t *>(OsalMemCalloc(sizeof(uint8_t) * (info.bssidLen))); 824 if (info.bssid == nullptr) { 825 return; 826 } 827 info.bssid[macAddrIndexOne] = 0x00; 828 info.bssid[macAddrIndexTwo] = 0x00; 829 info.bssid[macAddrIndexThree] = 0x00; 830 info.bssid[macAddrIndexFour] = 0x00; 831 info.bssid[macAddrIndexFive] = 0x00; 832 info.bssid[macAddrIndexSix] = 0x00; 833 interface->P2pHid2dConnect(interface, ifName, &info); 834 OsalMemFree(info.bssid); 835 HDF_LOGI("%{public}s: success", __FUNCTION__); 836} 837 838void FuzzWpaInterfaceP2pSetServDiscExternal(struct IWpaInterface *interface, const uint8_t *rawData) 839{ 840 const char *ifName = reinterpret_cast<const char *>(rawData); 841 int32_t mode = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 842 843 interface->P2pSetServDiscExternal(interface, ifName, mode); 844 HDF_LOGI("%{public}s: success", __FUNCTION__); 845} 846 847void FuzzWpaInterfaceP2pRemoveGroup(struct IWpaInterface *interface, const uint8_t *rawData) 848{ 849 const char *ifName = reinterpret_cast<const char *>(rawData); 850 const char *groupName = reinterpret_cast<const char *>(rawData); 851 852 interface->P2pRemoveGroup(interface, ifName, groupName); 853 HDF_LOGI("%{public}s: success", __FUNCTION__); 854} 855 856void FuzzWpaInterfaceP2pCancelConnect(struct IWpaInterface *interface, const uint8_t *rawData) 857{ 858 const char *ifName = reinterpret_cast<const char *>(rawData); 859 860 interface->P2pCancelConnect(interface, ifName); 861 HDF_LOGI("%{public}s: success", __FUNCTION__); 862} 863 864void FuzzWpaInterfaceP2pGetGroupConfig(struct IWpaInterface *interface, const uint8_t *rawData) 865{ 866 const char *ifName = reinterpret_cast<const char *>(rawData); 867 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 868 const char *param = reinterpret_cast<const char *>(rawData); 869 char value[32] = {0}; 870 uint32_t valueLen = *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(rawData)); 871 872 interface->P2pGetGroupConfig(interface, ifName, networkId, param, value, valueLen); 873 HDF_LOGI("%{public}s: success", __FUNCTION__); 874} 875 876void FuzzWpaInterfaceP2pAddNetwork(struct IWpaInterface *interface, const uint8_t *rawData) 877{ 878 const char *ifName = reinterpret_cast<const char *>(rawData); 879 int32_t networkId = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 880 881 interface->P2pAddNetwork(interface, ifName, &networkId); 882 HDF_LOGI("%{public}s: success", __FUNCTION__); 883} 884 885void FuzzWpaInterfaceP2pGetPeer(struct IWpaInterface *interface, const uint8_t *rawData) 886{ 887 const char *ifName = reinterpret_cast<const char *>(rawData); 888 const char *bssid = reinterpret_cast<const char *>(rawData); 889 struct HdiP2pDeviceInfo info; 890 (void)memset_s(&info, sizeof(struct HdiP2pDeviceInfo), 0, sizeof(struct HdiP2pDeviceInfo)); 891 892 interface->P2pGetPeer(interface, ifName, bssid, &info); 893 HDF_LOGI("%{public}s: success", __FUNCTION__); 894} 895 896void FuzzWpaInterfaceP2pGetGroupCapability(struct IWpaInterface *interface, const uint8_t *rawData) 897{ 898 const char *ifName = reinterpret_cast<const char *>(rawData); 899 const char *bssid = reinterpret_cast<const char *>(rawData); 900 int32_t cap = *const_cast<int32_t *>(reinterpret_cast<const int32_t *>(rawData)); 901 902 interface->P2pGetGroupCapability(interface, ifName, bssid, &cap); 903 HDF_LOGI("%{public}s: success", __FUNCTION__); 904} 905 906void FuzzWpaInterfaceP2pListNetworks(struct IWpaInterface *interface, const uint8_t *rawData) 907{ 908 const char *ifName = reinterpret_cast<const char *>(rawData); 909 struct HdiP2pNetworkList infoList; 910 (void)memset_s(&infoList, sizeof(struct HdiP2pNetworkList), 0, sizeof(struct HdiP2pNetworkList)); 911 912 interface->P2pListNetworks(interface, ifName, &infoList); 913 HDF_LOGI("%{public}s: success", __FUNCTION__); 914} 915 916void FuzzWpaInterfaceP2pSaveConfig(struct IWpaInterface *interface, const uint8_t *rawData) 917{ 918 const char *ifName = reinterpret_cast<const char *>(rawData); 919 920 interface->P2pSaveConfig(interface, ifName); 921 HDF_LOGI("%{public}s: success", __FUNCTION__); 922} 923