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_p2p_callback_stub.h"
17 #include "define.h"
18 #include "wifi_manager_service_ipc_interface_code.h"
19 #include "wifi_errcode.h"
20 #include "wifi_hisysevent.h"
21 #include "wifi_logger.h"
22 #include "wifi_p2p_msg.h"
23 
24 DEFINE_WIFILOG_P2P_LABEL("WifiP2pCallbackStub");
25 namespace OHOS {
26 namespace Wifi {
WifiP2pCallbackStub()27 WifiP2pCallbackStub::WifiP2pCallbackStub() : userCallback_(nullptr), mRemoteDied(false)
28 {
29     InitHandleMap();
30 }
31 
~WifiP2pCallbackStub()32 WifiP2pCallbackStub::~WifiP2pCallbackStub()
33 {}
34 
InitHandleMap()35 void WifiP2pCallbackStub::InitHandleMap()
36 {
37     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_P2P_STATE_CHANGE)] =
38         &WifiP2pCallbackStub::RemoteOnP2pStateChanged;
39     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_PERSISTENT_GROUPS_CHANGE)] =
40         &WifiP2pCallbackStub::RemoteOnP2pPersistentGroupsChanged;
41     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_THIS_DEVICE_CHANGE)] =
42         &WifiP2pCallbackStub::RemoteOnP2pThisDeviceChanged;
43     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_PEER_CHANGE)] =
44         &WifiP2pCallbackStub::RemoteOnP2pPeersChanged;
45     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_SERVICE_CHANGE)] =
46         &WifiP2pCallbackStub::RemoteOnP2pServicesChanged;
47     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_CONNECT_CHANGE)] =
48         &WifiP2pCallbackStub::RemoteOnP2pConnectionChanged;
49     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_DISCOVERY_CHANGE)] =
50         &WifiP2pCallbackStub::RemoteOnP2pDiscoveryChanged;
51     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_P2P_ACTION_RESULT)] =
52         &WifiP2pCallbackStub::RemoteOnP2pActionResult;
53     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_CFG_CHANGE)] =
54         &WifiP2pCallbackStub::RemoteOnConfigChanged;
55     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_P2P_GC_JOIN_GROUP)] =
56         &WifiP2pCallbackStub::RemoteOnP2pGcJoinGroup;
57     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_P2P_GC_LEAVE_GROUP)] =
58         &WifiP2pCallbackStub::RemoteOnP2pGcLeaveGroup;
59     handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_CBK_CMD_PRIVATE_PEER_CHANGE)] =
60         &WifiP2pCallbackStub::RemoteOnP2pPrivatePeersChanged;
61     return;
62 }
63 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)64 int WifiP2pCallbackStub::OnRemoteRequest(
65     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
66 {
67     WIFI_LOGD("WifiP2pCallbackStub::OnRemoteRequest code:%{public}u!", code);
68 
69     if (data.ReadInterfaceToken() != GetDescriptor()) {
70         WIFI_LOGE("P2p callback stub token verification error: %{public}d", code);
71         return WIFI_OPT_FAILED;
72     }
73 
74     int exception = data.ReadInt32();
75     if (exception) {
76         WIFI_LOGD("WifiP2pCallbackStub::OnRemoteRequest exception! %{public}d!", exception);
77         return WIFI_OPT_FAILED;
78     }
79 
80     HandleFuncMap::iterator iter = handleFuncMap.find(code);
81     if (iter == handleFuncMap.end()) {
82         WIFI_LOGI("not find function to deal, code %{public}u", code);
83     } else {
84         (this->*(iter->second))(code, data, reply);
85     }
86     return 0;
87 }
88 
RegisterCallBack(const sptr<IWifiP2pCallback> & userCallback)89 void WifiP2pCallbackStub::RegisterCallBack(const sptr<IWifiP2pCallback> &userCallback)
90 {
91     if (userCallback_ != nullptr) {
92         WIFI_LOGD("Callback has registered!");
93         return;
94     }
95     userCallback_ = userCallback;
96 }
97 
IsRemoteDied() const98 bool WifiP2pCallbackStub::IsRemoteDied() const
99 {
100     return mRemoteDied;
101 }
102 
SetRemoteDied(bool val)103 void WifiP2pCallbackStub::SetRemoteDied(bool val)
104 {
105     WIFI_LOGI("WifiP2pCallbackStub::SetRemoteDied: %{public}d", val);
106     mRemoteDied = val;
107 }
108 
OnP2pStateChanged(int state)109 void WifiP2pCallbackStub::OnP2pStateChanged(int state)
110 {
111     WIFI_LOGI("WifiP2pCallbackStub::OnP2pStateChanged: %{public}d", state);
112     if (userCallback_) {
113         userCallback_->OnP2pStateChanged(state);
114     }
115     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_STATE_CHANGE, state);
116 }
117 
OnP2pPersistentGroupsChanged(void)118 void WifiP2pCallbackStub::OnP2pPersistentGroupsChanged(void)
119 {
120     WIFI_LOGI("WifiP2pCallbackStub::OnP2pPersistentGroupsChanged");
121     if (userCallback_) {
122         userCallback_->OnP2pPersistentGroupsChanged();
123     }
124     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_PERSISTENT_GROUP_CHANGE, HISYS_EVENT_DEFAULT_VALUE);
125 }
126 
OnP2pThisDeviceChanged(const WifiP2pDevice & device)127 void WifiP2pCallbackStub::OnP2pThisDeviceChanged(const WifiP2pDevice &device)
128 {
129     WIFI_LOGI("WifiP2pCallbackStub::OnP2pThisDeviceChanged");
130     if (userCallback_) {
131         userCallback_->OnP2pThisDeviceChanged(device);
132     }
133     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_DEVICE_STATE_CHANGE, HISYS_EVENT_DEFAULT_VALUE);
134 }
135 
OnP2pPeersChanged(const std::vector<WifiP2pDevice> & device)136 void WifiP2pCallbackStub::OnP2pPeersChanged(const std::vector<WifiP2pDevice> &device)
137 {
138     WIFI_LOGI("WifiP2pCallbackStub::OnP2pPeersChanged");
139     if (userCallback_) {
140         userCallback_->OnP2pPeersChanged(device);
141     }
142     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_PEER_DEVICE_CHANGE, HISYS_EVENT_DEFAULT_VALUE);
143 }
144 
OnP2pPrivatePeersChanged(const std::string & priWfdInfo)145 void WifiP2pCallbackStub::OnP2pPrivatePeersChanged(const std::string &priWfdInfo)
146 {
147     WIFI_LOGI("WifiP2pCallbackStub::OnP2pPrivatePeersChanged");
148     if (userCallback_) {
149         userCallback_->OnP2pPrivatePeersChanged(priWfdInfo);
150     }
151 }
152 
OnP2pServicesChanged(const std::vector<WifiP2pServiceInfo> & srvInfo)153 void WifiP2pCallbackStub::OnP2pServicesChanged(const std::vector<WifiP2pServiceInfo> &srvInfo)
154 {
155     WIFI_LOGI("WifiP2pCallbackStub::OnP2pServicesChanged");
156     if (userCallback_) {
157         userCallback_->OnP2pServicesChanged(srvInfo);
158     }
159 }
160 
OnP2pConnectionChanged(const WifiP2pLinkedInfo & info)161 void WifiP2pCallbackStub::OnP2pConnectionChanged(const WifiP2pLinkedInfo &info)
162 {
163     WIFI_LOGI("WifiP2pCallbackStub::OnP2pConnectionChanged: %{public}d", static_cast<int>(info.GetConnectState()));
164     if (userCallback_) {
165         userCallback_->OnP2pConnectionChanged(info);
166     }
167     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_CONN_STATE_CHANGE, static_cast<int>(info.GetConnectState()));
168 }
169 
OnP2pDiscoveryChanged(bool isChange)170 void WifiP2pCallbackStub::OnP2pDiscoveryChanged(bool isChange)
171 {
172     WIFI_LOGI("WifiP2pCallbackStub::OnP2pDiscoveryChanged, isChange:%{public}d", isChange);
173     if (userCallback_) {
174         userCallback_->OnP2pDiscoveryChanged(isChange);
175     }
176     WriteWifiEventReceivedHiSysEvent(HISYS_P2P_DISCOVERY_CHANGE, isChange);
177 }
178 
OnP2pActionResult(P2pActionCallback action,ErrCode code)179 void WifiP2pCallbackStub::OnP2pActionResult(P2pActionCallback action, ErrCode code)
180 {
181     WIFI_LOGI("WifiP2pCallbackStub::OnP2pActionResult");
182     if (userCallback_) {
183         userCallback_->OnP2pActionResult(action, code);
184     }
185 }
186 
OnConfigChanged(CfgType type,char * data,int dataLen)187 void WifiP2pCallbackStub::OnConfigChanged(CfgType type, char* data, int dataLen)
188 {
189     WIFI_LOGI("WifiP2pCallbackStub::OnConfigChanged");
190     if (userCallback_) {
191         userCallback_->OnConfigChanged(type, data, dataLen);
192     }
193 }
194 
OnP2pGcJoinGroup(const OHOS::Wifi::GcInfo & info)195 void WifiP2pCallbackStub::OnP2pGcJoinGroup(const OHOS::Wifi::GcInfo &info)
196 {
197     WIFI_LOGD("WifiP2pCallbackStub::OnP2pGcJoinGroup");
198     if (userCallback_) {
199         userCallback_->OnP2pGcJoinGroup(info);
200     }
201 }
202 
OnP2pGcLeaveGroup(const OHOS::Wifi::GcInfo & info)203 void WifiP2pCallbackStub::OnP2pGcLeaveGroup(const OHOS::Wifi::GcInfo &info)
204 {
205     WIFI_LOGD("WifiP2pCallbackStub::OnP2pGcLeaveGroup");
206     if (userCallback_) {
207         userCallback_->OnP2pGcLeaveGroup(info);
208     }
209 }
210 
RemoteOnP2pStateChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)211 void WifiP2pCallbackStub::RemoteOnP2pStateChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
212 {
213     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
214     int state = data.ReadInt32();
215     OnP2pStateChanged(state);
216 }
217 
RemoteOnP2pPersistentGroupsChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)218 void WifiP2pCallbackStub::RemoteOnP2pPersistentGroupsChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
219 {
220     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
221     OnP2pPersistentGroupsChanged();
222 }
223 
ReadWifiP2pDeviceData(MessageParcel & data,WifiP2pDevice & device)224 void WifiP2pCallbackStub::ReadWifiP2pDeviceData(MessageParcel &data, WifiP2pDevice &device)
225 {
226     device.SetDeviceName(data.ReadString());
227     device.SetDeviceAddress(data.ReadString());
228     device.SetDeviceAddressType(data.ReadInt32());
229     device.SetPrimaryDeviceType(data.ReadString());
230     device.SetSecondaryDeviceType(data.ReadString());
231     device.SetP2pDeviceStatus(static_cast<P2pDeviceStatus>(data.ReadInt32()));
232     WifiP2pWfdInfo wfdInfo;
233     wfdInfo.SetWfdEnabled(data.ReadBool());
234     wfdInfo.SetDeviceInfo(data.ReadInt32());
235     wfdInfo.SetCtrlPort(data.ReadInt32());
236     wfdInfo.SetMaxThroughput(data.ReadInt32());
237     device.SetWfdInfo(wfdInfo);
238     device.SetWpsConfigMethod(data.ReadInt32());
239     device.SetDeviceCapabilitys(data.ReadInt32());
240     device.SetGroupCapabilitys(data.ReadInt32());
241     device.SetChrErrCode(static_cast<P2pChrEvent>(data.ReadInt32()));
242 }
243 
RemoteOnP2pThisDeviceChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)244 void WifiP2pCallbackStub::RemoteOnP2pThisDeviceChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
245 {
246     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
247     WifiP2pDevice config;
248     ReadWifiP2pDeviceData(data, config);
249     OnP2pThisDeviceChanged(config);
250 }
251 
RemoteOnP2pPeersChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)252 void WifiP2pCallbackStub::RemoteOnP2pPeersChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
253 {
254     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
255     constexpr int MAX_DEVICE_SIZE = 512;
256     std::vector<WifiP2pDevice> device;
257     int size = data.ReadInt32();
258     if (size > MAX_DEVICE_SIZE) {
259         WIFI_LOGE("Peers change list size error: %{public}d", size);
260         return;
261     }
262     for (int i = 0; i < size; ++i) {
263         WifiP2pDevice config;
264         ReadWifiP2pDeviceData(data, config);
265         device.emplace_back(config);
266     }
267     OnP2pPeersChanged(device);
268 }
269 
RemoteOnP2pPrivatePeersChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)270 void WifiP2pCallbackStub::RemoteOnP2pPrivatePeersChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
271 {
272     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
273 
274     std::string priWfdInfo = data.ReadString();
275     OnP2pPrivatePeersChanged(priWfdInfo);
276 }
277 
RemoteOnP2pServicesChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)278 void WifiP2pCallbackStub::RemoteOnP2pServicesChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
279 {
280     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
281     const char *readStr = nullptr;
282     constexpr int MAX_SIZE = 512;
283     constexpr int maxInfoSize = 100;
284     std::vector<WifiP2pServiceInfo> srvInfo;
285     int size = data.ReadInt32();
286     if (size > MAX_SIZE) {
287         WIFI_LOGE("Service change size error: %{public}d", size);
288         return;
289     }
290     for (int i = 0; i < size; ++i) {
291         WifiP2pServiceInfo info;
292         readStr = data.ReadCString();
293         info.SetServiceName((readStr != nullptr) ? readStr : "");
294         readStr = data.ReadCString();
295         info.SetDeviceAddress((readStr != nullptr) ? readStr : "");
296         info.SetServicerProtocolType(static_cast<P2pServicerProtocolType>(data.ReadInt32()));
297         int length = data.ReadInt32();
298         if (length > maxInfoSize) {
299             WIFI_LOGE("Data was incompletes. Service info length error: %{public}d", length);
300             break;
301         }
302         std::vector<std::string> queryList;
303         for (int j = 0; j < length; j++) {
304             readStr = data.ReadCString();
305             std::string queryStr = (readStr != nullptr) ? readStr : "";
306             queryList.push_back(queryStr);
307         }
308         info.SetQueryList(queryList);
309         srvInfo.emplace_back(info);
310     }
311     OnP2pServicesChanged(srvInfo);
312 }
313 
RemoteOnP2pConnectionChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)314 void WifiP2pCallbackStub::RemoteOnP2pConnectionChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
315 {
316     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
317     const char *readStr = nullptr;
318     WifiP2pLinkedInfo info;
319     info.SetConnectState(static_cast<P2pConnectedState>(data.ReadInt32()));
320     info.SetIsGroupOwner(data.ReadBool());
321     readStr = data.ReadCString();
322     info.SetIsGroupOwnerAddress((readStr != nullptr) ? readStr : "");
323     OnP2pConnectionChanged(info);
324 }
325 
RemoteOnP2pDiscoveryChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)326 void WifiP2pCallbackStub::RemoteOnP2pDiscoveryChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
327 {
328     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
329     bool isChange = data.ReadBool();
330     OnP2pDiscoveryChanged(isChange);
331 }
332 
RemoteOnP2pActionResult(uint32_t code,MessageParcel & data,MessageParcel & reply)333 void WifiP2pCallbackStub::RemoteOnP2pActionResult(uint32_t code, MessageParcel &data, MessageParcel &reply)
334 {
335     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
336     P2pActionCallback action = static_cast<P2pActionCallback>(data.ReadInt32());
337     ErrCode errCode = static_cast<ErrCode>(data.ReadInt32());
338     OnP2pActionResult(action, errCode);
339 }
340 
RemoteOnConfigChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)341 void WifiP2pCallbackStub::RemoteOnConfigChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
342 {
343     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
344 
345     CfgType cfgType = static_cast<CfgType>(data.ReadInt32());
346     int cfgLen = data.ReadInt32();
347     if (cfgLen <= 0) {
348         WIFI_LOGE("Config change size error: %{public}d", cfgLen);
349         return;
350     }
351 
352     const char *dataBuffer = (const char *)data.ReadBuffer(cfgLen);
353     if (dataBuffer == nullptr) {
354         WIFI_LOGE("read buffer error!");
355         return;
356     }
357 
358     if (cfgLen > MAX_LEN) {
359         WIFI_LOGE("cfgLen size error!");
360         return;
361     }
362     char* cfgData = new (std::nothrow) char[cfgLen];
363     if (cfgData == nullptr) {
364         WIFI_LOGE("new buffer error!");
365         return;
366     }
367     if (memcpy_s(cfgData, cfgLen, dataBuffer, cfgLen) != EOK) {
368         delete[] cfgData;
369         WIFI_LOGE("memcpy_s failed!");
370         return;
371     }
372     OnConfigChanged(cfgType, cfgData, cfgLen);
373     delete[] cfgData;
374     cfgData = nullptr;
375 }
376 
RemoteOnP2pGcJoinGroup(uint32_t code,MessageParcel & data,MessageParcel & reply)377 void WifiP2pCallbackStub::RemoteOnP2pGcJoinGroup(uint32_t code, MessageParcel &data, MessageParcel &reply)
378 {
379     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
380     GcInfo info;
381     info.mac = data.ReadString();
382     info.ip = data.ReadString();
383     info.host = data.ReadString();
384     OnP2pGcJoinGroup(info);
385 }
386 
RemoteOnP2pGcLeaveGroup(uint32_t code,MessageParcel & data,MessageParcel & reply)387 void WifiP2pCallbackStub::RemoteOnP2pGcLeaveGroup(uint32_t code, MessageParcel &data, MessageParcel &reply)
388 {
389     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
390     GcInfo info;
391     info.mac = data.ReadString();
392     info.ip = data.ReadString();
393     info.host = data.ReadString();
394     OnP2pGcLeaveGroup(info);
395 }
396 }  // namespace Wifi
397 }  // namespace OHOS