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 }
242
RemoteOnP2pThisDeviceChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)243 void WifiP2pCallbackStub::RemoteOnP2pThisDeviceChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
244 {
245 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
246 WifiP2pDevice config;
247 ReadWifiP2pDeviceData(data, config);
248 OnP2pThisDeviceChanged(config);
249 }
250
RemoteOnP2pPeersChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)251 void WifiP2pCallbackStub::RemoteOnP2pPeersChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
252 {
253 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
254 constexpr int MAX_DEVICE_SIZE = 512;
255 std::vector<WifiP2pDevice> device;
256 int size = data.ReadInt32();
257 if (size > MAX_DEVICE_SIZE) {
258 WIFI_LOGE("Peers change list size error: %{public}d", size);
259 return;
260 }
261 for (int i = 0; i < size; ++i) {
262 WifiP2pDevice config;
263 ReadWifiP2pDeviceData(data, config);
264 device.emplace_back(config);
265 }
266 OnP2pPeersChanged(device);
267 }
268
RemoteOnP2pPrivatePeersChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)269 void WifiP2pCallbackStub::RemoteOnP2pPrivatePeersChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
270 {
271 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
272
273 std::string priWfdInfo = data.ReadString();
274 OnP2pPrivatePeersChanged(priWfdInfo);
275 }
276
RemoteOnP2pServicesChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)277 void WifiP2pCallbackStub::RemoteOnP2pServicesChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
278 {
279 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
280 const char *readStr = nullptr;
281 constexpr int MAX_SIZE = 512;
282 constexpr int maxInfoSize = 100;
283 std::vector<WifiP2pServiceInfo> srvInfo;
284 int size = data.ReadInt32();
285 if (size > MAX_SIZE) {
286 WIFI_LOGE("Service change size error: %{public}d", size);
287 return;
288 }
289 for (int i = 0; i < size; ++i) {
290 WifiP2pServiceInfo info;
291 readStr = data.ReadCString();
292 info.SetServiceName((readStr != nullptr) ? readStr : "");
293 readStr = data.ReadCString();
294 info.SetDeviceAddress((readStr != nullptr) ? readStr : "");
295 info.SetServicerProtocolType(static_cast<P2pServicerProtocolType>(data.ReadInt32()));
296 int length = data.ReadInt32();
297 if (length > maxInfoSize) {
298 WIFI_LOGE("Data was incompletes. Service info length error: %{public}d", length);
299 break;
300 }
301 std::vector<std::string> queryList;
302 for (int j = 0; j < length; j++) {
303 readStr = data.ReadCString();
304 std::string queryStr = (readStr != nullptr) ? readStr : "";
305 queryList.push_back(queryStr);
306 }
307 info.SetQueryList(queryList);
308 srvInfo.emplace_back(info);
309 }
310 OnP2pServicesChanged(srvInfo);
311 }
312
RemoteOnP2pConnectionChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)313 void WifiP2pCallbackStub::RemoteOnP2pConnectionChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
314 {
315 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
316 const char *readStr = nullptr;
317 WifiP2pLinkedInfo info;
318 info.SetConnectState(static_cast<P2pConnectedState>(data.ReadInt32()));
319 info.SetIsGroupOwner(data.ReadBool());
320 readStr = data.ReadCString();
321 info.SetIsGroupOwnerAddress((readStr != nullptr) ? readStr : "");
322 OnP2pConnectionChanged(info);
323 }
324
RemoteOnP2pDiscoveryChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)325 void WifiP2pCallbackStub::RemoteOnP2pDiscoveryChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
326 {
327 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
328 bool isChange = data.ReadBool();
329 OnP2pDiscoveryChanged(isChange);
330 }
331
RemoteOnP2pActionResult(uint32_t code,MessageParcel & data,MessageParcel & reply)332 void WifiP2pCallbackStub::RemoteOnP2pActionResult(uint32_t code, MessageParcel &data, MessageParcel &reply)
333 {
334 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
335 P2pActionCallback action = static_cast<P2pActionCallback>(data.ReadInt32());
336 ErrCode errCode = static_cast<ErrCode>(data.ReadInt32());
337 OnP2pActionResult(action, errCode);
338 }
339
RemoteOnConfigChanged(uint32_t code,MessageParcel & data,MessageParcel & reply)340 void WifiP2pCallbackStub::RemoteOnConfigChanged(uint32_t code, MessageParcel &data, MessageParcel &reply)
341 {
342 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
343
344 CfgType cfgType = static_cast<CfgType>(data.ReadInt32());
345 int cfgLen = data.ReadInt32();
346 if (cfgLen <= 0) {
347 WIFI_LOGE("Config change size error: %{public}d", cfgLen);
348 return;
349 }
350
351 const char *dataBuffer = (const char *)data.ReadBuffer(cfgLen);
352 if (dataBuffer == nullptr) {
353 WIFI_LOGE("read buffer error!");
354 return;
355 }
356
357 if (cfgLen > MAX_LEN) {
358 WIFI_LOGE("cfgLen size error!");
359 return;
360 }
361 char* cfgData = new (std::nothrow) char[cfgLen];
362 if (cfgData == nullptr) {
363 WIFI_LOGE("new buffer error!");
364 return;
365 }
366 if (memcpy_s(cfgData, cfgLen, dataBuffer, cfgLen) != EOK) {
367 delete[] cfgData;
368 WIFI_LOGE("memcpy_s failed!");
369 return;
370 }
371 OnConfigChanged(cfgType, cfgData, cfgLen);
372 delete[] cfgData;
373 cfgData = nullptr;
374 }
375
RemoteOnP2pGcJoinGroup(uint32_t code,MessageParcel & data,MessageParcel & reply)376 void WifiP2pCallbackStub::RemoteOnP2pGcJoinGroup(uint32_t code, MessageParcel &data, MessageParcel &reply)
377 {
378 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
379 GcInfo info;
380 info.mac = data.ReadString();
381 info.ip = data.ReadString();
382 info.host = data.ReadString();
383 OnP2pGcJoinGroup(info);
384 }
385
RemoteOnP2pGcLeaveGroup(uint32_t code,MessageParcel & data,MessageParcel & reply)386 void WifiP2pCallbackStub::RemoteOnP2pGcLeaveGroup(uint32_t code, MessageParcel &data, MessageParcel &reply)
387 {
388 WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
389 GcInfo info;
390 info.mac = data.ReadString();
391 info.ip = data.ReadString();
392 info.host = data.ReadString();
393 OnP2pGcLeaveGroup(info);
394 }
395 } // namespace Wifi
396 } // namespace OHOS