1 /*
2 * Copyright (C) 2021-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
16 #include "wifi_hal_crpc_server.h"
17 #include <securec.h>
18 #include "serial.h"
19 #include "wifi_hal_crpc_base.h"
20 #include "wifi_hal_crpc_chip.h"
21 #include "wifi_hal_crpc_supplicant.h"
22 #include "wifi_hal_crpc_sta.h"
23 #include "wifi_hal_crpc_ap.h"
24 #include "wifi_hal_crpc_common.h"
25 #include "wifi_hal_crpc_p2p.h"
26 #include "wifi_log.h"
27 #include "wifi_hal_common_func.h"
28
29 #undef LOG_TAG
30 #define LOG_TAG "WifiHalCrpcServer"
31
32 /* Defines the mapping between global function names and functions. */
33 static WifiHalRpcFunc *g_rpcFuncHandle = NULL;
34 static RpcServer *g_rpcServer = NULL;
35
SetRpcServerInited(RpcServer * server)36 void SetRpcServerInited(RpcServer *server)
37 {
38 g_rpcServer = server;
39 return;
40 }
41
GetRpcServer(void)42 RpcServer *GetRpcServer(void)
43 {
44 return g_rpcServer;
45 }
46
GetPos(const char * name)47 static int GetPos(const char *name)
48 {
49 int total = 0;
50 while (*name) {
51 total += *name;
52 ++name;
53 }
54 if (total < 0) {
55 total *= -1;
56 }
57 return total % RPC_FUNC_NUM;
58 }
59
PushRpcFunc(const char * name,Rpcfunc func)60 static int PushRpcFunc(const char *name, Rpcfunc func)
61 {
62 if (g_rpcFuncHandle == NULL || name == NULL || func == NULL) {
63 return HAL_FAILURE;
64 }
65 int pos = GetPos(name);
66 if (g_rpcFuncHandle[pos].func == NULL) {
67 StrSafeCopy(g_rpcFuncHandle[pos].funcname, sizeof(g_rpcFuncHandle[pos].funcname), name);
68 g_rpcFuncHandle[pos].func = func;
69 } else {
70 WifiHalRpcFunc *p = g_rpcFuncHandle + pos;
71 while (p->next != NULL) {
72 p = p->next;
73 }
74 WifiHalRpcFunc *q = (WifiHalRpcFunc *)calloc(1, sizeof(WifiHalRpcFunc));
75 if (q == NULL) {
76 return HAL_FAILURE;
77 }
78 StrSafeCopy(q->funcname, sizeof(q->funcname), name);
79 q->func = func;
80 q->next = NULL;
81 p->next = q;
82 }
83 return HAL_SUCCESS;
84 }
85
InitRpcFuncMapBase(void)86 static int InitRpcFuncMapBase(void)
87 {
88 int ret = 0;
89 ret += PushRpcFunc("GetName", RpcGetName);
90 ret += PushRpcFunc("GetType", RpcGetType);
91 return ret;
92 }
93
InitRpcFuncMapChip(void)94 static int InitRpcFuncMapChip(void)
95 {
96 int ret = 0;
97 ret += PushRpcFunc("GetWifiChip", RpcGetWifiChip);
98 ret += PushRpcFunc("GetWifiChipIds", RpcGetWifiChipIds);
99 ret += PushRpcFunc("GetChipId", RpcGetChipId);
100 ret += PushRpcFunc("CreateIface", RpcCreateIface);
101 ret += PushRpcFunc("GetIface", RpcGetIface);
102 ret += PushRpcFunc("GetIfaceNames", RpcGetIfaceNames);
103 ret += PushRpcFunc("RemoveIface", RpcRemoveIface);
104 ret += PushRpcFunc("GetCapabilities", RpcGetCapabilities);
105 ret += PushRpcFunc("GetSupportedComboModes", RpcGetSupportedComboModes);
106 ret += PushRpcFunc("ConfigComboModes", RpcConfigComboModes);
107 ret += PushRpcFunc("GetComboModes", RpcGetComboModes);
108 ret += PushRpcFunc("RequestFirmwareDebugDump", RpcRequestFirmwareDebugDump);
109 ret += PushRpcFunc("IsChipSupportDbdc", RpcIsChipSupportDbdc);
110 ret += PushRpcFunc("IsChipSupportCsa", RpcIsChipSupportCsa);
111 ret += PushRpcFunc("IsChipSupportRadarDetect", RpcIsChipSupportRadarDetect);
112 ret += PushRpcFunc("IsChipSupportDfsChannel", RpcIsChipSupportDfsChannel);
113 ret += PushRpcFunc("IsChipSupportIndoorChannel", RpcIsChipSupportIndoorChannel);
114 return ret;
115 }
116
InitRpcFuncMapSupplicant(void)117 static int InitRpcFuncMapSupplicant(void)
118 {
119 int ret = 0;
120 ret += PushRpcFunc("StartSupplicant", RpcStartSupplicant);
121 ret += PushRpcFunc("StopSupplicant", RpcStopSupplicant);
122 ret += PushRpcFunc("ConnectSupplicant", RpcConnectSupplicant);
123 ret += PushRpcFunc("DisconnectSupplicant", RpcDisconnectSupplicant);
124 ret += PushRpcFunc("RequestToSupplicant", RpcRequestToSupplicant);
125 ret += PushRpcFunc("SetPowerSave", RpcSetPowerSave);
126 ret += PushRpcFunc("WpaSetCountryCode", RpcWpaSetCountryCode);
127 ret += PushRpcFunc("WpaGetCountryCode", RpcWpaGetCountryCode);
128 return ret;
129 }
130
InitRpcFuncMapSta(void)131 static int InitRpcFuncMapSta(void)
132 {
133 int ret = 0;
134 ret += PushRpcFunc("Start", RpcStart);
135 ret += PushRpcFunc("Stop", RpcStop);
136 ret += PushRpcFunc("StartScan", RpcStartScan);
137 ret += PushRpcFunc("GetScanInfos", RpcGetScanInfos);
138 ret += PushRpcFunc("StartPnoScan", RpcStartPnoScan);
139 ret += PushRpcFunc("StopPnoScan", RpcStopPnoScan);
140 ret += PushRpcFunc("Connect", RpcConnect);
141 ret += PushRpcFunc("Reconnect", RpcReconnect);
142 ret += PushRpcFunc("Reassociate", RpcReassociate);
143 ret += PushRpcFunc("Disconnect", RpcDisconnect);
144 ret += PushRpcFunc("GetStaCapabilities", RpcGetStaCapabilities);
145 ret += PushRpcFunc("GetDeviceMacAddress", RpcGetDeviceMacAddress);
146 ret += PushRpcFunc("GetFrequencies", RpcGetFrequencies);
147 ret += PushRpcFunc("SetAssocMacAddr", RpcSetAssocMacAddr);
148 ret += PushRpcFunc("SetScanningMacAddress", RpcSetScanningMacAddress);
149 ret += PushRpcFunc("DeauthLastRoamingBssid", RpcDeauthLastRoamingBssid);
150 ret += PushRpcFunc("GetSupportFeature", RpcGetSupportFeature);
151 ret += PushRpcFunc("RunCmd", RpcRunCmd);
152 ret += PushRpcFunc("SetWifiTxPower", RpcSetWifiTxPower);
153 ret += PushRpcFunc("RemoveNetwork", RpcRemoveNetwork);
154 ret += PushRpcFunc("AddNetwork", RpcAddNetwork);
155 ret += PushRpcFunc("EnableNetwork", RpcEnableNetwork);
156 ret += PushRpcFunc("DisableNetwork", RpcDisableNetwork);
157 ret += PushRpcFunc("SetNetwork", RpcSetNetwork);
158 ret += PushRpcFunc("SaveNetworkConfig", RpcSaveNetworkConfig);
159 ret += PushRpcFunc("StartWpsPbcMode", RpcStartWpsPbcMode);
160 ret += PushRpcFunc("StartWpsPinMode", RpcStartWpsPinMode);
161 ret += PushRpcFunc("StopWps", RpcStopWps);
162 ret += PushRpcFunc("GetRoamingCapabilities", RpcGetRoamingCapabilities);
163 ret += PushRpcFunc("SetRoamConfig", RpcSetRoamConfig);
164 ret += PushRpcFunc("WpaGetNetwork", RpcWpaGetNetwork);
165 ret += PushRpcFunc("WpaAutoConnect", RpcWpaAutoConnect);
166 ret += PushRpcFunc("WpaBlocklistClear", RpcWpaBlocklistClear);
167 ret += PushRpcFunc("GetNetworkList", RpcGetNetworkList);
168 ret += PushRpcFunc("GetConnectSignalInfo", RpcGetConnectSignalInfo);
169 ret += PushRpcFunc("SetSuspendMode", RpcSetSuspendMode);
170 return ret;
171 }
172
InitRpcFuncMapAp(void)173 static int InitRpcFuncMapAp(void)
174 {
175 int ret = 0;
176 ret += PushRpcFunc("StartSoftAp", RpcStartSoftAp);
177 ret += PushRpcFunc("StopSoftAp", RpcStopSoftAp);
178 ret += PushRpcFunc("SetHostapdConfig", RpcSetHostapdConfig);
179 ret += PushRpcFunc("GetStaInfos", RpcGetStaInfos);
180 ret += PushRpcFunc("SetCountryCode", RpcSetCountryCode);
181 ret += PushRpcFunc("SetMacFilter", RpcSetMacFilter);
182 ret += PushRpcFunc("DelMacFilter", RpcDelMacFilter);
183 ret += PushRpcFunc("DisassociateSta", RpcDisassociateSta);
184 ret += PushRpcFunc("GetValidFrequenciesForBand", RpcGetValidFrequenciesForBand);
185 ret += PushRpcFunc("WpaSetPowerModel", RpcSetPowerModel);
186 ret += PushRpcFunc("WpaGetPowerModel", RpcGetPowerModel);
187 return ret;
188 }
189
InitRpcFuncMapCommon(void)190 static int InitRpcFuncMapCommon(void)
191 {
192 int ret = 0;
193 ret += PushRpcFunc("RegisterEventCallback", RpcRegisterEventCallback);
194 ret += PushRpcFunc("UnRegisterEventCallback", RpcUnRegisterEventCallback);
195 ret += PushRpcFunc("NotifyClear", RpcNotifyClear);
196 return ret;
197 }
198
InitRpcFuncMapP2p(void)199 static int InitRpcFuncMapP2p(void)
200 {
201 int ret = 0;
202 ret += PushRpcFunc("P2pStart", RpcP2pStart);
203 ret += PushRpcFunc("P2pStop", RpcP2pStop);
204 ret += PushRpcFunc("P2pSetRandomMac", RpcP2pSetRandomMac);
205 ret += PushRpcFunc("P2pSetDeviceName", RpcP2pSetDeviceName);
206 ret += PushRpcFunc("P2pSetSsidPostfixName", RpcP2pSetSsidPostfixName);
207 ret += PushRpcFunc("P2pSetWpsDeviceType", RpcP2pSetWpsDeviceType);
208 ret += PushRpcFunc("P2pSetWpsSecondaryDeviceType", RpcP2pSetWpsSecondaryDeviceType);
209 ret += PushRpcFunc("P2pSetWpsConfigMethods", RpcP2pSetWpsConfigMethods);
210 ret += PushRpcFunc("P2pGetDeviceAddress", RpcP2pGetDeviceAddress);
211 ret += PushRpcFunc("P2pFlush", RpcP2pFlush);
212 ret += PushRpcFunc("P2pFlushService", RpcP2pFlushService);
213 ret += PushRpcFunc("P2pSaveConfig", RpcP2pSaveConfig);
214 ret += PushRpcFunc("P2pSetupWpsPbc", RpcP2pSetupWpsPbc);
215 ret += PushRpcFunc("P2pSetupWpsPin", RpcP2pSetupWpsPin);
216 ret += PushRpcFunc("P2pRemoveNetwork", RpcP2pRemoveNetwork);
217 ret += PushRpcFunc("P2pListNetworks", RpcP2pListNetworks);
218 ret += PushRpcFunc("P2pSetGroupMaxIdle", RpcP2pSetGroupMaxIdle);
219 ret += PushRpcFunc("P2pSetPowerSave", RpcP2pSetPowerSave);
220 ret += PushRpcFunc("P2pSetWfdEnable", RpcP2pSetWfdEnable);
221 ret += PushRpcFunc("P2pSetWfdDeviceConfig", RpcP2pSetWfdDeviceConfig);
222 ret += PushRpcFunc("P2pStartFind", RpcP2pStartFind);
223 ret += PushRpcFunc("P2pStopFind", RpcP2pStopFind);
224 ret += PushRpcFunc("P2pSetExtListen", RpcP2pSetExtListen);
225 ret += PushRpcFunc("P2pSetListenChannel", RpcP2pSetListenChannel);
226 ret += PushRpcFunc("P2pConnect", RpcP2pConnect);
227 ret += PushRpcFunc("P2pCancelConnect", RpcP2pCancelConnect);
228 ret += PushRpcFunc("P2pProvisionDiscovery", RpcP2pProvisionDiscovery);
229 ret += PushRpcFunc("P2pAddGroup", RpcP2pAddGroup);
230 ret += PushRpcFunc("P2pRemoveGroup", RpcP2pRemoveGroup);
231 ret += PushRpcFunc("P2pInvite", RpcP2pInvite);
232 ret += PushRpcFunc("P2pReinvoke", RpcP2pReinvoke);
233 ret += PushRpcFunc("P2pGetGroupCapability", RpcP2pGetGroupCapability);
234 ret += PushRpcFunc("P2pAddService", RpcP2pAddService);
235 ret += PushRpcFunc("P2pRemoveService", RpcP2pRemoveService);
236 ret += PushRpcFunc("P2pReqServiceDiscovery", RpcP2pReqServiceDiscovery);
237 ret += PushRpcFunc("P2pCancelServiceDiscovery", RpcP2pCancelServiceDiscovery);
238 ret += PushRpcFunc("P2pSetMiracastType", RpcP2pSetMiracastType);
239 ret += PushRpcFunc("P2pRespServerDiscovery", RpcP2pRespServerDiscovery);
240 ret += PushRpcFunc("P2pSetServDiscExternal", RpcP2pSetServDiscExternal);
241 ret += PushRpcFunc("P2pSetPersistentReconnect", RpcP2pSetPersistentReconnect);
242 ret += PushRpcFunc("P2pGetPeer", RpcP2pGetPeer);
243 ret += PushRpcFunc("P2pGetFrequencies", RpcP2pGetFrequencies);
244 ret += PushRpcFunc("P2pSetGroupConfig", RpcP2pSetGroupConfig);
245 ret += PushRpcFunc("P2pGetGroupConfig", RpcP2pGetGroupConfig);
246 ret += PushRpcFunc("P2pAddNetwork", RpcP2pAddNetwork);
247 ret += PushRpcFunc("P2pHid2dConnect", RpcP2pHid2dConnect);
248 return ret;
249 }
250
InitRpcFunc(void)251 int InitRpcFunc(void)
252 {
253 if (g_rpcFuncHandle != NULL) {
254 return HAL_SUCCESS;
255 }
256 g_rpcFuncHandle = (WifiHalRpcFunc *)calloc(RPC_FUNC_NUM, sizeof(WifiHalRpcFunc));
257 if (g_rpcFuncHandle == NULL) {
258 return HAL_FAILURE;
259 }
260
261 int ret = 0;
262 ret += InitRpcFuncMapBase();
263 ret += InitRpcFuncMapChip();
264 ret += InitRpcFuncMapSupplicant();
265 ret += InitRpcFuncMapSta();
266 ret += InitRpcFuncMapAp();
267 ret += InitRpcFuncMapCommon();
268 ret += InitRpcFuncMapP2p();
269 if (ret < 0) {
270 return HAL_FAILURE;
271 }
272
273 if (InitCallbackMsg() < 0) {
274 return HAL_FAILURE;
275 }
276 return HAL_SUCCESS;
277 }
278
ReleaseRpcFunc(void)279 void ReleaseRpcFunc(void)
280 {
281 for (int i = 0; i < RPC_FUNC_NUM; ++i) {
282 WifiHalRpcFunc *p = g_rpcFuncHandle[i].next;
283 while (p != NULL) {
284 WifiHalRpcFunc *q = p->next;
285 free(p);
286 p = q;
287 }
288 }
289 free(g_rpcFuncHandle);
290 g_rpcFuncHandle = NULL;
291 ReleaseCallbackMsg();
292 return;
293 }
294
GetRpcFunc(const char * func)295 Rpcfunc GetRpcFunc(const char *func)
296 {
297 if (g_rpcFuncHandle == NULL || func == NULL) {
298 return NULL;
299 }
300 int pos = GetPos(func);
301 WifiHalRpcFunc *p = g_rpcFuncHandle + pos;
302 while (p && strcmp(p->funcname, func) != 0) {
303 p = p->next;
304 }
305 if (p == NULL) {
306 return NULL;
307 }
308 return p->func;
309 }
310
311 /* Processing client requests */
OnTransact(RpcServer * server,Context * context)312 int OnTransact(RpcServer *server, Context *context)
313 {
314 if ((server == NULL) || (context == NULL)) {
315 return HAL_FAILURE;
316 }
317
318 char func[RPC_FUNCNAME_MAX_LEN] = {0};
319 int ret = ReadFunc(context, func, RPC_FUNCNAME_MAX_LEN);
320 if (ret < 0) {
321 return HAL_FAILURE;
322 }
323 LOGD("run %{public}s", func);
324 Rpcfunc pFunc = GetRpcFunc(func);
325 if (pFunc == NULL) {
326 LOGD("unsupported function[%{public}s]", func);
327 WriteBegin(context, 0);
328 WriteInt(context, WIFI_HAL_FAILED);
329 WriteStr(context, "unsupported function");
330 WriteEnd(context);
331 } else {
332 ret = pFunc(server, context);
333 if (ret < 0) {
334 WriteBegin(context, 0);
335 WriteInt(context, WIFI_HAL_FAILED);
336 WriteStr(context, "server deal failed!");
337 WriteEnd(context);
338 }
339 }
340 return HAL_SUCCESS;
341 }
342
343 /* Defines the bidirectional list of global callback event parameters. */
344 static WifiHalEventCallback *g_wifiHalEventCallback = NULL;
345
InitCallbackMsg(void)346 int InitCallbackMsg(void)
347 {
348 if (g_wifiHalEventCallback != NULL) {
349 return HAL_SUCCESS;
350 }
351 g_wifiHalEventCallback = (WifiHalEventCallback *)calloc(1, sizeof(WifiHalEventCallback));
352 if (g_wifiHalEventCallback == NULL) {
353 return HAL_FAILURE;
354 }
355 pthread_mutex_init(&g_wifiHalEventCallback->mutex, NULL);
356 for (int i = 0; i < WIFI_HAL_MAX_EVENT - WIFI_FAILURE_EVENT; ++i) {
357 g_wifiHalEventCallback->cbmsgs[i].pre = g_wifiHalEventCallback->cbmsgs + i;
358 g_wifiHalEventCallback->cbmsgs[i].next = g_wifiHalEventCallback->cbmsgs + i;
359 }
360 return HAL_SUCCESS;
361 }
362
ReleaseCallbackMsg(void)363 void ReleaseCallbackMsg(void)
364 {
365 if (g_wifiHalEventCallback == NULL) {
366 return;
367 }
368 for (int i = 0; i < WIFI_HAL_MAX_EVENT - WIFI_FAILURE_EVENT; ++i) {
369 WifiHalEventCallbackMsg *head = g_wifiHalEventCallback->cbmsgs + i;
370 WifiHalEventCallbackMsg *p = head->next;
371 while (p != head) {
372 WifiHalEventCallbackMsg *q = p->next;
373 free(p);
374 p = q;
375 }
376 }
377 pthread_mutex_destroy(&g_wifiHalEventCallback->mutex);
378 free(g_wifiHalEventCallback);
379 g_wifiHalEventCallback = NULL;
380 return;
381 }
382
PushBackCallbackMsg(int event,WifiHalEventCallbackMsg * msg)383 int PushBackCallbackMsg(int event, WifiHalEventCallbackMsg *msg)
384 {
385 if (g_wifiHalEventCallback == NULL || event >= WIFI_HAL_MAX_EVENT || event < WIFI_FAILURE_EVENT || msg == NULL) {
386 return HAL_FAILURE;
387 }
388 int pos = event - WIFI_FAILURE_EVENT;
389 pthread_mutex_lock(&g_wifiHalEventCallback->mutex);
390 WifiHalEventCallbackMsg *head = g_wifiHalEventCallback->cbmsgs + pos;
391 if (head->next == head) { /* Empty Queue */
392 msg->pre = head;
393 head->next = msg;
394 msg->next = head;
395 head->pre = msg;
396 } else {
397 msg->pre = head->pre;
398 head->pre->next = msg;
399 msg->next = head;
400 head->pre = msg;
401 }
402 pthread_mutex_unlock(&g_wifiHalEventCallback->mutex);
403 return HAL_SUCCESS;
404 }
405
PopBackCallbackMsg(int event)406 int PopBackCallbackMsg(int event)
407 {
408 if (g_wifiHalEventCallback == NULL || event >= WIFI_HAL_MAX_EVENT || event < WIFI_FAILURE_EVENT) {
409 return HAL_FAILURE;
410 }
411 int pos = event - WIFI_FAILURE_EVENT;
412 pthread_mutex_lock(&g_wifiHalEventCallback->mutex);
413 WifiHalEventCallbackMsg *head = g_wifiHalEventCallback->cbmsgs + pos;
414 if (head->next != head) { /* The queue is not empty. */
415 WifiHalEventCallbackMsg *tail = head->pre;
416 head->pre = tail->pre;
417 tail->pre->next = head;
418 }
419 pthread_mutex_unlock(&g_wifiHalEventCallback->mutex);
420 return HAL_SUCCESS;
421 }
422
FrontCallbackMsg(int event)423 WifiHalEventCallbackMsg *FrontCallbackMsg(int event)
424 {
425 if (g_wifiHalEventCallback == NULL || event >= WIFI_HAL_MAX_EVENT || event < WIFI_FAILURE_EVENT) {
426 return NULL;
427 }
428 int pos = event - WIFI_FAILURE_EVENT;
429 WifiHalEventCallbackMsg *head = g_wifiHalEventCallback->cbmsgs + pos;
430 if (head->next != head) { /* The queue is not empty. */
431 return head->next;
432 } else {
433 return NULL;
434 }
435 }
436
PopFrontCallbackMsg(int event)437 int PopFrontCallbackMsg(int event)
438 {
439 if (g_wifiHalEventCallback == NULL || event >= WIFI_HAL_MAX_EVENT || event < WIFI_FAILURE_EVENT) {
440 return HAL_FAILURE;
441 }
442 int pos = event - WIFI_FAILURE_EVENT;
443 pthread_mutex_lock(&g_wifiHalEventCallback->mutex);
444 WifiHalEventCallbackMsg *head = g_wifiHalEventCallback->cbmsgs + pos;
445 if (head->next != head) { /* The queue is not empty. */
446 WifiHalEventCallbackMsg *p = head->next;
447 head->next = p->next;
448 p->next->pre = head;
449 free(p);
450 p = NULL;
451 }
452 pthread_mutex_unlock(&g_wifiHalEventCallback->mutex);
453 return HAL_SUCCESS;
454 }
455
456 /* Processing callback messages */
DealCommonCbk(int event,Context * context)457 static void DealCommonCbk(int event, Context *context)
458 {
459 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
460 if (cbmsg != NULL) {
461 WriteInt(context, cbmsg->msg.scanStatus);
462 }
463 return;
464 }
465
DealIfaceCbk(int event,Context * context)466 static void DealIfaceCbk(int event, Context *context)
467 {
468 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
469 if (cbmsg != NULL) {
470 WriteInt(context, cbmsg->msg.ifMsg.id);
471 WriteInt(context, cbmsg->msg.ifMsg.type);
472 WriteStr(context, cbmsg->msg.ifMsg.ifname);
473 }
474 return;
475 }
476
DealConnectionChangedCbk(int event,Context * context)477 static void DealConnectionChangedCbk(int event, Context *context)
478 {
479 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
480 if (cbmsg != NULL) {
481 WriteInt(context, cbmsg->msg.connMsg.status);
482 WriteInt(context, cbmsg->msg.connMsg.networkId);
483 WriteStr(context, cbmsg->msg.connMsg.bssid);
484 }
485 return;
486 }
487
DealBssidChangedCbk(int event,Context * context)488 static void DealBssidChangedCbk(int event, Context *context)
489 {
490 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
491 if (cbmsg != NULL) {
492 WriteStr(context, cbmsg->msg.bssidChangedMsg.reason);
493 WriteStr(context, cbmsg->msg.bssidChangedMsg.bssid);
494 }
495 return;
496 }
497
DealConnectWpsResultCbk(int event,Context * context)498 static void DealConnectWpsResultCbk(int event, Context *context)
499 {
500 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
501 if (cbmsg != NULL) {
502 WriteInt(context, cbmsg->msg.connMsg.status);
503 }
504 return;
505 }
506
DealStaApCallback(int event,Context * context)507 static void DealStaApCallback(int event, Context *context)
508 {
509 switch (event) {
510 case WIFI_ADD_IFACE_EVENT:
511 case WIFI_STA_JOIN_EVENT:
512 case WIFI_STA_LEAVE_EVENT:
513 case WIFI_AP_ENABLE_EVENT:
514 case WIFI_AP_DISABLE_EVENT:
515 DealIfaceCbk(event, context);
516 break;
517 case WIFI_SCAN_INFO_NOTIFY_EVENT:
518 DealCommonCbk(event, context);
519 break;
520 case WIFI_WPA_STATE_EVENT:
521 case WIFI_SSID_WRONG_KEY:
522 case WIFI_WPS_OVERLAP:
523 case WIFI_WPS_TIME_OUT:
524 case WIFI_CONNECTION_FULL_EVENT:
525 case WIFI_CONNECTION_REJECT_EVENT:
526 DealConnectWpsResultCbk(event, context);
527 break;
528 case WIFI_CONNECT_CHANGED_NOTIFY_EVENT:
529 DealConnectionChangedCbk(event, context);
530 break;
531 case WIFI_BSSID_CHANGED_NOTIFY_EVENT:
532 DealBssidChangedCbk(event, context);
533 break;
534 default:
535 LOGE("DealStaApCallback, Invalid event: %{public}d", event);
536 break;
537 }
538 return;
539 }
540
DealP2pDeviceFoundCbk(int event,Context * context)541 static void DealP2pDeviceFoundCbk(int event, Context *context)
542 {
543 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
544 if (cbmsg != NULL) {
545 WriteInt(context, cbmsg->msg.deviceInfo.configMethods);
546 WriteInt(context, cbmsg->msg.deviceInfo.deviceCapabilities);
547 WriteInt(context, cbmsg->msg.deviceInfo.groupCapabilities);
548 WriteInt(context, cbmsg->msg.deviceInfo.wfdLength);
549 WriteStr(context, cbmsg->msg.deviceInfo.srcAddress);
550 WriteStr(context, cbmsg->msg.deviceInfo.p2pDeviceAddress);
551 WriteStr(context, cbmsg->msg.deviceInfo.primaryDeviceType);
552 WriteStr(context, cbmsg->msg.deviceInfo.deviceName);
553 WriteStr(context, cbmsg->msg.deviceInfo.wfdDeviceInfo);
554 }
555 return;
556 }
557
DealP2pNegoriationCbk(int event,Context * context)558 static void DealP2pNegoriationCbk(int event, Context *context)
559 {
560 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
561 if (cbmsg != NULL) {
562 if (event == P2P_DEVICE_LOST_EVENT) {
563 WriteStr(context, cbmsg->msg.connMsg.bssid);
564 }
565 if (event == P2P_GO_NEGOTIATION_REQUEST_EVENT) {
566 WriteInt(context, cbmsg->msg.connMsg.status);
567 WriteStr(context, cbmsg->msg.connMsg.bssid);
568 }
569 }
570 return;
571 }
572
DealP2pInviationCbk(int event,Context * context)573 static void DealP2pInviationCbk(int event, Context *context)
574 {
575 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
576 if (cbmsg != NULL) {
577 if (event == P2P_INVITATION_RECEIVED_EVENT) {
578 WriteInt(context, cbmsg->msg.invitaInfo.type);
579 WriteInt(context, cbmsg->msg.invitaInfo.persistentNetworkId);
580 WriteInt(context, cbmsg->msg.invitaInfo.operatingFrequency);
581 WriteStr(context, cbmsg->msg.invitaInfo.srcAddress);
582 WriteStr(context, cbmsg->msg.invitaInfo.goDeviceAddress);
583 WriteStr(context, cbmsg->msg.invitaInfo.bssid);
584 }
585 if (event == P2P_INVITATION_RESULT_EVENT) {
586 WriteInt(context, cbmsg->msg.invitaInfo.persistentNetworkId);
587 WriteStr(context, cbmsg->msg.invitaInfo.bssid);
588 }
589 if (event == P2P_GROUP_FORMATION_FAILURE_EVENT) {
590 WriteStr(context, cbmsg->msg.invitaInfo.bssid);
591 }
592 }
593 return;
594 }
595
DealP2pGroupInfoCbk(int event,Context * context)596 static void DealP2pGroupInfoCbk(int event, Context *context)
597 {
598 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
599 if (cbmsg != NULL) {
600 if (event == P2P_GROUP_STARTED_EVENT) {
601 WriteInt(context, cbmsg->msg.groupInfo.isGo);
602 WriteInt(context, cbmsg->msg.groupInfo.isPersistent);
603 WriteInt(context, cbmsg->msg.groupInfo.frequency);
604 WriteStr(context, cbmsg->msg.groupInfo.groupIfName);
605 WriteStr(context, cbmsg->msg.groupInfo.ssid);
606 WriteStr(context, cbmsg->msg.groupInfo.psk);
607 WriteStr(context, cbmsg->msg.groupInfo.passphrase);
608 WriteStr(context, cbmsg->msg.groupInfo.goDeviceAddress);
609 }
610 if (event == P2P_GROUP_REMOVED_EVENT) {
611 WriteInt(context, cbmsg->msg.groupInfo.isGo);
612 WriteStr(context, cbmsg->msg.groupInfo.groupIfName);
613 }
614 }
615 return;
616 }
617
DealP2pDeviceInfoCbk(int event,Context * context)618 static void DealP2pDeviceInfoCbk(int event, Context *context)
619 {
620 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
621 if (cbmsg != NULL) {
622 if (event == P2P_PROV_DISC_PBC_REQ_EVENT || event == P2P_PROV_DISC_PBC_RSP_EVENT ||
623 event == P2P_PROV_DISC_ENTER_PIN_EVENT) {
624 WriteStr(context, cbmsg->msg.deviceInfo.srcAddress);
625 }
626 if (event == P2P_PROV_DISC_SHOW_PIN_EVENT) {
627 WriteStr(context, cbmsg->msg.deviceInfo.srcAddress);
628 WriteStr(context, cbmsg->msg.deviceInfo.deviceName);
629 }
630 if (event == AP_STA_DISCONNECTED_EVENT || event == AP_STA_CONNECTED_EVENT) {
631 WriteStr(context, cbmsg->msg.deviceInfo.p2pDeviceAddress);
632 }
633 }
634 return;
635 }
636
DealP2pServerInfoCbk(int event,Context * context)637 static void DealP2pServerInfoCbk(int event, Context *context)
638 {
639 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
640 if (cbmsg != NULL) {
641 WriteInt(context, cbmsg->msg.serverInfo.updateIndicator);
642 WriteStr(context, cbmsg->msg.serverInfo.srcAddress);
643 if (cbmsg->msg.serverInfo.tlvs != NULL) {
644 WriteInt(context, strlen(cbmsg->msg.serverInfo.tlvs));
645 WriteStr(context, cbmsg->msg.serverInfo.tlvs);
646 free(cbmsg->msg.serverInfo.tlvs);
647 cbmsg->msg.serverInfo.tlvs = NULL;
648 } else {
649 WriteInt(context, 0);
650 }
651 }
652 return;
653 }
654
DealP2pServerDiscReqCbk(int event,Context * context)655 static void DealP2pServerDiscReqCbk(int event, Context *context)
656 {
657 WifiHalEventCallbackMsg *cbmsg = FrontCallbackMsg(event);
658 if (cbmsg != NULL) {
659 WriteInt(context, cbmsg->msg.serDiscReqInfo.freq);
660 WriteInt(context, cbmsg->msg.serDiscReqInfo.dialogToken);
661 WriteInt(context, cbmsg->msg.serDiscReqInfo.updateIndic);
662 WriteStr(context, cbmsg->msg.serDiscReqInfo.mac);
663 if (cbmsg->msg.serDiscReqInfo.tlvs != NULL) {
664 WriteInt(context, strlen(cbmsg->msg.serDiscReqInfo.tlvs));
665 WriteStr(context, cbmsg->msg.serDiscReqInfo.tlvs);
666 free(cbmsg->msg.serDiscReqInfo.tlvs);
667 cbmsg->msg.serDiscReqInfo.tlvs = NULL;
668 } else {
669 WriteInt(context, 0);
670 }
671 }
672 return;
673 }
674
DealP2pCallback(int event,Context * context)675 static void DealP2pCallback(int event, Context *context)
676 {
677 switch (event) {
678 case WIFI_P2P_SUP_CONNECTION_EVENT:
679 case P2P_GO_NEGOTIATION_FAILURE_EVENT:
680 DealCommonCbk(event, context);
681 break;
682 case P2P_DEVICE_FOUND_EVENT:
683 DealP2pDeviceFoundCbk(event, context);
684 break;
685 case P2P_DEVICE_LOST_EVENT:
686 case P2P_GO_NEGOTIATION_REQUEST_EVENT:
687 DealP2pNegoriationCbk(event, context);
688 break;
689 case P2P_INVITATION_RECEIVED_EVENT:
690 case P2P_INVITATION_RESULT_EVENT:
691 case P2P_GROUP_FORMATION_FAILURE_EVENT:
692 DealP2pInviationCbk(event, context);
693 break;
694 case P2P_GROUP_STARTED_EVENT:
695 case P2P_GROUP_REMOVED_EVENT:
696 DealP2pGroupInfoCbk(event, context);
697 break;
698 case P2P_PROV_DISC_PBC_REQ_EVENT:
699 case P2P_PROV_DISC_PBC_RSP_EVENT:
700 case P2P_PROV_DISC_ENTER_PIN_EVENT:
701 case P2P_PROV_DISC_SHOW_PIN_EVENT:
702 case AP_STA_DISCONNECTED_EVENT:
703 case AP_STA_CONNECTED_EVENT:
704 DealP2pDeviceInfoCbk(event, context);
705 break;
706 case P2P_SERV_DISC_RESP_EVENT:
707 DealP2pServerInfoCbk(event, context);
708 break;
709 case P2P_SERV_DISC_REQ_EVENT:
710 DealP2pServerDiscReqCbk(event, context);
711 break;
712 case P2P_IFACE_CREATED_EVENT:
713 DealIfaceCbk(event, context);
714 default:
715 break;
716 }
717 return;
718 }
719
720 /* Callback request */
OnCallbackTransact(const RpcServer * server,int event,Context * context)721 int OnCallbackTransact(const RpcServer *server, int event, Context *context)
722 {
723 if (server == NULL || context == NULL) {
724 return HAL_FAILURE;
725 }
726 WriteBegin(context, 1);
727 WriteInt(context, event);
728 DealStaApCallback(event, context);
729 DealP2pCallback(event, context);
730 WriteEnd(context);
731 return HAL_SUCCESS;
732 }
733
EndCallbackTransact(const RpcServer * server,int event)734 int EndCallbackTransact(const RpcServer *server, int event)
735 {
736 if (server == NULL) {
737 return HAL_FAILURE;
738 }
739 return PopFrontCallbackMsg(event);
740 }
741