1 /*
2 * Copyright (C) 2024 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 #ifdef HDI_WPA_INTERFACE_SUPPORT
17 #include "wifi_hdi_wpa_ap_impl.h"
18 #include "wifi_hdi_util.h"
19 #include "wifi_log.h"
20 #include <unistd.h>
21 #include "stub_collector.h"
22
23 #undef LOG_TAG
24 #define LOG_TAG "wifiHdiWpaApImpl"
25
26 static pthread_mutex_t g_hdiCallbackMutex = PTHREAD_MUTEX_INITIALIZER;
27 static struct IHostapdCallback *g_hdiApCallbackObj = NULL;
28
RegisterApEventCallback()29 static WifiErrorNo RegisterApEventCallback()
30 {
31 LOGI("RegisterApEventCallback enter");
32 pthread_mutex_lock(&g_hdiCallbackMutex);
33 if (g_hdiApCallbackObj == NULL) {
34 pthread_mutex_unlock(&g_hdiCallbackMutex);
35 LOGE("RegisterApEventCallback: g_hdiApCallbackObj is NULL");
36 return WIFI_HAL_OPT_FAILED;
37 }
38
39 struct IHostapdInterface *apObj = GetApInterface();
40 if (apObj == NULL) {
41 pthread_mutex_unlock(&g_hdiCallbackMutex);
42 LOGE("RegisterApEventCallback: apObj is NULL");
43 return WIFI_HAL_OPT_FAILED;
44 }
45
46 int32_t result = apObj->RegisterEventCallback(apObj, g_hdiApCallbackObj, GetHdiApIfaceName());
47 if (result != HDF_SUCCESS) {
48 pthread_mutex_unlock(&g_hdiCallbackMutex);
49 LOGE("RegisterApEventCallback: RegisterApEventCallback failed result:%{public}d", result);
50 return WIFI_HAL_OPT_FAILED;
51 }
52
53 pthread_mutex_unlock(&g_hdiCallbackMutex);
54 LOGI("RegisterApEventCallback success.");
55 return WIFI_HAL_OPT_OK;
56 }
57
UnRegisterApEventCallback()58 static WifiErrorNo UnRegisterApEventCallback()
59 {
60 LOGI("UnRegisterApEventCallback enter");
61 pthread_mutex_lock(&g_hdiCallbackMutex);
62 if (g_hdiApCallbackObj != NULL) {
63 struct IHostapdInterface *apObj = GetApInterface();
64 if (apObj == NULL) {
65 pthread_mutex_unlock(&g_hdiCallbackMutex);
66 LOGE("UnRegisterApEventCallback: apObj is NULL");
67 return WIFI_HAL_OPT_FAILED;
68 }
69
70 int32_t result = apObj->UnregisterEventCallback(apObj, g_hdiApCallbackObj, GetHdiApIfaceName());
71 if (result != HDF_SUCCESS) {
72 pthread_mutex_unlock(&g_hdiCallbackMutex);
73 LOGE("UnRegisterEventCallback: UnRegisterEventCallback failed result:%{public}d", result);
74 return WIFI_HAL_OPT_FAILED;
75 }
76 StubCollectorRemoveObject(IHOSTAPDCALLBACK_INTERFACE_DESC, g_hdiApCallbackObj);
77 free(g_hdiApCallbackObj);
78 g_hdiApCallbackObj = NULL;
79 }
80
81 pthread_mutex_unlock(&g_hdiCallbackMutex);
82 LOGI("UnRegisterApEventCallback success.");
83 return WIFI_HAL_OPT_OK;
84 }
85
HdiRegisterApEventCallback(struct IHostapdCallback * callback)86 WifiErrorNo HdiRegisterApEventCallback(struct IHostapdCallback *callback)
87 {
88 LOGI("HdiRegisterApEventCallback enter");
89 pthread_mutex_lock(&g_hdiCallbackMutex);
90 if (callback == NULL || callback->OnEventStaJoin == NULL) {
91 pthread_mutex_unlock(&g_hdiCallbackMutex);
92 LOGE("HdiRegisterApEventCallback: invalid parameter");
93 return WIFI_HAL_OPT_INVALID_PARAM;
94 }
95
96 if (g_hdiApCallbackObj != NULL) {
97 pthread_mutex_unlock(&g_hdiCallbackMutex);
98 LOGE("HdiRegisterApEventCallback: already register");
99 return WIFI_HAL_OPT_OK;
100 }
101
102 g_hdiApCallbackObj = (struct IHostapdCallback *)malloc(sizeof(struct IHostapdCallback));
103 if (g_hdiApCallbackObj == NULL) {
104 pthread_mutex_unlock(&g_hdiCallbackMutex);
105 LOGE("HdiRegisterApEventCallback: IWpaCallback malloc failed");
106 return WIFI_HAL_OPT_FAILED;
107 }
108
109 g_hdiApCallbackObj->OnEventStaJoin = callback->OnEventStaJoin;
110 g_hdiApCallbackObj->OnEventApState = callback->OnEventApState;
111 g_hdiApCallbackObj->GetVersion = NULL;
112 g_hdiApCallbackObj->AsObject = NULL;
113
114 pthread_mutex_unlock(&g_hdiCallbackMutex);
115 LOGI("HdiRegisterApEventCallback: success.");
116 return WIFI_HAL_OPT_OK;
117 }
118
HdiStartAp(const char * ifaceName,int id)119 WifiErrorNo HdiStartAp(const char *ifaceName, int id)
120 {
121 LOGI("Ready to start hostpad: %{public}d, %{public}s", id, ifaceName);
122 if (SetHdiApIfaceName(ifaceName) != WIFI_HAL_OPT_OK) {
123 LOGE("HdiStartAp: set ap iface name failed.");
124 return WIFI_HAL_OPT_FAILED;
125 }
126
127 if (HdiApStart(id, ifaceName) != WIFI_HAL_OPT_OK) {
128 LOGE("HdiStartAp: HdiApStart failed.");
129 return WIFI_HAL_OPT_FAILED;
130 }
131
132 if (RegisterApEventCallback() != WIFI_HAL_OPT_OK) {
133 LOGE("HdiStartAp: RegisterApEventCallback failed.");
134 return WIFI_HAL_OPT_FAILED;
135 }
136
137 LOGI("HdiStartAp: success.");
138 return WIFI_HAL_OPT_OK;
139 }
140
HdiStopAp(int id)141 WifiErrorNo HdiStopAp(int id)
142 {
143 LOGI("HdiStopAp enter");
144 if (IsHdiApStopped() == WIFI_HAL_OPT_OK) {
145 LOGI("HdiStopAp: HdiAp already stopped. HdiStopAp success");
146 return WIFI_HAL_OPT_OK;
147 }
148
149 if (UnRegisterApEventCallback() != WIFI_HAL_OPT_OK) {
150 LOGE("HdiStopAp: UnRegisterApEventCallback failed.");
151 }
152
153 if (HdiApStop(id) != WIFI_HAL_OPT_OK) {
154 LOGE("HdiStopAp: HdiApStop failed.");
155 return WIFI_HAL_OPT_FAILED;
156 }
157
158 LOGI("HdiStopAp success");
159 return WIFI_HAL_OPT_OK;
160 }
161
HdiEnableAp(int id)162 WifiErrorNo HdiEnableAp(int id)
163 {
164 LOGI("HdiEnableAp enter");
165 struct IHostapdInterface *apObj = GetApInterface();
166 if (apObj == NULL) {
167 LOGE("HdiEnableAp: apObj is NULL");
168 return WIFI_HAL_OPT_FAILED;
169 }
170
171 int32_t result = apObj->EnableAp(apObj, GetHdiApIfaceName(), id);
172 if (result != HDF_SUCCESS) {
173 LOGE("HdiEnableAp failed result:%{public}d", result);
174 return WIFI_HAL_OPT_FAILED;
175 }
176
177 LOGI("HdiEnableAp success");
178 return WIFI_HAL_OPT_OK;
179 }
180
HdiDisableAp(int id)181 WifiErrorNo HdiDisableAp(int id)
182 {
183 LOGI("HdiDisableAp enter");
184 struct IHostapdInterface *apObj = GetApInterface();
185 if (apObj == NULL) {
186 LOGE("HdiDisableAp: apObj is NULL");
187 return WIFI_HAL_OPT_FAILED;
188 }
189 SetExecDisable(EXEC_DISABLE);
190 int32_t result = apObj->DisableAp(apObj, GetHdiApIfaceName(), id);
191 if (result != HDF_SUCCESS) {
192 LOGE("HdiDisableAp failed result:%{public}d", result);
193 return WIFI_HAL_OPT_FAILED;
194 }
195
196 LOGI("HdiDisableAp success");
197 return WIFI_HAL_OPT_OK;
198 }
199
HdiReloadApConfigInfo(int id)200 WifiErrorNo HdiReloadApConfigInfo(int id)
201 {
202 LOGI("HdiReloadApConfigInfo enter");
203 struct IHostapdInterface *apObj = GetApInterface();
204 if (apObj == NULL) {
205 LOGE("HdiReloadApConfigInfo: apObj is NULL");
206 return WIFI_HAL_OPT_FAILED;
207 }
208
209 int32_t result = apObj->ReloadApConfigInfo(apObj, GetHdiApIfaceName(), id);
210 if (result != HDF_SUCCESS) {
211 LOGE("HdiReloadApConfigInfo failed result:%{public}d", result);
212 return WIFI_HAL_OPT_FAILED;
213 }
214
215 LOGI("HdiReloadApConfigInfo success");
216 return WIFI_HAL_OPT_OK;
217 }
218
HdiSetApPasswd(const char * pass,int id)219 WifiErrorNo HdiSetApPasswd(const char *pass, int id)
220 {
221 LOGI("HdiSetApPasswd enter");
222 struct IHostapdInterface *apObj = GetApInterface();
223 if (apObj == NULL) {
224 LOGE("HdiSetApPasswd: apObj is NULL");
225 return WIFI_HAL_OPT_FAILED;
226 }
227
228 int32_t result = apObj->SetApPasswd(apObj, GetHdiApIfaceName(), pass, id);
229 if (result != HDF_SUCCESS) {
230 LOGE("HdiSetApPasswd failed result:%{public}d", result);
231 return WIFI_HAL_OPT_FAILED;
232 }
233
234 LOGI("HdiSetApPasswd success");
235 return WIFI_HAL_OPT_OK;
236 }
237
HdiSetApName(const char * name,int id)238 WifiErrorNo HdiSetApName(const char *name, int id)
239 {
240 LOGI("HdiSetApName enter");
241 struct IHostapdInterface *apObj = GetApInterface();
242 if (apObj == NULL) {
243 LOGE("HdiSetApName: apObj is NULL");
244 return WIFI_HAL_OPT_FAILED;
245 }
246
247 int32_t result = apObj->SetApName(apObj, GetHdiApIfaceName(), name, id);
248 if (result != HDF_SUCCESS) {
249 LOGE("HdiSetApName failed result:%{public}d", result);
250 return WIFI_HAL_OPT_FAILED;
251 }
252
253 LOGI("HdiSetApName success");
254 return WIFI_HAL_OPT_OK;
255 }
256
HdiSetApWpaValue(int securityType,int id)257 WifiErrorNo HdiSetApWpaValue(int securityType, int id)
258 {
259 LOGI("HdiSetApWpaValue enter");
260 struct IHostapdInterface *apObj = GetApInterface();
261 if (apObj == NULL) {
262 LOGE("HdiSetApWpaValue: apObj is NULL");
263 return WIFI_HAL_OPT_FAILED;
264 }
265
266 int32_t result = apObj->SetApWpaValue(apObj, GetHdiApIfaceName(), securityType, id);
267 if (result != HDF_SUCCESS) {
268 LOGE("HdiSetApWpaValue failed result:%{public}d", result);
269 return WIFI_HAL_OPT_FAILED;
270 }
271
272 LOGI("HdiSetApWpaValue success");
273 return WIFI_HAL_OPT_OK;
274 }
275
HdiSetApBand(int band,int id)276 WifiErrorNo HdiSetApBand(int band, int id)
277 {
278 LOGI("HdiSetApBand enter");
279 struct IHostapdInterface *apObj = GetApInterface();
280 if (apObj == NULL) {
281 LOGE("HdiSetApBand: apObj is NULL");
282 return WIFI_HAL_OPT_FAILED;
283 }
284
285 int32_t result = apObj->SetApBand(apObj, GetHdiApIfaceName(), band, id);
286 if (result != HDF_SUCCESS) {
287 LOGE("HdiSetApBand failed result:%{public}d", result);
288 return WIFI_HAL_OPT_FAILED;
289 }
290
291 LOGI("HdiSetApBand success");
292 return WIFI_HAL_OPT_OK;
293 }
294
HdiSetAp80211n(int value,int id)295 WifiErrorNo HdiSetAp80211n(int value, int id)
296 {
297 LOGI("HdiSetAp80211n enter");
298 struct IHostapdInterface *apObj = GetApInterface();
299 if (apObj == NULL) {
300 LOGE("HdiSetAp80211n: apObj is NULL");
301 return WIFI_HAL_OPT_FAILED;
302 }
303
304 int32_t result = apObj->SetAp80211n(apObj, GetHdiApIfaceName(), value, id);
305 if (result != HDF_SUCCESS) {
306 LOGE("HdiSetAp80211n failed result:%{public}d", result);
307 return WIFI_HAL_OPT_FAILED;
308 }
309
310 LOGI("HdiSetAp80211n success");
311 return WIFI_HAL_OPT_OK;
312 }
313
HdiSetApWmm(int value,int id)314 WifiErrorNo HdiSetApWmm(int value, int id)
315 {
316 LOGI("HdiSetApWmm enter");
317 struct IHostapdInterface *apObj = GetApInterface();
318 if (apObj == NULL) {
319 LOGE("HdiSetApWmm: apObj is NULL");
320 return WIFI_HAL_OPT_FAILED;
321 }
322
323 int32_t result = apObj->SetApWmm(apObj, GetHdiApIfaceName(), value, id);
324 if (result != HDF_SUCCESS) {
325 LOGE("HdiSetApWmm failed result:%{public}d", result);
326 return WIFI_HAL_OPT_FAILED;
327 }
328
329 LOGI("HdiSetApWmm success");
330 return WIFI_HAL_OPT_OK;
331 }
332
HdiSetApChannel(int channel,int id)333 WifiErrorNo HdiSetApChannel(int channel, int id)
334 {
335 LOGI("HdiSetApChannel enter");
336 struct IHostapdInterface *apObj = GetApInterface();
337 if (apObj == NULL) {
338 LOGE("HdiSetApChannel: apObj is NULL");
339 return WIFI_HAL_OPT_FAILED;
340 }
341
342 int32_t result = apObj->SetApChannel(apObj, GetHdiApIfaceName(), channel, id);
343 if (result != HDF_SUCCESS) {
344 LOGE("HdiSetApChannel failed result:%{public}d", result);
345 return WIFI_HAL_OPT_FAILED;
346 }
347
348 LOGI("HdiSetApChannel success");
349 return WIFI_HAL_OPT_OK;
350 }
351
HdiSetApMaxConn(int maxConn,int id)352 WifiErrorNo HdiSetApMaxConn(int maxConn, int id)
353 {
354 LOGI("HdiSetApMaxConn enter");
355 struct IHostapdInterface *apObj = GetApInterface();
356 if (apObj == NULL) {
357 LOGE("HdiSetApMaxConn: apObj is NULL");
358 return WIFI_HAL_OPT_FAILED;
359 }
360
361 int32_t result = apObj->SetApMaxConn(apObj, GetHdiApIfaceName(), maxConn, id);
362 if (result != HDF_SUCCESS) {
363 LOGE("HdiSetApMaxConn failed result:%{public}d", result);
364 return WIFI_HAL_OPT_FAILED;
365 }
366
367 LOGI("HdiSetApMaxConn success");
368 return WIFI_HAL_OPT_OK;
369 }
370
HdiSetMacFilter(const char * mac,int id)371 WifiErrorNo HdiSetMacFilter(const char *mac, int id)
372 {
373 LOGI("HdiSetMacFilter enter");
374 struct IHostapdInterface *apObj = GetApInterface();
375 if (apObj == NULL) {
376 LOGE("HdiSetMacFilter: apObj is NULL");
377 return WIFI_HAL_OPT_FAILED;
378 }
379
380 int32_t result = apObj->SetMacFilter(apObj, GetHdiApIfaceName(), mac, id);
381 if (result != HDF_SUCCESS) {
382 LOGE("HdiSetMacFilter failed result:%{public}d", result);
383 return WIFI_HAL_OPT_FAILED;
384 }
385
386 LOGI("HdiSetMacFilter success");
387 return WIFI_HAL_OPT_OK;
388 }
389
HdiDelMacFilter(const char * mac,int id)390 WifiErrorNo HdiDelMacFilter(const char *mac, int id)
391 {
392 LOGI("HHdiDelMacFilter enter");
393 struct IHostapdInterface *apObj = GetApInterface();
394 if (apObj == NULL) {
395 LOGE("HHdiDelMacFilter: apObj is NULL");
396 return WIFI_HAL_OPT_FAILED;
397 }
398
399 int32_t result = apObj->DelMacFilter(apObj, GetHdiApIfaceName(), mac, id);
400 if (result != HDF_SUCCESS) {
401 LOGE("HHdiDelMacFilter failed result:%{public}d", result);
402 return WIFI_HAL_OPT_FAILED;
403 }
404
405 LOGI("HHdiDelMacFilter success");
406 return WIFI_HAL_OPT_OK;
407 }
408
HdiGetStaInfos(char * buf,int size,int id)409 WifiErrorNo HdiGetStaInfos(char *buf, int size, int id)
410 {
411 LOGI("HdiGetStaInfos enter");
412 struct IHostapdInterface *apObj = GetApInterface();
413 if (apObj == NULL) {
414 LOGE("HdiGetStaInfos: apObj is NULL");
415 return WIFI_HAL_OPT_FAILED;
416 }
417
418 int32_t result = apObj->GetStaInfos(apObj, GetHdiApIfaceName(), buf, size, size, id);
419 if (result != HDF_SUCCESS) {
420 LOGE("HdiGetStaInfos failed result:%{public}d", result);
421 return WIFI_HAL_OPT_FAILED;
422 }
423
424 LOGI("HdiGetStaInfos success");
425 return WIFI_HAL_OPT_OK;
426 }
427
HdiDisassociateSta(const char * mac,int id)428 WifiErrorNo HdiDisassociateSta(const char *mac, int id)
429 {
430 LOGI("HdiDisassociateSta enter");
431 struct IHostapdInterface *apObj = GetApInterface();
432 if (apObj == NULL) {
433 LOGE("HdiDisassociateSta: apObj is NULL");
434 return WIFI_HAL_OPT_FAILED;
435 }
436
437 int32_t result = apObj->DisassociateSta(apObj, GetHdiApIfaceName(), mac, id);
438 if (result != HDF_SUCCESS) {
439 LOGE("HdiDisassociateSta failed result:%{public}d", result);
440 return WIFI_HAL_OPT_FAILED;
441 }
442
443 LOGI("HdiDisassociateSta success");
444 return WIFI_HAL_OPT_OK;
445 }
446
447 #endif