1 /*
2 * Copyright (C) 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 #include "wifi_device_callback_stub_lite.h"
16 #include "define.h"
17 #include "wifi_manager_service_ipc_interface_code.h"
18 #include "wifi_logger.h"
19 #include "wifi_msg.h"
20 #include "wifi_errcode.h"
21 #include "wifi_common_util.h"
22
23 DEFINE_WIFILOG_LABEL("WifiDeviceCallBackStub");
24 namespace OHOS {
25 namespace Wifi {
WifiDeviceCallBackStub()26 WifiDeviceCallBackStub::WifiDeviceCallBackStub() : callback_(nullptr), mRemoteDied(false)
27 {}
28
~WifiDeviceCallBackStub()29 WifiDeviceCallBackStub::~WifiDeviceCallBackStub()
30 {}
31
OnRemoteInterfaceToken(uint32_t code,IpcIo * data)32 int WifiDeviceCallBackStub::OnRemoteInterfaceToken(uint32_t code, IpcIo *data)
33 {
34 size_t length;
35 uint16_t* interfaceRead = nullptr;
36 interfaceRead = ReadInterfaceToken(data, &length);
37 for (size_t i = 0; i < length; i++) {
38 if (i >= DECLARE_INTERFACE_DESCRIPTOR_L1_LENGTH || interfaceRead[i] != DECLARE_INTERFACE_DESCRIPTOR_L1[i]) {
39 WIFI_LOGE("Sta stub token verification error: %{public}d", code);
40 return WIFI_OPT_FAILED;
41 }
42 }
43 return WIFI_OPT_SUCCESS;
44 }
45
OnRemoteRequest(uint32_t code,IpcIo * data)46 int WifiDeviceCallBackStub::OnRemoteRequest(uint32_t code, IpcIo *data)
47 {
48 int ret = WIFI_OPT_FAILED;
49 WIFI_LOGD("OnRemoteRequest code:%{public}u!", code);
50 if (mRemoteDied || data == nullptr) {
51 WIFI_LOGE("Failed to %{public}s,mRemoteDied:%{public}d data:%{public}d!",
52 __func__, mRemoteDied, data == nullptr);
53 return ret;
54 }
55
56 if (OnRemoteInterfaceToken(code, data) == WIFI_OPT_FAILED) {
57 return WIFI_OPT_FAILED;
58 }
59 int exception = WIFI_OPT_FAILED;
60 (void)ReadInt32(data, &exception);
61 if (exception) {
62 WIFI_LOGE("WifiDeviceCallBackStub::OnRemoteRequest, got exception: %{public}d!", exception);
63 return ret;
64 }
65 switch (code) {
66 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_STATE_CHANGE): {
67 ret = RemoteOnWifiStateChanged(code, data);
68 break;
69 }
70 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_CONNECTION_CHANGE): {
71 ret = RemoteOnWifiConnectionChanged(code, data);
72 break;
73 }
74 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_RSSI_CHANGE): {
75 ret = RemoteOnWifiRssiChanged(code, data);
76 break;
77 }
78 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_WPS_STATE_CHANGE): {
79 ret = RemoteOnWifiWpsStateChanged(code, data);
80 break;
81 }
82 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_STREAM_DIRECTION): {
83 ret = RemoteOnStreamChanged(code, data);
84 break;
85 }
86 case static_cast<uint32_t>(DevInterfaceCode::WIFI_CBK_CMD_DEVICE_CONFIG_CHANGE): {
87 ret = RemoteOnDeviceConfigChanged(code, data);
88 break;
89 }
90 default: {
91 ret = WIFI_OPT_FAILED;
92 }
93 }
94 return ret;
95 }
96
RegisterUserCallBack(const std::shared_ptr<IWifiDeviceCallBack> & callBack)97 void WifiDeviceCallBackStub::RegisterUserCallBack(const std::shared_ptr<IWifiDeviceCallBack> &callBack)
98 {
99 if (callBack == nullptr) {
100 WIFI_LOGE("RegisterUserCallBack:callBack is nullptr!");
101 return;
102 }
103 callback_ = callBack;
104 }
105
IsRemoteDied() const106 bool WifiDeviceCallBackStub::IsRemoteDied() const
107 {
108 return mRemoteDied;
109 }
110
SetRemoteDied(bool val)111 void WifiDeviceCallBackStub::SetRemoteDied(bool val)
112 {
113 mRemoteDied = val;
114 }
115
OnWifiStateChanged(int state)116 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnWifiStateChanged(int state)
117 {
118 WIFI_LOGD("WifiDeviceCallBackStub::OnWifiStateChanged");
119
120 if (callback_) {
121 callback_->OnWifiStateChanged(state);
122 }
123 }
124
OnWifiConnectionChanged(int state,const WifiLinkedInfo & info)125 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnWifiConnectionChanged(int state, const WifiLinkedInfo &info)
126 {
127 WIFI_LOGD("WifiDeviceCallBackStub::OnWifiConnectionChanged");
128 if (callback_) {
129 callback_->OnWifiConnectionChanged(state, info);
130 }
131 }
132
OnWifiRssiChanged(int rssi)133 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnWifiRssiChanged(int rssi)
134 {
135 WIFI_LOGD("WifiDeviceCallBackStub::OnWifiRssiChanged");
136 if (callback_) {
137 callback_->OnWifiRssiChanged(rssi);
138 }
139 }
140
OnWifiWpsStateChanged(int state,const std::string & pinCode)141 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnWifiWpsStateChanged(int state, const std::string &pinCode)
142 {
143 WIFI_LOGD("WifiDeviceCallBackStub::OnWifiWpsStateChanged");
144 if (callback_) {
145 callback_->OnWifiWpsStateChanged(state, pinCode);
146 }
147 }
148
OnStreamChanged(int direction)149 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnStreamChanged(int direction)
150 {
151 WIFI_LOGD("WifiDeviceCallBackStub::OnStreamChanged");
152 if (callback_) {
153 callback_->OnStreamChanged(direction);
154 }
155 }
156
OnDeviceConfigChanged(ConfigChange state)157 NO_SANITIZE("cfi") void WifiDeviceCallBackStub::OnDeviceConfigChanged(ConfigChange state)
158 {
159 WIFI_LOGD("WifiDeviceCallBackStub::OnDeviceConfigChanged");
160 if (callback_) {
161 callback_->OnDeviceConfigChanged(state);
162 }
163 }
164
RemoteOnWifiStateChanged(uint32_t code,IpcIo * data)165 int WifiDeviceCallBackStub::RemoteOnWifiStateChanged(uint32_t code, IpcIo *data)
166 {
167 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
168 int state = 0;
169 (void)ReadInt32(data, &state);
170 OnWifiStateChanged(state);
171 return 0;
172 }
173
RemoteOnWifiConnectionChanged(uint32_t code,IpcIo * data)174 int WifiDeviceCallBackStub::RemoteOnWifiConnectionChanged(uint32_t code, IpcIo *data)
175 {
176 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
177 size_t readLen;
178 int state = 0;
179 (void)ReadInt32(data, &state);
180 WifiLinkedInfo info;
181 (void)ReadInt32(data, &info.networkId);
182 info.ssid = (char *)ReadString(data, &readLen);
183 info.bssid = (char *)ReadString(data, &readLen);
184 (void)ReadInt32(data, &info.rssi);
185 (void)ReadInt32(data, &info.band);
186 (void)ReadInt32(data, &info.frequency);
187 (void)ReadInt32(data, &info.linkSpeed);
188 info.macAddress = (char *)ReadString(data, &readLen);
189 (void)ReadUint32(data, &info.ipAddress);
190 int tmpConnState = 0;
191 (void)ReadInt32(data, &tmpConnState);
192 if (tmpConnState >= 0 && tmpConnState <= int(ConnState::UNKNOWN)) {
193 info.connState = ConnState(tmpConnState);
194 } else {
195 info.connState = ConnState::UNKNOWN;
196 }
197 (void)ReadBool(data, &info.ifHiddenSSID);
198 (void)ReadInt32(data, &info.rxLinkSpeed);
199 (void)ReadInt32(data, &info.txLinkSpeed);
200 (void)ReadInt32(data, &info.chload);
201 (void)ReadInt32(data, &info.snr);
202 (void)ReadInt32(data, &info.isDataRestricted);
203 info.portalUrl = (char *)ReadString(data, &readLen);
204 int tmpState = 0;
205 (void)ReadInt32(data, &tmpState);
206 if (tmpState >= 0 && tmpState <= int(SupplicantState::INVALID)) {
207 info.supplicantState = SupplicantState(tmpState);
208 } else {
209 info.supplicantState = SupplicantState::INVALID;
210 }
211
212 int tmpDetailState = 0;
213 (void)ReadInt32(data, &tmpDetailState);
214 if (tmpDetailState >= 0 && tmpDetailState <= int(DetailedState::INVALID)) {
215 info.detailedState = DetailedState(tmpDetailState);
216 } else {
217 info.detailedState = DetailedState::INVALID;
218 }
219 OnWifiConnectionChanged(state, info);
220 return 0;
221 }
222
RemoteOnWifiRssiChanged(uint32_t code,IpcIo * data)223 int WifiDeviceCallBackStub::RemoteOnWifiRssiChanged(uint32_t code, IpcIo *data)
224 {
225 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
226 int rssi = 0;
227 (void)ReadInt32(data, &rssi);
228 OnWifiRssiChanged(rssi);
229 return 0;
230 }
231
RemoteOnWifiWpsStateChanged(uint32_t code,IpcIo * data)232 int WifiDeviceCallBackStub::RemoteOnWifiWpsStateChanged(uint32_t code, IpcIo *data)
233 {
234 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
235 size_t readLen;
236 int state = 0;
237 (void)ReadInt32(data, &state);
238 std::string pinCode = (char *)ReadString(data, &readLen);
239 OnWifiWpsStateChanged(state, pinCode);
240 return 0;
241 }
242
RemoteOnStreamChanged(uint32_t code,IpcIo * data)243 int WifiDeviceCallBackStub::RemoteOnStreamChanged(uint32_t code, IpcIo *data)
244 {
245 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
246 int direction = 0;
247 (void)ReadInt32(data, &direction);
248 OnStreamChanged(direction);
249 return 0;
250 }
251
RemoteOnDeviceConfigChanged(uint32_t code,IpcIo * data)252 int WifiDeviceCallBackStub::RemoteOnDeviceConfigChanged(uint32_t code, IpcIo *data)
253 {
254 WIFI_LOGD("run %{public}s code %{public}u", __func__, code);
255 int state = 0;
256 (void)ReadInt32(data, &state);
257 OnDeviceConfigChanged(ConfigChange(state));
258 return 0;
259 }
260 } // namespace Wifi
261 } // namespace OHOS
262