1/*
2 * Copyright (c) 2021-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
16#include <stdlib.h>
17
18#include "hdf_log.h"
19#include "sbuf_common_adapter.h"
20#include "securec.h"
21
22#ifdef __cplusplus
23#if __cplusplus
24extern "C" {
25#endif
26#endif
27
28#define DRIVER_SERVICE_NAME "hdfwifi"
29static struct HdfDevEventlistener g_wifiDevEventListener;
30static bool g_isHasRegisterListener = false;
31#define PNO_SCAN_INFO_MAXSIZE 1500
32
33static int32_t ParserNetworkInfo(struct HdfSBuf *reply, struct NetworkInfoResult *result)
34{
35    uint32_t i;
36    const char *ifName = NULL;
37    uint8_t *mode = NULL;
38    uint32_t replayDataSize;
39
40    if (!HdfSbufReadUint32(reply, &result->nums)) {
41        HDF_LOGE("%s: get networkNum failed", __FUNCTION__);
42        return RET_CODE_FAILURE;
43    }
44    if (result->nums > MAX_IFACE_NUM) {
45        result->nums = MAX_IFACE_NUM;
46    }
47    for (i = 0; i < result->nums; i++) {
48        ifName = HdfSbufReadString(reply);
49        if (ifName == NULL) {
50            HDF_LOGE("%s: get ifName failed", __FUNCTION__);
51            return RET_CODE_FAILURE;
52        }
53        if (!HdfSbufReadBuffer(reply, (const void **)&mode, &replayDataSize) || mode == NULL ||
54            replayDataSize != WIFI_IFTYPE_MAX) {
55            HDF_LOGE("%s: get mode failed", __FUNCTION__);
56            return RET_CODE_FAILURE;
57        }
58        if (strncpy_s(result->infos[i].name, IFNAMSIZ, ifName, strlen(ifName)) != EOK) {
59            HDF_LOGE("%s: memcpy_s name failed", __FUNCTION__);
60            return RET_CODE_FAILURE;
61        }
62        if (memcpy_s(result->infos[i].supportMode, WIFI_IFTYPE_MAX, mode, replayDataSize) != EOK) {
63            HDF_LOGE("%s: memcpy_s supportMode failed", __FUNCTION__);
64            return RET_CODE_FAILURE;
65        }
66    }
67    return RET_CODE_SUCCESS;
68}
69
70static int32_t ParserDeviceMacAddr(struct HdfSBuf *reply, uint8_t *mac, uint8_t len)
71{
72    uint8_t isEfuseSavedMac;
73    uint32_t replayDataSize = 0;
74    const uint8_t *replayData = 0;
75
76    if (!HdfSbufReadUint8(reply, &isEfuseSavedMac)) {
77        HDF_LOGE("%s: HdfSbufReadUint8 failed", __FUNCTION__);
78        return RET_CODE_FAILURE;
79    }
80    if (!isEfuseSavedMac) {
81        HDF_LOGE("%s: not support to get device mac addr", __FUNCTION__);
82        return RET_CODE_NOT_SUPPORT;
83    }
84    if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &replayDataSize) || replayDataSize != len) {
85        HDF_LOGE("%s: HdfSbufReadBuffer failed", __FUNCTION__);
86        return RET_CODE_FAILURE;
87    }
88    if (memcpy_s(mac, len, replayData, replayDataSize) != EOK) {
89        HDF_LOGE("%s: memcpy failed", __FUNCTION__);
90        return RET_CODE_FAILURE;
91    }
92    return RET_CODE_SUCCESS;
93}
94
95static int32_t ParserFreqInfo(struct HdfSBuf *reply, struct FreqInfoResult *result, uint32_t size)
96{
97    uint32_t replayDataSize = 0;
98    const uint8_t *replayData = 0;
99
100    if (result == NULL || result->freqs == NULL || result->txPower == NULL) {
101        HDF_LOGE("%s:  Invalid input parameter", __FUNCTION__);
102        return RET_CODE_INVALID_PARAM;
103    }
104
105    if (!HdfSbufReadUint32(reply, &result->nums)) {
106        HDF_LOGE("%s: read num failed", __FUNCTION__);
107        return RET_CODE_FAILURE;
108    }
109    if (result->nums > size) {
110        HDF_LOGE("%s: num valid", __FUNCTION__);
111        return RET_CODE_FAILURE;
112    }
113    if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &replayDataSize)) {
114        HDF_LOGE("%s: read freqs failed", __FUNCTION__);
115        return RET_CODE_FAILURE;
116    }
117    if (memcpy_s(result->freqs, size * sizeof(uint32_t), replayData, replayDataSize) != EOK) {
118        HDF_LOGE("%s: memcpy failed", __FUNCTION__);
119        return RET_CODE_FAILURE;
120    }
121    return RET_CODE_SUCCESS;
122}
123
124static int32_t ParserAssociatedStas(struct HdfSBuf *reply, struct AssocStaInfoResult *result)
125{
126    uint32_t replayDataSize = 0;
127    const uint8_t *replayData = 0;
128
129    if (!HdfSbufReadUint32(reply, &result->num)) {
130        HDF_LOGE("%s: read num failed", __FUNCTION__);
131        return RET_CODE_FAILURE;
132    }
133    if (result->num > MAX_ASSOC_STA_NUM) {
134        HDF_LOGE("%s: num invalid", __FUNCTION__);
135        return RET_CODE_FAILURE;
136    }
137    if (result->num != 0) {
138        if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &replayDataSize) ||
139            replayDataSize > sizeof(result->infos)) {
140            HDF_LOGE("%s: read AssocStaInfo failed", __FUNCTION__);
141            return RET_CODE_FAILURE;
142        }
143        if (memcpy_s(result->infos, sizeof(result->infos), replayData, replayDataSize) != EOK) {
144            HDF_LOGE("%s: memcpy failed", __FUNCTION__);
145            return RET_CODE_FAILURE;
146        }
147    }
148    return RET_CODE_SUCCESS;
149}
150
151static int32_t HdfSbufObtainDefault(struct HdfSBuf **data, struct HdfSBuf **reply)
152{
153    *data = HdfSbufObtainDefaultSize();
154    if (*data == NULL) {
155        return RET_CODE_FAILURE;
156    }
157    *reply = HdfSbufObtainDefaultSize();
158    if (*reply == NULL) {
159        HdfSbufRecycle(*data);
160        return RET_CODE_FAILURE;
161    }
162    return RET_CODE_SUCCESS;
163}
164
165static int32_t WifiMsgRegisterEventListener(struct HdfDevEventlistener *listener)
166{
167    struct HdfIoService *wifiService = GetWifiService();
168    if (wifiService == NULL || listener == NULL) {
169        HDF_LOGE("%s: At least one param is null", __FUNCTION__);
170        return RET_CODE_FAILURE;
171    }
172    if (HdfDeviceRegisterEventListener(wifiService, listener) != RET_CODE_SUCCESS) {
173        HDF_LOGE("%s: fail to register event listener, line: %d", __FUNCTION__, __LINE__);
174        return RET_CODE_FAILURE;
175    }
176    g_isHasRegisterListener = true;
177    return RET_CODE_SUCCESS;
178}
179
180static void WifiMsgUnregisterEventListener(struct HdfDevEventlistener *listener)
181{
182    struct HdfIoService *wifiService = GetWifiService();
183    if (listener == NULL) {
184        return;
185    }
186    if (HdfDeviceUnregisterEventListener(wifiService, listener) != HDF_SUCCESS) {
187        HDF_LOGE("%s: fail to unregister event listener, line: %d", __FUNCTION__, __LINE__);
188    }
189    g_isHasRegisterListener = false;
190}
191
192int32_t WifiDriverClientInit(void)
193{
194    int32_t ret;
195    struct HdfIoService *wifiService = InitWifiService(DRIVER_SERVICE_NAME);
196    if (wifiService == NULL) {
197        HDF_LOGE("%s: fail to get remote service!", __FUNCTION__);
198        return RET_CODE_FAILURE;
199    }
200    g_wifiDevEventListener.onReceive = OnWiFiEvents;
201    if (g_isHasRegisterListener) {
202        HDF_LOGI("%s:has register listener!", __FUNCTION__);
203        return RET_CODE_SUCCESS;
204    }
205    ret = WifiMsgRegisterEventListener(&g_wifiDevEventListener);
206    if (ret != RET_CODE_SUCCESS) {
207        HDF_LOGE("%s: register event listener failed, line: %d", __FUNCTION__, __LINE__);
208    }
209    return ret;
210}
211
212void WifiDriverClientDeinit(void)
213{
214    struct HdfIoService *wifiService = GetWifiService();
215    if (wifiService == NULL) {
216        return;
217    }
218    WifiMsgUnregisterEventListener(&g_wifiDevEventListener);
219    if (HdfIoserviceGetListenerCount(wifiService) != 0) {
220        HDF_LOGE("%s: the current EventListener is not empty. cancel the listener registration first.",
221            __FUNCTION__);
222        return;
223    }
224    ReleaseWifiService();
225}
226
227int32_t GetUsableNetworkInfo(struct NetworkInfoResult *result)
228{
229    int32_t ret;
230    struct HdfSBuf *data = NULL;
231    struct HdfSBuf *reply = NULL;
232
233    if (result == NULL) {
234        HDF_LOGE("%s params is NULL", __FUNCTION__);
235        return RET_CODE_INVALID_PARAM;
236    }
237    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
238        return RET_CODE_FAILURE;
239    }
240    ret = SendCmdSync(WIFI_HAL_CMD_GET_NETWORK_INFO, data, reply);
241    if (ret == RET_CODE_SUCCESS) {
242        ret = ParserNetworkInfo(reply, result);
243    } else {
244        ret = RET_CODE_FAILURE;
245    }
246    HdfSbufRecycle(data);
247    HdfSbufRecycle(reply);
248    return ret;
249}
250
251int32_t IsSupportCombo(uint8_t *isSupportCombo)
252{
253    int32_t ret;
254    struct HdfSBuf *data = NULL;
255    struct HdfSBuf *reply = NULL;
256
257    if (isSupportCombo == NULL) {
258        HDF_LOGE("%s params is NULL", __FUNCTION__);
259        return RET_CODE_INVALID_PARAM;
260    }
261    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
262        return RET_CODE_FAILURE;
263    }
264    ret = SendCmdSync(WIFI_HAL_CMD_IS_SUPPORT_COMBO, data, reply);
265    do {
266        if (ret != RET_CODE_SUCCESS) {
267            break;
268        }
269        if (!HdfSbufReadUint8(reply, isSupportCombo)) {
270            HDF_LOGE("%s: HdfSbufReadUint8 failed", __FUNCTION__);
271            ret = RET_CODE_FAILURE;
272        } else {
273            ret = RET_CODE_SUCCESS;
274        }
275    } while (0);
276    HdfSbufRecycle(data);
277    HdfSbufRecycle(reply);
278    return ret;
279}
280
281int32_t GetComboInfo(uint64_t *comboInfo, uint32_t size)
282{
283    int32_t ret;
284    uint8_t isComboValid;
285    uint32_t replayDataSize = 0;
286    const uint8_t *replayData = 0;
287    struct HdfSBuf *data = NULL;
288    struct HdfSBuf *reply = NULL;
289
290    if (comboInfo == NULL) {
291        HDF_LOGE("%s params is NULL", __FUNCTION__);
292        return RET_CODE_INVALID_PARAM;
293    }
294    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
295        return RET_CODE_FAILURE;
296    }
297    ret = SendCmdSync(WIFI_HAL_CMD_GET_SUPPORT_COMBO, data, reply);
298    do {
299        if (ret != RET_CODE_SUCCESS) {
300            ret = RET_CODE_FAILURE;
301            break;
302        }
303        if (!HdfSbufReadUint8(reply, &isComboValid)) {
304            HDF_LOGE("%s: read combo valid flag failed", __FUNCTION__);
305            ret = RET_CODE_FAILURE;
306            break;
307        }
308        if (!isComboValid) {
309            HDF_LOGE("%s: not support combo mode", __FUNCTION__);
310            ret = RET_CODE_NOT_SUPPORT;
311            break;
312        }
313        if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &replayDataSize)) {
314            HDF_LOGE("%s: HdfSbufReadBuffer failed", __FUNCTION__);
315            ret = RET_CODE_FAILURE;
316            break;
317        }
318        if (memcpy_s(comboInfo, size, replayData, replayDataSize) != EOK) {
319            HDF_LOGE("%s: memcpy failed", __FUNCTION__);
320            ret = RET_CODE_FAILURE;
321            break;
322        }
323    } while (0);
324    HdfSbufRecycle(data);
325    HdfSbufRecycle(reply);
326    return ret;
327}
328
329int32_t SetMacAddr(const char *ifName, unsigned char *mac, uint8_t len)
330{
331    int32_t ret;
332    struct HdfSBuf *data = NULL;
333    struct HdfSBuf *reply = NULL;
334
335    if (ifName == NULL || mac == NULL) {
336        HDF_LOGE("%s params is NULL", __FUNCTION__);
337        return RET_CODE_INVALID_PARAM;
338    }
339    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
340        return RET_CODE_FAILURE;
341    }
342    do {
343        if (!HdfSbufWriteString(data, ifName)) {
344            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
345            ret = RET_CODE_FAILURE;
346            break;
347        }
348        if (!HdfSbufWriteBuffer(data, mac, len)) {
349            HDF_LOGE("%s: write mac failed", __FUNCTION__);
350            ret = RET_CODE_FAILURE;
351            break;
352        }
353        ret = SendCmdSync(WIFI_HAL_CMD_SET_MAC_ADDR, data, reply);
354    } while (0);
355    HdfSbufRecycle(data);
356    HdfSbufRecycle(reply);
357    return ret;
358}
359
360int32_t GetDevMacAddr(const char *ifName, int32_t type, uint8_t *mac, uint8_t len)
361{
362    int32_t ret;
363    struct HdfSBuf *data = NULL;
364    struct HdfSBuf *reply = NULL;
365
366    if (ifName == NULL || mac == NULL) {
367        HDF_LOGE("%s params is NULL", __FUNCTION__);
368        return RET_CODE_INVALID_PARAM;
369    }
370    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
371        return RET_CODE_FAILURE;
372    }
373    do {
374        if (!HdfSbufWriteString(data, ifName)) {
375            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
376            ret = RET_CODE_FAILURE;
377            break;
378        }
379        if (!HdfSbufWriteInt32(data, type)) {
380            HDF_LOGE("%s: write type failed", __FUNCTION__);
381            ret = RET_CODE_FAILURE;
382            break;
383        }
384        ret = SendCmdSync(WIFI_HAL_CMD_GET_DEV_MAC_ADDR, data, reply);
385        if (ret != RET_CODE_SUCCESS) {
386            ret = RET_CODE_FAILURE;
387            break;
388        }
389        ret = ParserDeviceMacAddr(reply, mac, len);
390    } while (0);
391    HdfSbufRecycle(data);
392    HdfSbufRecycle(reply);
393    return ret;
394}
395
396int32_t GetValidFreqByBand(const char *ifName, int32_t band, struct FreqInfoResult *result, uint32_t size)
397{
398    int32_t ret;
399    struct HdfSBuf *data = NULL;
400    struct HdfSBuf *reply = NULL;
401
402    if (ifName == NULL || result == NULL || band >= IEEE80211_NUM_BANDS) {
403        HDF_LOGE("%s params is NULL", __FUNCTION__);
404        return RET_CODE_INVALID_PARAM;
405    }
406    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
407        return RET_CODE_FAILURE;
408    }
409    do {
410        if (!HdfSbufWriteString(data, ifName)) {
411            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
412            ret = RET_CODE_FAILURE;
413            break;
414        }
415        if (!HdfSbufWriteInt32(data, band)) {
416            HDF_LOGE("%s: write band failed", __FUNCTION__);
417            ret = RET_CODE_FAILURE;
418            break;
419        }
420        ret = SendCmdSync(WIFI_HAL_CMD_GET_VALID_FREQ, data, reply);
421        if (ret != RET_CODE_SUCCESS) {
422            ret = RET_CODE_FAILURE;
423            break;
424        }
425        ret = ParserFreqInfo(reply, result, size);
426    } while (0);
427    HdfSbufRecycle(data);
428    HdfSbufRecycle(reply);
429    return ret;
430}
431
432int32_t SetTxPower(const char *ifName, int32_t power)
433{
434    int32_t ret;
435    struct HdfSBuf *data = NULL;
436    struct HdfSBuf *reply = NULL;
437
438    if (ifName == NULL) {
439        HDF_LOGE("%s params is NULL", __FUNCTION__);
440        return RET_CODE_INVALID_PARAM;
441    }
442    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
443        return RET_CODE_FAILURE;
444    }
445    do {
446        if (!HdfSbufWriteString(data, ifName)) {
447            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
448            ret = RET_CODE_FAILURE;
449            break;
450        }
451        if (!HdfSbufWriteInt32(data, power)) {
452            HDF_LOGE("%s: HdfSbufWriteInt32 failed", __FUNCTION__);
453            ret = RET_CODE_FAILURE;
454            break;
455        }
456        ret = SendCmdSync(WIFI_HAL_CMD_SET_TX_POWER, data, reply);
457    } while (0);
458    HdfSbufRecycle(data);
459    HdfSbufRecycle(reply);
460    return ret;
461}
462
463int32_t GetAssociatedStas(const char *ifName, struct AssocStaInfoResult *result)
464{
465    int32_t ret;
466    struct HdfSBuf *data = NULL;
467    struct HdfSBuf *reply = NULL;
468
469    if (ifName == NULL || result == NULL) {
470        HDF_LOGE("%s params is NULL", __FUNCTION__);
471        return RET_CODE_INVALID_PARAM;
472    }
473    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
474        return RET_CODE_FAILURE;
475    }
476    do {
477        if (!HdfSbufWriteString(data, ifName)) {
478            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
479            ret = RET_CODE_FAILURE;
480            break;
481        }
482        ret = SendCmdSync(WIFI_HAL_CMD_GET_ASSOC_STA, data, reply);
483        if (ret != RET_CODE_SUCCESS) {
484            ret = RET_CODE_FAILURE;
485            break;
486        }
487        ret = ParserAssociatedStas(reply, result);
488    } while (0);
489    HdfSbufRecycle(data);
490    HdfSbufRecycle(reply);
491    return ret;
492}
493
494int32_t WifiSetCountryCode(const char *ifName, const char *code, uint32_t len)
495{
496    int32_t ret;
497    struct HdfSBuf *data = NULL;
498    struct HdfSBuf *reply = NULL;
499
500    if (ifName == NULL || code == NULL) {
501        HDF_LOGE("%s params is NULL", __FUNCTION__);
502        return RET_CODE_INVALID_PARAM;
503    }
504    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
505        return RET_CODE_FAILURE;
506    }
507    do {
508        if (!HdfSbufWriteString(data, ifName)) {
509            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
510            ret = RET_CODE_FAILURE;
511            break;
512        }
513        if (!HdfSbufWriteBuffer(data, code, len)) {
514            HDF_LOGE("%s: write code failed", __FUNCTION__);
515            ret = RET_CODE_FAILURE;
516            break;
517        }
518        ret = SendCmdSync(WIFI_HAL_CMD_SET_COUNTRY_CODE, data, reply);
519    } while (0);
520    HdfSbufRecycle(data);
521    HdfSbufRecycle(reply);
522    return ret;
523}
524
525int32_t SetScanMacAddr(const char *ifName, uint8_t *scanMac, uint8_t len)
526{
527    int32_t ret;
528    uint8_t isFuncValid;
529    struct HdfSBuf *data = NULL;
530    struct HdfSBuf *reply = NULL;
531
532    if (ifName == NULL || scanMac == NULL) {
533        HDF_LOGE("%s params is NULL", __FUNCTION__);
534        return RET_CODE_INVALID_PARAM;
535    }
536    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
537        return RET_CODE_FAILURE;
538    }
539    do {
540        if (!HdfSbufWriteString(data, ifName)) {
541            HDF_LOGE("%s: write ifName failed", __FUNCTION__);
542            ret = RET_CODE_FAILURE;
543            break;
544        }
545        if (!HdfSbufWriteBuffer(data, scanMac, len)) {
546            HDF_LOGE("%s: write scan mac failed", __FUNCTION__);
547            ret = RET_CODE_FAILURE;
548            break;
549        }
550        ret = SendCmdSync(WIFI_HAL_CMD_SET_SCAN_MAC_ADDR, data, reply);
551        if (ret != RET_CODE_SUCCESS) {
552            break;
553        }
554        if (!HdfSbufReadUint8(reply, &isFuncValid)) {
555            HDF_LOGE("%s: read valid flag failed", __FUNCTION__);
556            ret = RET_CODE_FAILURE;
557            break;
558        }
559        if (!isFuncValid) {
560            HDF_LOGE("%s: not support to set scan mac addr", __FUNCTION__);
561            ret = RET_CODE_NOT_SUPPORT;
562            break;
563        }
564    } while (0);
565    HdfSbufRecycle(data);
566    HdfSbufRecycle(reply);
567    return ret;
568}
569
570int32_t AcquireChipId(const char *ifName, uint8_t *chipId)
571{
572    int32_t ret;
573    struct HdfSBuf *data = NULL;
574    struct HdfSBuf *reply = NULL;
575
576    if (ifName == NULL || chipId == NULL) {
577        HDF_LOGE("%s params is NULL", __FUNCTION__);
578        return RET_CODE_INVALID_PARAM;
579    }
580    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
581        return RET_CODE_FAILURE;
582    }
583    do {
584        if (!HdfSbufWriteString(data, ifName)) {
585            HDF_LOGE("%s: HdfSbufWriteString failed", __FUNCTION__);
586            ret = RET_CODE_FAILURE;
587            break;
588        }
589        ret = SendCmdSync(WIFI_HAL_CMD_GET_CHIPID, data, reply);
590        if (ret != RET_CODE_SUCCESS) {
591            break;
592        }
593        if (!HdfSbufReadUint8(reply, chipId)) {
594            HDF_LOGE("%s:  HdfSbufReadUint8 failed", __FUNCTION__);
595            ret = RET_CODE_FAILURE;
596            break;
597        }
598    } while (0);
599    HdfSbufRecycle(data);
600    HdfSbufRecycle(reply);
601    return ret;
602}
603
604static int32_t GetIfNames(struct HdfSBuf *reply, char **ifNames, uint32_t *num)
605{
606    uint32_t i;
607    uint32_t replayDataSize = 0;
608    const char *replayData = NULL;
609
610    if (!HdfSbufReadUint32(reply, num)) {
611        HDF_LOGE("%s: HdfSbufReadUint32 failed", __FUNCTION__);
612        return RET_CODE_FAILURE;
613    }
614    *ifNames = (char *)calloc(*num, IFNAMSIZ);
615    if (*ifNames == NULL) {
616        HDF_LOGE("%s: calloc failed", __FUNCTION__);
617        return RET_CODE_FAILURE;
618    }
619
620    if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &replayDataSize) ||
621        replayDataSize < (*num * IFNAMSIZ)) {
622        HDF_LOGE("%s: HdfSbufReadBuffer failed", __FUNCTION__);
623        free(*ifNames);
624        *ifNames = NULL;
625        return RET_CODE_FAILURE;
626    }
627
628    for (i = 0; i < *num; i++) {
629        if (memcpy_s(*ifNames + i * IFNAMSIZ, IFNAMSIZ, replayData + i * IFNAMSIZ, replayDataSize) != EOK) {
630            HDF_LOGE("%s: memcpy failed", __FUNCTION__);
631            free(*ifNames);
632            *ifNames = NULL;
633            return RET_CODE_FAILURE;
634        }
635    }
636    return RET_CODE_SUCCESS;
637}
638
639int32_t GetIfNamesByChipId(const uint8_t chipId, char **ifNames, uint32_t *num)
640{
641    int32_t ret;
642    struct HdfSBuf *data = NULL;
643    struct HdfSBuf *reply = NULL;
644
645    if (ifNames == NULL || num == NULL) {
646        HDF_LOGE("%s params is NULL", __FUNCTION__);
647        return RET_CODE_INVALID_PARAM;
648    }
649    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
650        return RET_CODE_FAILURE;
651    }
652    do {
653        if (!HdfSbufWriteUint8(data, chipId)) {
654            HDF_LOGE("%s: HdfSbufWriteUint8 failed", __FUNCTION__);
655            ret = RET_CODE_FAILURE;
656            break;
657        }
658        ret = SendCmdSync(WIFI_HAL_CMD_GET_IFNAMES, data, reply);
659        if (ret != RET_CODE_SUCCESS) {
660            break;
661        }
662        ret = GetIfNames(reply, ifNames, num);
663    } while (0);
664    HdfSbufRecycle(data);
665    HdfSbufRecycle(reply);
666    return ret;
667}
668
669int32_t SetResetDriver(const uint8_t chipId, const char *ifName)
670{
671    int32_t ret;
672    struct HdfSBuf *data = NULL;
673    struct HdfSBuf *reply = NULL;
674
675    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
676        return RET_CODE_FAILURE;
677    }
678    do {
679        if (!HdfSbufWriteUint8(data, chipId)) {
680            HDF_LOGE("%s: HdfSbufWriteUint8 failed", __FUNCTION__);
681            ret = RET_CODE_FAILURE;
682            break;
683        }
684        if (!HdfSbufWriteString(data, ifName)) {
685            HDF_LOGE("%s: Serialize failed!", __FUNCTION__);
686            ret = RET_CODE_FAILURE;
687            break;
688        }
689        ret = SendCmdSync(WIFI_HAL_CMD_RESET_DRIVER, data, reply);
690    } while (0);
691    HdfSbufRecycle(data);
692    HdfSbufRecycle(reply);
693    return ret;
694}
695
696int32_t GetNetDeviceInfo(struct NetDeviceInfoResult *netDeviceInfoResult)
697{
698    int32_t ret;
699    struct HdfSBuf *data = NULL;
700    struct HdfSBuf *reply = NULL;
701    uint32_t netdevNum = 0;
702    uint32_t ifNameSize;
703    uint32_t macSize;
704    uint32_t i;
705    const uint8_t *replayData = NULL;
706    const char *ifName = NULL;
707
708    if (netDeviceInfoResult == NULL) {
709        HDF_LOGE("%s: params is NULL", __FUNCTION__);
710        return RET_CODE_INVALID_PARAM;
711    }
712    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
713        return RET_CODE_FAILURE;
714    }
715    do {
716        ret = SendCmdSync(WIFI_HAL_CMD_GET_NETDEV_INFO, data, reply);
717        if (ret != RET_CODE_SUCCESS) {
718            break;
719        }
720        if (!HdfSbufReadUint32(reply, &netdevNum)) {
721            HDF_LOGE("%s: HdfSbufReadUint32 failed", __FUNCTION__);
722            ret = RET_CODE_FAILURE;
723            break;
724        }
725        for (i = 0; i < netdevNum; i++) {
726            if (!HdfSbufReadUint32(reply, &(netDeviceInfoResult->deviceInfos[i].index)) ||
727                !HdfSbufReadBuffer(reply, (const void **)(&ifName), &ifNameSize) ||
728                !HdfSbufReadUint8(reply, &(netDeviceInfoResult->deviceInfos[i].iftype)) ||
729                !HdfSbufReadBuffer(reply, (const void **)(&replayData), &macSize)) {
730                HDF_LOGE("%s: read fail!", __FUNCTION__);
731                ret = RET_CODE_FAILURE;
732                break;
733            }
734            if (memcpy_s(netDeviceInfoResult->deviceInfos[i].ifName, ifNameSize, ifName, ifNameSize) != EOK) {
735                HDF_LOGE("%s: memcpy failed", __FUNCTION__);
736                ret = RET_CODE_FAILURE;
737                break;
738            }
739            if (memcpy_s(netDeviceInfoResult->deviceInfos[i].mac, macSize, replayData, macSize) != EOK) {
740                HDF_LOGE("%s: memcpy failed", __FUNCTION__);
741                ret = RET_CODE_FAILURE;
742                break;
743            }
744        }
745    } while (0);
746    HdfSbufRecycle(data);
747    HdfSbufRecycle(reply);
748    return ret;
749}
750
751int32_t GetCurrentPowerMode(const char *ifName, uint8_t *mode)
752{
753    int32_t ret;
754    struct HdfSBuf *data = NULL;
755    struct HdfSBuf *reply = NULL;
756
757    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
758        HDF_LOGE("%s: HdfSbufObtainDefault fail", __FUNCTION__);
759        return RET_CODE_FAILURE;
760    }
761
762    do {
763        if (!HdfSbufWriteString(data, ifName)) {
764            HDF_LOGE("%s: write ifName fail!", __FUNCTION__);
765            ret = RET_CODE_FAILURE;
766            break;
767        }
768        ret = SendCmdSync(WIFI_HAL_CMD_GET_POWER_MODE, data, reply);
769        if (ret != RET_CODE_SUCCESS) {
770            HDF_LOGE("%s: SendCmdSync fail!", __FUNCTION__);
771            break;
772        }
773        if (!HdfSbufReadUint8(reply, mode)) {
774            HDF_LOGE("%s: HdfSbufReadUint8 failed", __FUNCTION__);
775            ret = RET_CODE_FAILURE;
776            break;
777        }
778    } while (0);
779
780    HdfSbufRecycle(data);
781    HdfSbufRecycle(reply);
782    return ret;
783}
784
785int32_t SetPowerMode(const char *ifName, uint8_t mode)
786{
787    int32_t ret = RET_CODE_FAILURE;
788    struct HdfSBuf *data = NULL;
789
790    data = HdfSbufObtainDefaultSize();
791    if (data == NULL) {
792        HDF_LOGE("%s: HdfSbufObtainDefaultSize fail!", __FUNCTION__);
793        return ret;
794    }
795
796    do {
797        if (!HdfSbufWriteString(data, ifName)) {
798            HDF_LOGE("%s: write ifName fail!", __FUNCTION__);
799            break;
800        }
801        if (!HdfSbufWriteUint8(data, mode)) {
802            HDF_LOGE("%s: write ifName fail!", __FUNCTION__);
803            break;
804        }
805        ret = SendCmdSync(WIFI_HAL_CMD_SET_POWER_MODE, data, NULL);
806    } while (0);
807
808    HdfSbufRecycle(data);
809    return ret;
810}
811
812int32_t WifiCmdScan(const char *ifName, WifiScan *scan)
813{
814    int32_t ret;
815    struct HdfSBuf *data = NULL;
816
817    if (ifName == NULL || scan == NULL) {
818        HDF_LOGE("%s: Input param is null", __FUNCTION__);
819        return RET_CODE_INVALID_PARAM;
820    }
821    data = HdfSbufObtainDefaultSize();
822    if (data == NULL) {
823        HDF_LOGE("%s: HdfSbufObtainDefaultSize fail", __FUNCTION__);
824        return RET_CODE_FAILURE;
825    }
826    bool isSerializeFailed = false;
827    isSerializeFailed = isSerializeFailed || !HdfSbufWriteString(data, ifName);
828    if (scan->bssid == NULL) {
829        isSerializeFailed = isSerializeFailed || !HdfSbufWriteBuffer(data, scan->bssid, 0);
830    } else {
831        isSerializeFailed = isSerializeFailed || !HdfSbufWriteBuffer(data, scan->bssid, ETH_ADDR_LEN);
832    }
833    isSerializeFailed =
834        isSerializeFailed || !HdfSbufWriteBuffer(data, scan->ssids, sizeof(scan->ssids[0]) * scan->numSsids);
835    isSerializeFailed = isSerializeFailed || !HdfSbufWriteBuffer(data, scan->extraIes, scan->extraIesLen);
836    isSerializeFailed =
837        isSerializeFailed || !HdfSbufWriteBuffer(data, scan->freqs, sizeof(scan->freqs[0]) * scan->numFreqs);
838    isSerializeFailed = isSerializeFailed || !HdfSbufWriteUint8(data, scan->prefixSsidScanFlag);
839    isSerializeFailed = isSerializeFailed || !HdfSbufWriteUint8(data, scan->fastConnectFlag);
840    if (isSerializeFailed) {
841        HDF_LOGE("%s: Serialize failed!", __FUNCTION__);
842        ret = RET_CODE_FAILURE;
843    } else {
844        ret = SendCmdSync(WIFI_WPA_CMD_SCAN, data, NULL);
845    }
846    HdfSbufRecycle(data);
847    return ret;
848}
849
850int32_t StartChannelMeas(const char *ifName, const struct MeasParam *measParam)
851{
852    int32_t ret = RET_CODE_FAILURE;
853    struct HdfSBuf *data = NULL;
854
855    data = HdfSbufObtainDefaultSize();
856    if (data == NULL) {
857        HDF_LOGE("%s: HdfSbufObtainDefaultSize fail!", __FUNCTION__);
858        return ret;
859    }
860
861    do {
862        if (!HdfSbufWriteString(data, ifName)) {
863            HDF_LOGE("%s: write ifName fail!", __FUNCTION__);
864            break;
865        }
866        if (!HdfSbufWriteBuffer(data, measParam, sizeof(struct MeasParam))) {
867            HDF_LOGE("%s: write paramBuf fail!", __FUNCTION__);
868            break;
869        }
870        ret = SendCmdSync(WIFI_HAL_CMD_START_CHANNEL_MEAS, data, NULL);
871    } while (0);
872
873    HdfSbufRecycle(data);
874    return ret;
875}
876
877int32_t SetProjectionScreenParam(const char *ifName, const ProjectionScreenParam *param)
878{
879    int32_t ret = RET_CODE_FAILURE;
880    struct HdfSBuf *req = NULL;
881
882    req = HdfSbufObtainDefaultSize();
883    if (req == NULL) {
884        HDF_LOGE("%{public}s: HdfSbufObtainDefaultSize fail!", __FUNCTION__);
885        return ret;
886    }
887
888    do {
889        if (!HdfSbufWriteString(req, ifName)) {
890            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
891            break;
892        }
893        if (!HdfSbufWriteInt32(req, param->cmdId)) {
894            HDF_LOGE("%{public}s: write cmd fail!", __FUNCTION__);
895            break;
896        }
897        if (!HdfSbufWriteBuffer(req, param->buf, param->bufLen)) {
898            HDF_LOGE("%{public}s: write buffer data fail!", __FUNCTION__);
899            break;
900        }
901        ret = SendCmdSync(WIFI_HAL_CMD_CONFIG_PROJECTION_SCREEN, req, NULL);
902        if (ret != RET_CODE_SUCCESS) {
903            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
904        }
905    } while (0);
906
907    HdfSbufRecycle(req);
908    return ret;
909}
910
911int32_t SendCmdIoctl(const char *ifName, int32_t cmdId, const int8_t *paramBuf, uint32_t paramBufLen)
912{
913    int ret = RET_CODE_FAILURE;
914    struct HdfSBuf *req = NULL;
915
916    req = HdfSbufObtainDefaultSize();
917    if (req == NULL) {
918        HDF_LOGE("%{public}s: HdfSbufObtainDefaultSize fail!", __FUNCTION__);
919        return ret;
920    }
921
922    do {
923        if (!HdfSbufWriteString(req, ifName)) {
924            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
925            break;
926        }
927        if (!HdfSbufWriteInt32(req, cmdId)) {
928            HDF_LOGE("%{public}s: write cmd fail!", __FUNCTION__);
929            break;
930        }
931        if (!HdfSbufWriteBuffer(req, paramBuf, paramBufLen)) {
932            HDF_LOGE("%{public}s: write buffer data fail!", __FUNCTION__);
933            break;
934        }
935        ret = SendCmdSync(WIFI_HAL_CMD_SET_CMD_IOCTL, req, NULL);
936        if (ret != RET_CODE_SUCCESS) {
937            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
938        }
939    } while (0);
940
941    HdfSbufRecycle(req);
942    return ret;
943}
944
945int32_t GetStationInfo(const char *ifName, StationInfo *info, const uint8_t *mac, uint32_t macLen)
946{
947    int32_t ret = RET_CODE_FAILURE;
948
949    struct HdfSBuf *data = NULL;
950    struct HdfSBuf *reply = NULL;
951    const uint8_t *replayData = NULL;
952    uint32_t size;
953
954    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
955        return RET_CODE_FAILURE;
956    }
957
958    do {
959        if (!HdfSbufWriteString(data, ifName)) {
960            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
961            break;
962        }
963        if (!HdfSbufWriteBuffer(data, mac, macLen)) {
964            HDF_LOGE("%{public}s: write mac address fail!", __FUNCTION__);
965            break;
966        }
967        ret = SendCmdSync(WIFI_HAL_CMD_GET_STATION_INFO, data, reply);
968        if (ret != RET_CODE_SUCCESS) {
969            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
970            break;
971        }
972        if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &size)) {
973            HDF_LOGE("%{public}s: read station information fail!", __FUNCTION__);
974            ret = RET_CODE_FAILURE;
975            break;
976        }
977        if (memcpy_s(info, sizeof(StationInfo), replayData, size) != EOK) {
978            HDF_LOGE("%{public}s: memcpy_s fail", __FUNCTION__);
979            ret = RET_CODE_FAILURE;
980        }
981    } while (0);
982    HdfSbufRecycle(data);
983    HdfSbufRecycle(reply);
984    return ret;
985}
986
987static int32_t SerializeSettingsToSbuf(struct HdfSBuf *req, const WifiPnoSettings *pnoSettings)
988{
989    if (!HdfSbufWriteInt32(req, pnoSettings->min2gRssi)) {
990        HDF_LOGE("%{public}s: write min2gRssi fail!", __FUNCTION__);
991        return RET_CODE_FAILURE;
992    }
993    if (!HdfSbufWriteInt32(req, pnoSettings->min5gRssi)) {
994        HDF_LOGE("%{public}s: write min5gRssi fail!", __FUNCTION__);
995        return RET_CODE_FAILURE;
996    }
997    if (!HdfSbufWriteInt32(req, pnoSettings->scanIntervalMs)) {
998        HDF_LOGE("%{public}s: write scanIntervalMs fail!", __FUNCTION__);
999        return RET_CODE_FAILURE;
1000    }
1001    if (!HdfSbufWriteInt32(req, pnoSettings->scanIterations)) {
1002        HDF_LOGE("%{public}s: write scanIterations fail!", __FUNCTION__);
1003        return RET_CODE_FAILURE;
1004    }
1005    if (!HdfSbufWriteUint32(req, pnoSettings->pnoNetworksLen)) {
1006        HDF_LOGE("%{public}s: write pnoNetworksLen fail!", __FUNCTION__);
1007        return RET_CODE_FAILURE;
1008    }
1009    for (uint32_t i = 0; i < pnoSettings->pnoNetworksLen; i++) {
1010        if (!HdfSbufWriteUint8(req, pnoSettings->pnoNetworks[i].isHidden)) {
1011            HDF_LOGE("%{public}s: write isHidden fail!", __FUNCTION__);
1012            return RET_CODE_FAILURE;
1013        }
1014        if (!HdfSbufWriteBuffer(req, pnoSettings->pnoNetworks[i].freqs,
1015            sizeof(int32_t) * (pnoSettings->pnoNetworks[i].freqsLen))) {
1016            HDF_LOGE("%{public}s: write freqs fail!", __FUNCTION__);
1017            return RET_CODE_FAILURE;
1018        }
1019        if (!HdfSbufWriteBuffer(req, pnoSettings->pnoNetworks[i].ssid.ssid,
1020            pnoSettings->pnoNetworks[i].ssid.ssidLen)) {
1021            HDF_LOGE("%{public}s: write ssid fail!", __FUNCTION__);
1022            return RET_CODE_FAILURE;
1023        }
1024    }
1025    return RET_CODE_SUCCESS;
1026}
1027
1028int32_t WifiStartPnoScan(const char *ifName, const WifiPnoSettings *pnoSettings)
1029{
1030    int32_t ret = RET_CODE_FAILURE;
1031    struct HdfSBuf *req = NULL;
1032
1033    if (ifName == NULL || pnoSettings == NULL) {
1034        HDF_LOGE("%s: Input param is null", __FUNCTION__);
1035        return RET_CODE_INVALID_PARAM;
1036    }
1037    req = HdfSbufObtain(PNO_SCAN_INFO_MAXSIZE);
1038    if (req == NULL) {
1039        HDF_LOGE("%s: HdfSbufObtainDefaultSize fail", __FUNCTION__);
1040        return RET_CODE_FAILURE;
1041    }
1042    do {
1043        if (!HdfSbufWriteString(req, ifName)) {
1044            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
1045            break;
1046        }
1047        if (SerializeSettingsToSbuf(req, pnoSettings) != RET_CODE_SUCCESS) {
1048            HDF_LOGE("%{public}s:SerilizeSettingsToSbuf fail!", __FUNCTION__);
1049            break;
1050        }
1051        ret = SendCmdSync(WIFI_HAL_CMD_START_PNO_SCAN, req, NULL);
1052        if (ret != RET_CODE_SUCCESS) {
1053            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
1054        }
1055    } while (0);
1056    HdfSbufRecycle(req);
1057    return ret;
1058}
1059
1060int32_t WifiStopPnoScan(const char *ifName)
1061{
1062    int32_t ret = RET_CODE_FAILURE;
1063    struct HdfSBuf *req = NULL;
1064
1065    req = HdfSbufObtainDefaultSize();
1066    if (req == NULL) {
1067        HDF_LOGE("%{public}s: HdfSbufObtainDefaultSize fail!", __FUNCTION__);
1068        return ret;
1069    }
1070
1071    do {
1072        if (!HdfSbufWriteString(req, ifName)) {
1073            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
1074            break;
1075        }
1076        ret = SendCmdSync(WIFI_HAL_CMD_STOP_PNO_SCAN, req, NULL);
1077        if (ret != RET_CODE_SUCCESS) {
1078            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
1079        }
1080    } while (0);
1081
1082    HdfSbufRecycle(req);
1083    return ret;
1084}
1085
1086int32_t ClientGetApBandwidth(const char *ifName, uint8_t *bandwidth)
1087{
1088    int32_t ret;
1089    struct HdfSBuf *data = NULL;
1090    struct HdfSBuf *reply = NULL;
1091
1092    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
1093        HDF_LOGE("%s: HdfSbufObtainDefault fail", __FUNCTION__);
1094        return RET_CODE_FAILURE;
1095    }
1096
1097    do {
1098        if (!HdfSbufWriteString(data, ifName)) {
1099            HDF_LOGE("%s: write ifName fail!", __FUNCTION__);
1100            ret = RET_CODE_FAILURE;
1101            break;
1102        }
1103        ret = SendCmdSync(WIFI_HAL_CMD_GET_AP_BANDWIDTH, data, reply);
1104        if (ret != RET_CODE_SUCCESS) {
1105            HDF_LOGE("%s: SendCmdSync fail, code=%d", __FUNCTION__, ret);
1106            break;
1107        }
1108        if (!HdfSbufReadUint8(reply, bandwidth)) {
1109            HDF_LOGE("%s: HdfSbufReadUint8 failed", __FUNCTION__);
1110            ret = RET_CODE_FAILURE;
1111            break;
1112        }
1113    } while (0);
1114
1115    HdfSbufRecycle(data);
1116    HdfSbufRecycle(reply);
1117    return ret;
1118}
1119
1120int32_t WifiGetSignalPollInfo(const char *ifName, struct SignalResult *signalResult)
1121{
1122    int32_t ret = RET_CODE_FAILURE;
1123    struct HdfSBuf *data = NULL;
1124    struct HdfSBuf *reply = NULL;
1125    const uint8_t *replayData = NULL;
1126    uint32_t size;
1127
1128    if (HdfSbufObtainDefault(&data, &reply) != RET_CODE_SUCCESS) {
1129        return RET_CODE_FAILURE;
1130    }
1131    do {
1132        if (!HdfSbufWriteString(data, ifName)) {
1133            HDF_LOGE("%{public}s: write ifName fail!", __FUNCTION__);
1134            break;
1135        }
1136        ret = SendCmdSync(WIFI_HAL_CMD_GET_SIGNAL_INFO, data, reply);
1137        if (ret != RET_CODE_SUCCESS) {
1138            HDF_LOGE("%{public}s: SendCmdSync fail, ret = %{public}d!", __FUNCTION__, ret);
1139            break;
1140        }
1141        if (!HdfSbufReadBuffer(reply, (const void **)(&replayData), &size)) {
1142            HDF_LOGE("%{public}s: read signal information fail!", __FUNCTION__);
1143            ret = RET_CODE_FAILURE;
1144            break;
1145        }
1146        if (memcpy_s(signalResult, sizeof(struct SignalResult), replayData, size) != EOK) {
1147            HDF_LOGE("%{public}s: memcpy_s fail", __FUNCTION__);
1148            ret = RET_CODE_FAILURE;
1149        }
1150    } while (0);
1151    HdfSbufRecycle(data);
1152    HdfSbufRecycle(reply);
1153    return ret;
1154}
1155
1156int32_t WifiSendActionFrame(const char *ifName, uint32_t freq, const uint8_t *frameData, uint32_t frameDataLen)
1157{
1158    (void)ifName;
1159    (void)freq;
1160    (void)frameData;
1161    (void)frameDataLen;
1162    return RET_CODE_NOT_SUPPORT;
1163}
1164
1165int32_t WifiRegisterActionFrameReceiver(const char *ifName, const uint8_t *match, uint32_t matchLen)
1166{
1167    (void)ifName;
1168    (void)match;
1169    (void)matchLen;
1170    return RET_CODE_NOT_SUPPORT;
1171}
1172
1173int32_t WifiSetPowerSaveMode(const char *ifName, int32_t frequency, int32_t mode)
1174{
1175    (void)ifName;
1176    (void)frequency;
1177    (void)mode;
1178
1179    return RET_CODE_NOT_SUPPORT;
1180}
1181
1182int32_t WifiSetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable)
1183{
1184    (void)uid;
1185    (void)protocol;
1186    (void)enable;
1187
1188    return RET_CODE_NOT_SUPPORT;
1189}
1190
1191int32_t WifiInstallWlanExtParam(const char *ifName, const InstallWlanParam *param)
1192{
1193    (void)ifName;
1194    (void)param;
1195
1196    return RET_CODE_NOT_SUPPORT;
1197}
1198
1199#ifdef __cplusplus
1200#if __cplusplus
1201}
1202#endif
1203#endif
1204