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