1 /*
2 * Copyright (c) 2020-2022 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "sta.h"
10 #include "securec.h"
11 #include "message/message_router.h"
12 #include "message/sidecar.h"
13 #include "wifi_base.h"
14 #include "hdf_wlan_services.h"
15 #include "hdf_wlan_utils.h"
16
17 #define HDF_LOG_TAG HDF_WIFI_CORE
18 #define ATTR_MIN_LEN 2
19
20 #ifdef __cplusplus
21 extern "C" {
22 #endif
23
Connect(struct NetDevice * netDev,struct WlanConnectParams * param)24 inline static int32_t Connect(struct NetDevice *netDev, struct WlanConnectParams *param)
25 {
26 struct HdfChipDriver *chipDriver = GetChipDriver(netDev);
27 if (chipDriver == NULL) {
28 HDF_LOGE("%s:bad net device found!", __func__);
29 return HDF_FAILURE;
30 }
31 RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, Connect);
32 return chipDriver->staOps->Connect(netDev, param);
33 }
34
Disconnect(struct NetDevice * netDev,uint16_t reasonCode)35 inline static int32_t Disconnect(struct NetDevice *netDev, uint16_t reasonCode)
36 {
37 struct HdfChipDriver *chipDriver = GetChipDriver(netDev);
38 if (chipDriver == NULL) {
39 HDF_LOGE("%s:bad net device found!", __func__);
40 return HDF_FAILURE;
41 }
42 RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, Disconnect);
43 return chipDriver->staOps->Disconnect(netDev, reasonCode);
44 }
45
ScanAll(struct NetDevice * netDev,struct WlanScanRequest * params)46 inline static int32_t ScanAll(struct NetDevice *netDev, struct WlanScanRequest *params)
47 {
48 struct HdfChipDriver *chipDriver = GetChipDriver(netDev);
49 if (chipDriver == NULL) {
50 HDF_LOGE("%s:bad net device found!", __func__);
51 return HDF_FAILURE;
52 }
53 RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, StartScan);
54 HDF_LOGI("%s: ScanAll finished!", __func__);
55 return chipDriver->staOps->StartScan(netDev, params);
56 }
57
AbortScan(struct NetDevice * netDev)58 inline static int32_t AbortScan(struct NetDevice *netDev)
59 {
60 struct HdfChipDriver *chipDriver = GetChipDriver(netDev);
61 if (chipDriver == NULL) {
62 HDF_LOGE("%s:bad net device found!", __func__);
63 return HDF_FAILURE;
64 }
65 RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, AbortScan);
66 return chipDriver->staOps->AbortScan(netDev);
67 }
68
WifiFillScanParam(struct WlanScanRequest * params,struct HdfSBuf * reqData)69 static int WifiFillScanParam(struct WlanScanRequest *params, struct HdfSBuf *reqData)
70 {
71 uint32_t dataSize = 0;
72 if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->bssid, &dataSize)) {
73 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "apSettings");
74 return HDF_FAILURE;
75 }
76 if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->ssids, &dataSize)) {
77 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ssids");
78 return HDF_FAILURE;
79 }
80 params->ssidCount = dataSize / sizeof(params->ssids[0]);
81 if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->extraIEs, &dataSize)) {
82 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "extraIes");
83 return HDF_FAILURE;
84 }
85 params->extraIEsLen = dataSize;
86 if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->freqs, &dataSize)) {
87 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freqs");
88 return HDF_FAILURE;
89 }
90 params->freqsCount =
91 (dataSize / sizeof(params->freqs[0])) < MAX_FREQ_FTILTER_COUNT ? (dataSize / sizeof(params->freqs[0])) : 0;
92
93 return HDF_SUCCESS;
94 }
95
WifiValidIeAttr(const uint8_t * ie,uint32_t len)96 static uint8_t WifiValidIeAttr(const uint8_t *ie, uint32_t len)
97 {
98 uint8_t elemLen;
99 if (ie == NULL) { // ie null is normal
100 return true;
101 }
102 while (len != 0) {
103 if (len < ATTR_MIN_LEN) {
104 return false;
105 }
106 len -= ATTR_MIN_LEN;
107 elemLen = ie[1];
108 if (elemLen > len) {
109 return false;
110 }
111 len -= elemLen;
112 ie += ATTR_MIN_LEN + elemLen;
113 }
114 return true;
115 }
116
WifiFillAssocParams(WifiAssociateParams * assoc,struct HdfSBuf * reqData)117 static int WifiFillAssocParams(WifiAssociateParams *assoc, struct HdfSBuf *reqData)
118 {
119 uint32_t dataSize = 0;
120 if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->bssid, &dataSize) || dataSize != ETH_ADDR_LEN) {
121 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "bssid");
122 return HDF_FAILURE;
123 }
124 if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->ssid, &(assoc->ssidLen))) {
125 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ssid");
126 return HDF_FAILURE;
127 }
128 if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->ie, &(assoc->ieLen))) {
129 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ie");
130 return HDF_FAILURE;
131 }
132 if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->key, &dataSize)) {
133 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "key");
134 return HDF_FAILURE;
135 }
136 if (!HdfSbufReadUint8(reqData, &assoc->authType)) {
137 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "authType");
138 return HDF_FAILURE;
139 }
140 if (!HdfSbufReadUint8(reqData, &assoc->privacy)) {
141 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "privacy");
142 return HDF_FAILURE;
143 }
144 if (!HdfSbufReadUint8(reqData, &assoc->keyIdx)) {
145 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "keyIdx");
146 return HDF_FAILURE;
147 }
148 if (!HdfSbufReadUint8(reqData, &assoc->mfp)) {
149 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "mfp");
150 return HDF_FAILURE;
151 }
152 if (!HdfSbufReadUint32(reqData, &assoc->freq)) {
153 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freq");
154 return HDF_FAILURE;
155 }
156 if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->crypto, &dataSize)) {
157 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "crypto");
158 return HDF_FAILURE;
159 }
160 if ((assoc->ssid == NULL) || (assoc->ssidLen == 0)) {
161 HDF_LOGE("%s:void ssid", __func__);
162 return HDF_FAILURE;
163 }
164 if (WifiValidIeAttr(assoc->ie, assoc->ieLen) == false) {
165 HDF_LOGE("%s:illegal ie", __func__);
166 return HDF_FAILURE;
167 }
168 return HDF_SUCCESS;
169 }
170
WifiSetAssocParams(const WifiAssociateParams * assoc,const struct NetDevice * netdev,struct WlanConnectParams * params)171 static int WifiSetAssocParams(const WifiAssociateParams *assoc, const struct NetDevice *netdev,
172 struct WlanConnectParams *params)
173 {
174 (void)netdev;
175 params->ssid = assoc->ssid;
176 params->ssidLen = assoc->ssidLen;
177 params->ie = assoc->ie;
178 params->ieLen = assoc->ieLen;
179 if ((assoc->authType > WIFI_AUTHTYPE_AUTOMATIC) || (assoc->authType == WIFI_AUTHTYPE_SAE)) {
180 HDF_LOGE("%s:illegal authType %u", __func__, assoc->authType);
181 return HDF_FAILURE;
182 }
183 params->authType = assoc->authType;
184 params->bssid = assoc->bssid;
185 params->privacy = assoc->privacy;
186 if ((assoc->mfp != WIFI_MFP_REQUIRED) && (assoc->mfp != WIFI_MFP_NO) && (assoc->mfp != WIFI_MFP_OPTIONAL)) {
187 HDF_LOGE("%s:unexpected mfp.mfp=%u", __func__, assoc->mfp);
188 return HDF_FAILURE;
189 }
190 params->mfp = (WifiMfp)assoc->mfp;
191 if (assoc->key != NULL) {
192 params->key = assoc->key;
193 params->keyLen = assoc->keyLen;
194 params->keyIdx = assoc->keyIdx;
195 }
196 if (memcpy_s(¶ms->crypto, sizeof(WifiCryptoSetting), assoc->crypto, sizeof(WifiCryptoSetting)) != EOK) {
197 HDF_LOGE("%s:copy crypto failed!", __func__);
198 return HDF_FAILURE;
199 }
200 return HDF_SUCCESS;
201 }
202
WifiCmdAssoc(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)203 static int32_t WifiCmdAssoc(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
204 {
205 struct WlanConnectParams params = { 0 };
206 WifiAssociateParams assoc = { 0 };
207 struct NetDevice *netdev = NULL;
208 struct WlanHwCapability *capability = NULL;
209 const char *ifName = NULL;
210 int32_t ret;
211 (void)context;
212 (void)rspData;
213 if (reqData == NULL) {
214 HDF_LOGE("%s: reqData is NULL", __func__);
215 return HDF_ERR_INVALID_PARAM;
216 }
217 ifName = HdfSbufReadString(reqData);
218 if (ifName == NULL) {
219 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName");
220 return HDF_FAILURE;
221 }
222 if (WifiFillAssocParams(&assoc, reqData) != HDF_SUCCESS) {
223 return HDF_FAILURE;
224 }
225 if ((netdev = NetDeviceGetInstByName(ifName)) == NULL) {
226 HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName);
227 return HDF_FAILURE;
228 }
229 if (WifiSetAssocParams(&assoc, netdev, ¶ms) != HDF_SUCCESS) {
230 HDF_LOGE("%s: WifiSetAssocParams failed", __func__);
231 return HDF_FAILURE;
232 }
233 capability = GetHwCapability(netdev);
234 if (capability == NULL) {
235 HDF_LOGE("%s:GetHwCapability failed!", __func__);
236 return HDF_FAILURE;
237 }
238 do {
239 params.centerFreq = assoc.freq;
240 HDF_LOGI("%s: %s connecting to AP ...", __func__, ifName);
241 ret = Connect(netdev, ¶ms);
242 if (ret != HDF_SUCCESS) {
243 HDF_LOGE("%s:fail to do connect,%d", __func__, ret);
244 break;
245 }
246 } while (false);
247 if (capability->Release != NULL) {
248 capability->Release(capability);
249 capability = NULL;
250 }
251 HDF_LOGI("%s: Wifi cmd Assoc finished!", __func__);
252 return ret;
253 }
254
WifiCmdDisconnect(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)255 static int32_t WifiCmdDisconnect(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
256 {
257 struct NetDevice *netdev = NULL;
258 uint16_t reasonCode;
259 const char *ifName = NULL;
260 int ret;
261 (void)context;
262 (void)rspData;
263 if (reqData == NULL) {
264 HDF_LOGE("%s: reqData is NULL", __func__);
265 return HDF_ERR_INVALID_PARAM;
266 }
267 ifName = HdfSbufReadString(reqData);
268 if (ifName == NULL) {
269 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName");
270 return HDF_FAILURE;
271 }
272 if (!HdfSbufReadUint16(reqData, &reasonCode)) {
273 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "reasonCode");
274 return HDF_FAILURE;
275 }
276 netdev = NetDeviceGetInstByName(ifName);
277 if (netdev == NULL) {
278 HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName);
279 return HDF_FAILURE;
280 }
281 HDF_LOGW("%s:%s disconnecting from AP...", __func__, ifName);
282 ret = Disconnect(netdev, reasonCode);
283 if (ret != HDF_SUCCESS) {
284 HDF_LOGE("%s:fail to do disconnect,%d", __func__, ret);
285 }
286 HDF_LOGI("%s: WifiCmdDisconnect finished!", __func__);
287 return ret;
288 }
289
WifiCmdScan(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)290 static int32_t WifiCmdScan(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
291 {
292 struct NetDevice *netdev = NULL;
293 const char *ifName = NULL;
294 struct WlanScanRequest params = { 0 };
295 int32_t ret;
296 (void)context;
297 (void)rspData;
298 if (reqData == NULL) {
299 HDF_LOGE("%s: reqData is NULL", __func__);
300 return HDF_ERR_INVALID_PARAM;
301 }
302 ifName = HdfSbufReadString(reqData);
303 if (ifName == NULL) {
304 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName");
305 return HDF_FAILURE;
306 }
307 netdev = NetDeviceGetInstByName(ifName);
308 if (netdev == NULL) {
309 HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName);
310 return HDF_FAILURE;
311 }
312 ret = WifiFillScanParam(¶ms, reqData);
313 if (ret != HDF_SUCCESS) {
314 HDF_LOGE("%s: WifiFillScanParam failed", __func__);
315 return ret;
316 }
317 ret = ScanAll(netdev, ¶ms);
318 if (ret != HDF_SUCCESS) {
319 HDF_LOGE("%s: ScanAll failed! ret=%d", __func__, ret);
320 }
321 HDF_LOGI("%s: WifiCmdScan finished!", __func__);
322 return ret;
323 }
324
WifiCmdAbortScan(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)325 static int32_t WifiCmdAbortScan(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
326 {
327 struct NetDevice *netdev = NULL;
328 int32_t ret;
329 const char *ifName = HdfSbufReadString(reqData);
330 (void)context;
331 (void)rspData;
332 if (ifName == NULL) {
333 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName");
334 return HDF_FAILURE;
335 }
336 netdev = NetDeviceGetInstByName(ifName);
337 if (netdev == NULL) {
338 HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName);
339 return HDF_FAILURE;
340 }
341 ret = AbortScan(netdev);
342 if (ret != HDF_SUCCESS) {
343 HDF_LOGE("%s:AbortScan failed!ret=%d", __func__, ret);
344 }
345 // keep return SUCCESS if AbortScan return FAILED
346 return HDF_SUCCESS;
347 }
348
WifiCmdSetScanningMacAddress(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)349 static int32_t WifiCmdSetScanningMacAddress(const RequestContext *context, struct HdfSBuf *reqData,
350 struct HdfSBuf *rspData)
351 {
352 int32_t ret;
353 uint8_t isFuncValid;
354 struct NetDevice *netdev = NULL;
355 const char *ifName = NULL;
356 unsigned char *mac = NULL;
357 uint32_t replayDataSize;
358 struct HdfChipDriver *chipDriver = NULL;
359 (void)context;
360 if (reqData == NULL || rspData == NULL) {
361 return HDF_ERR_INVALID_PARAM;
362 }
363 ifName = HdfSbufReadString(reqData);
364 if (ifName == NULL) {
365 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName");
366 return HDF_FAILURE;
367 }
368 netdev = NetDeviceGetInstByName(ifName);
369 if (netdev == NULL) {
370 HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName);
371 return HDF_FAILURE;
372 }
373 if (!HdfSbufReadBuffer(reqData, (const void **)&mac, &replayDataSize) || mac == NULL ||
374 replayDataSize != IEEE80211_MAC_ADDR_LEN) {
375 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "mac");
376 return HDF_FAILURE;
377 }
378 chipDriver = GetChipDriver(netdev);
379 if (chipDriver == NULL) {
380 HDF_LOGE("%s:bad net device found!", __func__);
381 return HDF_FAILURE;
382 }
383 RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, SetScanningMacAddress);
384 ret = chipDriver->staOps->SetScanningMacAddress(netdev, mac, IEEE80211_MAC_ADDR_LEN);
385 if (ret != HDF_SUCCESS && ret != HDF_ERR_NOT_SUPPORT) {
386 HDF_LOGE("%s: fail to do set scanning mac addr!ret=%d", __func__, ret);
387 return ret;
388 }
389 isFuncValid = (ret == HDF_ERR_NOT_SUPPORT) ? false : true;
390 if (!HdfSbufWriteUint8(rspData, isFuncValid)) {
391 HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED);
392 return HDF_FAILURE;
393 }
394 return HDF_SUCCESS;
395 }
396
HdfCmdfillPnoSettings(struct HdfSBuf * reqData,WifiPnoSettings * pnoSettings)397 static int32_t HdfCmdfillPnoSettings(struct HdfSBuf *reqData, WifiPnoSettings *pnoSettings)
398 {
399 uint32_t dataSize = 0;
400
401 if (!HdfSbufReadInt32(reqData, &(pnoSettings->min2gRssi))) {
402 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "min2gRssi");
403 return HDF_FAILURE;
404 }
405 if (!HdfSbufReadInt32(reqData, &(pnoSettings->min5gRssi))) {
406 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "min5gRssi");
407 return HDF_FAILURE;
408 }
409 if (!HdfSbufReadInt32(reqData, &(pnoSettings->scanIntervalMs))) {
410 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "scanIntervalMs");
411 return HDF_FAILURE;
412 }
413 if (!HdfSbufReadInt32(reqData, &(pnoSettings->scanIterations))) {
414 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "scanIterations");
415 return HDF_FAILURE;
416 }
417 if (!HdfSbufReadUint32(reqData, &(pnoSettings->pnoNetworksLen))) {
418 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "pnoNetworksLen");
419 return HDF_FAILURE;
420 }
421
422 pnoSettings->pnoNetworks = (WifiPnoNetwork *)OsalMemAlloc(sizeof(WifiPnoNetwork) * pnoSettings->pnoNetworksLen);
423 if (pnoSettings->pnoNetworks == NULL) {
424 HDF_LOGE("%s: alloc memory failed.", __func__);
425 return HDF_FAILURE;
426 }
427 for (uint32_t i = 0; i < pnoSettings->pnoNetworksLen; i++) {
428 if (!HdfSbufReadUint8(reqData, &(pnoSettings->pnoNetworks[i].isHidden))) {
429 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "isHidden");
430 return HDF_FAILURE;
431 }
432 if (!HdfSbufReadBuffer(reqData, (const void **)&pnoSettings->pnoNetworks[i].freqs, &dataSize)) {
433 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freqs");
434 return HDF_FAILURE;
435 }
436 pnoSettings->pnoNetworks[i].freqsLen = dataSize / sizeof(pnoSettings->pnoNetworks[i].freqs[0]);
437 if (!HdfSbufReadBuffer(reqData, (const void **)&pnoSettings->pnoNetworks[i].ssid.ssid,
438 &(pnoSettings->pnoNetworks[i].ssid.ssidLen))) {
439 HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ssid");
440 return HDF_FAILURE;
441 }
442 }
443
444 return HDF_SUCCESS;
445 }
446
HdfWlanStartPnoScan(const char * ifName,const WifiPnoSettings * pnoSettings)447 static int32_t HdfWlanStartPnoScan(const char *ifName, const WifiPnoSettings *pnoSettings)
448 {
449 struct NetDevice *netdev = NULL;
450 struct HdfChipDriver *chipDriver = NULL;
451
452 netdev = NetDeviceGetInstByName(ifName);
453 if (netdev == NULL) {
454 HDF_LOGE("%s:netdev not found!ifName=%s.", __func__, ifName);
455 return HDF_FAILURE;
456 }
457 chipDriver = GetChipDriver(netdev);
458 if (chipDriver == NULL) {
459 HDF_LOGE("%s:bad net device found!", __func__);
460 return HDF_FAILURE;
461 }
462 if (chipDriver->staOps == NULL) {
463 HDF_LOGE("%s: chipDriver->staOps is null", __func__);
464 return HDF_ERR_INVALID_OBJECT;
465 }
466 if (chipDriver->staOps->StartPnoScan == NULL) {
467 HDF_LOGE("%s: chipDriver->staOps->StartPnoScan is null", __func__);
468 return HDF_ERR_NOT_SUPPORT;
469 }
470 return chipDriver->staOps->StartPnoScan(netdev, pnoSettings);
471 }
472
HdfPnosettingsFree(WifiPnoSettings * pnoSettings)473 static void HdfPnosettingsFree(WifiPnoSettings *pnoSettings)
474 {
475 if (pnoSettings == NULL) {
476 HDF_LOGE("%{public}s input parameter is NULL!", __func__);
477 return;
478 }
479 if (pnoSettings->pnoNetworks != NULL) {
480 OsalMemFree(pnoSettings->pnoNetworks);
481 pnoSettings->pnoNetworks = NULL;
482 }
483 OsalMemFree(pnoSettings);
484 }
485
WifiCmdStartPnoScan(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)486 static int32_t WifiCmdStartPnoScan(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
487 {
488 int32_t ret = HDF_FAILURE;
489 const char *ifName = NULL;
490 (void)rspData;
491 (void)context;
492
493 if (reqData == NULL || rspData == NULL) {
494 return HDF_ERR_INVALID_PARAM;
495 }
496 ifName = HdfSbufReadString(reqData);
497 if (ifName == NULL) {
498 HDF_LOGE("%s: read ifName failed!", __func__);
499 return ret;
500 }
501 WifiPnoSettings *pnoSettings = (WifiPnoSettings *)OsalMemCalloc(sizeof(WifiPnoSettings));
502 if (pnoSettings == NULL) {
503 HDF_LOGE("%s: calloc memory failed!", __func__);
504 return ret;
505 }
506 ret = HdfCmdfillPnoSettings(reqData, pnoSettings);
507 if (ret != HDF_SUCCESS) {
508 HDF_LOGE("%s: HdfCmdfillPnoSettings failed!", __func__);
509 HdfPnosettingsFree(pnoSettings);
510 return ret;
511 }
512 ret = HdfWlanStartPnoScan(ifName, pnoSettings);
513 if (ret != HDF_SUCCESS) {
514 HDF_LOGE("%s: fail to start pno scan, %d", __func__, ret);
515 }
516 HdfPnosettingsFree(pnoSettings);
517 return ret;
518 }
519
HdfWlanStopPnoScan(const char * ifName)520 static int32_t HdfWlanStopPnoScan(const char *ifName)
521 {
522 struct NetDevice *netdev = NULL;
523 struct HdfChipDriver *chipDriver = NULL;
524
525 netdev = NetDeviceGetInstByName(ifName);
526 if (netdev == NULL) {
527 HDF_LOGE("%s:netdev not found!ifName=%s.", __func__, ifName);
528 return HDF_FAILURE;
529 }
530 chipDriver = GetChipDriver(netdev);
531 if (chipDriver == NULL) {
532 HDF_LOGE("%s:bad net device found!", __func__);
533 return HDF_FAILURE;
534 }
535 if (chipDriver->staOps == NULL) {
536 HDF_LOGE("%s: chipDriver->staOps is null", __func__);
537 return HDF_ERR_INVALID_OBJECT;
538 }
539
540 if (chipDriver->staOps->StopPnoScan == NULL) {
541 HDF_LOGE("%s: chipDriver->staOps->StopPnoScan is null", __func__);
542 return HDF_ERR_NOT_SUPPORT;
543 }
544 return chipDriver->staOps->StopPnoScan(netdev);
545 }
546
WifiCmdStopPnoScan(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)547 static int32_t WifiCmdStopPnoScan(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
548 {
549 int32_t ret = HDF_FAILURE;
550 const char *ifName = NULL;
551 (void)rspData;
552 (void)context;
553
554 if (reqData == NULL || rspData == NULL) {
555 return HDF_ERR_INVALID_PARAM;
556 }
557 ifName = HdfSbufReadString(reqData);
558 if (ifName == NULL) {
559 HDF_LOGE("%s: read ifName failed!", __func__);
560 return ret;
561 }
562 ret = HdfWlanStopPnoScan(ifName);
563 if (ret != HDF_SUCCESS) {
564 HDF_LOGE("%s: fail to stop pno scan, %d", __func__, ret);
565 }
566 return ret;
567 }
568
HdfWlanGetSignalPollInfo(const char * ifName,struct SignalResult * signalInfo)569 static int32_t HdfWlanGetSignalPollInfo(const char *ifName, struct SignalResult *signalInfo)
570 {
571 struct NetDevice *netdev = NULL;
572 struct HdfChipDriver *chipDriver = NULL;
573
574 netdev = NetDeviceGetInstByName(ifName);
575 if (netdev == NULL) {
576 HDF_LOGE("%s:netdev not found! ifName=%s.", __func__, ifName);
577 return HDF_FAILURE;
578 }
579 chipDriver = GetChipDriver(netdev);
580 if (chipDriver == NULL) {
581 HDF_LOGE("%s:bad net device found!", __func__);
582 return HDF_FAILURE;
583 }
584 if (chipDriver->staOps == NULL) {
585 HDF_LOGE("%s: chipDriver->staOps is null", __func__);
586 return HDF_ERR_INVALID_OBJECT;
587 }
588 if (chipDriver->staOps->GetSignalPollInfo == NULL) {
589 HDF_LOGE("%s: chipDriver->staOps->GetSignalPollInfo is null", __func__);
590 return HDF_ERR_NOT_SUPPORT;
591 }
592 return chipDriver->staOps->GetSignalPollInfo(netdev, signalInfo);
593 }
594
WifiCmdGetSignalPollInfo(const RequestContext * context,struct HdfSBuf * reqData,struct HdfSBuf * rspData)595 static int32_t WifiCmdGetSignalPollInfo(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData)
596 {
597 (void)context;
598 int32_t ret = HDF_FAILURE;
599 const char *ifName = NULL;
600 struct SignalResult signalInfo = {0};
601
602 if (reqData == NULL || rspData == NULL) {
603 return HDF_ERR_INVALID_PARAM;
604 }
605 ifName = HdfSbufReadString(reqData);
606 if (ifName == NULL) {
607 HDF_LOGE("%s: read ifName failed!", __func__);
608 return ret;
609 }
610 ret = HdfWlanGetSignalPollInfo(ifName, &signalInfo);
611 if (ret != HDF_SUCCESS) {
612 HDF_LOGE("%s: fail to get signal information, %d", __func__, ret);
613 return ret;
614 }
615 if (!HdfSbufWriteBuffer(rspData, &signalInfo, sizeof(struct SignalResult))) {
616 HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED);
617 ret = HDF_FAILURE;
618 }
619 return ret;
620 }
621
622 static struct MessageDef g_wifiStaFeatureCmds[] = {
623 DUEMessage(CMD_STA_CONNECT, WifiCmdAssoc, 0),
624 DUEMessage(CMD_STA_DISCONNECT, WifiCmdDisconnect, 0),
625 DUEMessage(CMD_STA_SCAN, WifiCmdScan, 0),
626 DUEMessage(CMD_STA_ABORT_SCAN, WifiCmdAbortScan, 0),
627 DUEMessage(CMD_STA_SET_SCAN_MAC_ADDR, WifiCmdSetScanningMacAddress, 0),
628 DUEMessage(CMD_STA_START_PNO_SCAN, WifiCmdStartPnoScan, 0),
629 DUEMessage(CMD_STA_STOP_PNO_SCAN, WifiCmdStopPnoScan, 0),
630 DUEMessage(CMD_STA_GET_SIGNAL_INFO, WifiCmdGetSignalPollInfo, 0)
631 };
632 ServiceDefine(STAService, STA_SERVICE_ID, g_wifiStaFeatureCmds);
633
634 Service *g_staService = NULL;
635
StaInit(struct WifiFeature * feature)636 static int32_t StaInit(struct WifiFeature *feature)
637 {
638 (void)feature;
639 if (g_staService == NULL) {
640 ServiceCfg cfg = {
641 .dispatcherId = DEFAULT_DISPATCHER_ID
642 };
643 g_staService = CreateService(STAService, &cfg);
644 if (g_staService == NULL) {
645 HDF_LOGE("%s: The g_staService is null, CreateService failed!", __func__);
646 return HDF_FAILURE;
647 }
648 }
649 return HDF_SUCCESS;
650 }
651
StaDeinit(struct WifiFeature * feature)652 static int32_t StaDeinit(struct WifiFeature *feature)
653 {
654 (void)feature;
655 if (g_staService != NULL && g_staService->Destroy != NULL) {
656 g_staService->Destroy(g_staService);
657 g_staService = NULL;
658 }
659 return HDF_SUCCESS;
660 }
661
662 struct WifiFeature g_staFeature = {
663 .name = "sta",
664 .init = StaInit,
665 .deInit = StaDeinit
666 };
667
GetWifiStaFeature(void)668 struct WifiFeature *GetWifiStaFeature(void)
669 {
670 return &g_staFeature;
671 }
672
673 #ifdef __cplusplus
674 }
675 #endif
676