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_device_stub.h"
17 #include "string_ex.h"
18 #include "wifi_logger.h"
19 #include "wifi_msg.h"
20 #include "wifi_device_callback_proxy.h"
21 #include "wifi_internal_event_dispatcher.h"
22 #include "wifi_device_death_recipient.h"
23 #include "wifi_common_util.h"
24 #include "wifi_common_def.h"
25 #include "wifi_manager_service_ipc_interface_code.h"
26 #include "wifi_watchdog_utils.h"
27 
28 DEFINE_WIFILOG_LABEL("WifiDeviceStub");
29 
30 namespace OHOS {
31 namespace Wifi {
32 constexpr int MAX_ASHMEM_SIZE = 300;
33 static std::map<int, std::string> g_HicollieStaMap = {
34     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_CONNECTED), "WIFI_SVR_CMD_IS_WIFI_CONNECTED"},
35     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_ACTIVE), "WIFI_SVR_CMD_IS_WIFI_ACTIVE"},
36     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_METERED_HOTSPOT), "WIFI_SVR_CMD_IS_METERED_HOTSPOT"},
37     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REGISTER_CALLBACK_CLIENT),
38         "WIFI_SVR_CMD_REGISTER_CALLBACK_CLIENT"},
39     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_SIGNAL_LEVEL), "WIFI_SVR_CMD_GET_SIGNAL_LEVEL"},
40     {static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_DETAIL_STATE), "WIFI_SVR_CMD_GET_WIFI_DETAIL_STATE"},
41 };
42 
WifiDeviceStub()43 WifiDeviceStub::WifiDeviceStub() : mSingleCallback(false)
44 {
45     WIFI_LOGI("enter WifiDeviceStub!");
46     InitHandleMap();
47     deathRecipient_ = nullptr;
48 }
49 
WifiDeviceStub(int instId)50 WifiDeviceStub::WifiDeviceStub(int instId) : mSingleCallback(false), m_instId(instId)
51 {
52     WIFI_LOGI("enter WifiDeviceStub!");
53     InitHandleMap();
54     deathRecipient_ = nullptr;
55 }
56 
~WifiDeviceStub()57 WifiDeviceStub::~WifiDeviceStub()
58 {
59     WIFI_LOGI("enter ~WifiDeviceStub!");
60     deathRecipient_ = nullptr;
61 }
62 
InitHandleMapEx()63 void WifiDeviceStub::InitHandleMapEx()
64 {
65     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_SIGNAL_LEVEL)] = [this](uint32_t code,
66         MessageParcel &data, MessageParcel &reply) { OnGetSignalLevel(code, data, reply); };
67     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_SUPPORTED_FEATURES)] = [this](uint32_t code,
68         MessageParcel &data, MessageParcel &reply) { OnGetSupportedFeatures(code, data, reply); };
69     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DHCP_IPV6INFO)] = [this](uint32_t code,
70         MessageParcel &data, MessageParcel &reply) { OnGetIpV6Info(code, data, reply); };
71     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DERVICE_MAC_ADD)] = [this](uint32_t code,
72         MessageParcel &data, MessageParcel &reply) { OnGetDeviceMacAdd(code, data, reply); };
73     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_CONNECTED)] = [this](uint32_t code,
74         MessageParcel &data, MessageParcel &reply) { OnIsWifiConnected(code, data, reply); };
75     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_LOW_LATENCY_MODE)] = [this](uint32_t code,
76         MessageParcel &data, MessageParcel &reply) { OnSetLowLatencyMode(code, data, reply); };
77     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_CANDIDATE_CONFIG)] = [this](uint32_t code,
78         MessageParcel &data, MessageParcel &reply) { OnRemoveCandidateConfig(code, data, reply); };
79     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_BANDTYPE_SUPPORTED)] = [this](uint32_t code,
80         MessageParcel &data, MessageParcel &reply) { OnIsBandTypeSupported(code, data, reply); };
81     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_5G_CHANNELLIST)] = [this](uint32_t code,
82         MessageParcel &data, MessageParcel &reply) { OnGet5GHzChannelList(code, data, reply); };
83     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DISCONNECTED_REASON)] = [this](uint32_t code,
84         MessageParcel &data, MessageParcel &reply) { OnGetDisconnectedReason(code, data, reply); };
85     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_FROZEN_APP)] = [this](uint32_t code,
86         MessageParcel &data, MessageParcel &reply) { OnSetFrozenApp(code, data, reply); };
87     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_RESET_ALL_FROZEN_APP)] = [this](uint32_t code,
88         MessageParcel &data, MessageParcel &reply) { OnResetAllFrozenApp(code, data, reply); };
89     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN)] = [this](uint32_t code,
90         MessageParcel &data, MessageParcel &reply) { OnDisableAutoJoin(code, data, reply); };
91     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_AUTO_JOIN)] = [this](uint32_t code,
92         MessageParcel &data, MessageParcel &reply) { OnEnableAutoJoin(code, data, reply); };
93     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_PORTAL_CERTIF)] = [this](uint32_t code,
94         MessageParcel &data, MessageParcel &reply) { OnStartPortalCertification(code, data, reply); };
95     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIG_CHANGE)] = [this](
96         uint32_t code, MessageParcel &data, MessageParcel &reply) { OnGetChangeDeviceConfig(code, data, reply); };
97     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_SET_FACTORY_RESET)] = [this](uint32_t code,
98         MessageParcel &data, MessageParcel &reply) { OnFactoryReset(code, data, reply); };
99     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_LIMIT_SPEED)] = [this](uint32_t code,
100         MessageParcel &data, MessageParcel &reply) { OnLimitSpeed(code, data, reply); };
101     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_HILINK_CONNECT)] = [this](uint32_t code,
102         MessageParcel &data, MessageParcel &reply) { OnEnableHiLinkHandshake(code, data, reply); };
103     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_SEMI_WIFI)] = [this](uint32_t code,
104         MessageParcel &data, MessageParcel &reply) { OnEnableSemiWifi(code, data, reply); };
105     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_DETAIL_STATE)] = [this](uint32_t code,
106         MessageParcel &data, MessageParcel &reply) { OnGetWifiDetailState(code, data, reply); };
107     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_SATELLITE_STATE)] = [this](uint32_t code,
108         MessageParcel &data, MessageParcel &reply) { OnSetSatelliteState(code, data, reply); };
109     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_LOW_TX_POWER)] = [this](uint32_t code,
110         MessageParcel &data, MessageParcel &reply) { OnSetLowTxPower(code, data, reply); };
111     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_TX_POWER)] = [this](uint32_t code,
112         MessageParcel &data, MessageParcel &reply) { OnSetTxPower(code, data, reply); };
113     return;
114 }
115 
InitHandleMapEx2()116 void WifiDeviceStub::InitHandleMapEx2()
117 {
118     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_ROAM_TO_NETWORK)] = [this](uint32_t code,
119         MessageParcel &data, MessageParcel &reply) { OnStartRoamToNetwork(code, data, reply); };
120     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_CONNECT_TO_USER_SELECT_NETWORK)] =
121         [this](uint32_t code, MessageParcel &data, MessageParcel &reply) {
122             OnStartConnectToUserSelectNetwork(code, data, reply);
123         };
124     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIG)] = [this](uint32_t code,
125         MessageParcel &data, MessageParcel &reply) { OnGetDeviceConfig(code, data, reply); };
126     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_DPI_MARK_RULE)] = [this](uint32_t code,
127         MessageParcel &data, MessageParcel &reply) { OnSetDpiMarkRule(code, data, reply); };
128 }
129 
InitHandleMap()130 void WifiDeviceStub::InitHandleMap()
131 {
132     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_WIFI)] = [this](uint32_t code,
133         MessageParcel &data, MessageParcel &reply) { OnEnableWifi(code, data, reply); };
134     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_WIFI)] = [this](uint32_t code,
135         MessageParcel &data, MessageParcel &reply) { OnDisableWifi(code, data, reply); };
136     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_INIT_WIFI_PROTECT)] = [this](uint32_t code,
137         MessageParcel &data, MessageParcel &reply) { OnInitWifiProtect(code, data, reply); };
138     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_PROTECT)] = [this](uint32_t code,
139         MessageParcel &data, MessageParcel &reply) { OnGetWifiProtectRef(code, data, reply); };
140     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_PUT_WIFI_PROTECT)] = [this](uint32_t code,
141         MessageParcel &data, MessageParcel &reply) { OnPutWifiProtectRef(code, data, reply); };
142     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_HELD_WIFI_PROTECT)] = [this](uint32_t code,
143         MessageParcel &data, MessageParcel &reply) { OnIsHeldWifiProtectRef(code, data, reply); };
144     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ADD_DEVICE_CONFIG)] = [this](uint32_t code,
145         MessageParcel &data, MessageParcel &reply) { OnAddDeviceConfig(code, data, reply); };
146     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_UPDATE_DEVICE_CONFIG)] = [this](uint32_t code,
147         MessageParcel &data, MessageParcel &reply) { OnUpdateDeviceConfig(code, data, reply); };
148     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_DEVICE_CONFIG)] = [this](uint32_t code,
149         MessageParcel &data, MessageParcel &reply) { OnRemoveDevice(code, data, reply); };
150     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_ALL_DEVICE_CONFIG)] =
151         [this](uint32_t code, MessageParcel &data, MessageParcel &reply) { OnRemoveAllDevice(code, data, reply); };
152     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIGS)] = [this](uint32_t code,
153         MessageParcel &data, MessageParcel &reply) { OnGetDeviceConfigs(code, data, reply); };
154     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_DEVICE)] = [this](uint32_t code,
155         MessageParcel &data, MessageParcel &reply) { OnEnableDeviceConfig(code, data, reply); };
156     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_DEVICE)] = [this](uint32_t code,
157         MessageParcel &data, MessageParcel &reply) { OnDisableDeviceConfig(code, data, reply); };
158     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CONNECT_TO)] = [this](uint32_t code,
159         MessageParcel &data, MessageParcel &reply) { OnConnectTo(code, data, reply); };
160     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CONNECT2_TO)] = [this](uint32_t code,
161         MessageParcel &data, MessageParcel &reply) { OnConnect2To(code, data, reply); };
162     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_RECONNECT)] = [this](uint32_t code,
163         MessageParcel &data, MessageParcel &reply) { OnReConnect(code, data, reply); };
164     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REASSOCIATE)] = [this](uint32_t code,
165         MessageParcel &data, MessageParcel &reply) { OnReAssociate(code, data, reply); };
166     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISCONNECT)] = [this](uint32_t code,
167         MessageParcel &data, MessageParcel &reply) { OnDisconnect(code, data, reply); };
168     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_WPS)] = [this](uint32_t code,
169         MessageParcel &data, MessageParcel &reply) { OnStartWps(code, data, reply); };
170     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CANCEL_WPS)] = [this](uint32_t code,
171         MessageParcel &data, MessageParcel &reply) { OnCancelWps(code, data, reply); };
172     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_ACTIVE)] = [this](uint32_t code,
173         MessageParcel &data, MessageParcel &reply) { OnIsWifiActive(code, data, reply); };
174     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_STATE)] = [this](uint32_t code,
175         MessageParcel &data, MessageParcel &reply) { OnGetWifiState(code, data, reply); };
176     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_METERED_HOTSPOT)] = [this](uint32_t code,
177         MessageParcel &data, MessageParcel &reply) { OnIsMeteredHotspot(code, data, reply); };
178     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_LINKED_INFO)] = [this](uint32_t code,
179         MessageParcel &data, MessageParcel &reply) { OnGetLinkedInfo(code, data, reply); };
180     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DHCP_INFO)] = [this](uint32_t code,
181         MessageParcel &data, MessageParcel &reply) { OnGetIpInfo(code, data, reply); };
182     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_COUNTRY_CODE)] = [this](uint32_t code,
183         MessageParcel &data, MessageParcel &reply) { OnSetCountryCode(code, data, reply); };
184     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_COUNTRY_CODE)] = [this](uint32_t code,
185         MessageParcel &data, MessageParcel &reply) { OnGetCountryCode(code, data, reply); };
186     handleFuncMap[static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REGISTER_CALLBACK_CLIENT)] =
187         [this](uint32_t code, MessageParcel &data, MessageParcel &reply) { OnRegisterCallBack(code, data, reply); };
188     InitHandleMapEx();
189     InitHandleMapEx2();
190     return;
191 }
192 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)193 int WifiDeviceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
194 {
195     if (data.ReadInterfaceToken() != GetDescriptor()) {
196         WIFI_LOGE("Sta stub token verification error: %{public}d", code);
197         return WIFI_OPT_FAILED;
198     }
199 
200     WIFI_LOGD("%{public}s, code: %{public}u, uid: %{public}d, pid: %{public}d",
201         __func__, code, GetCallingUid(), GetCallingPid());
202     HandleFuncMap::iterator iter = handleFuncMap.find(code);
203     if (iter == handleFuncMap.end()) {
204         WIFI_LOGI("not find function to deal, code %{public}u", code);
205         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
206     } else {
207         int exception = data.ReadInt32();
208         if (exception) {
209             return WIFI_OPT_FAILED;
210         }
211         std::map<int, std::string>::const_iterator itCollieId = g_HicollieStaMap.find(code);
212         if (itCollieId != g_HicollieStaMap.end()) {
213             int idTimer = 0;
214             idTimer = WifiWatchDogUtils::GetInstance()->StartWatchDogForFunc(itCollieId->second);
215             WIFI_LOGI("SetTimer id: %{public}d, name: %{public}s.", idTimer, itCollieId->second.c_str());
216             (iter->second)(code, data, reply);
217             WifiWatchDogUtils::GetInstance()->StopWatchDogForFunc(itCollieId->second, idTimer);
218         } else {
219             (iter->second)(code, data, reply);
220         }
221     }
222     return 0;
223 }
224 
OnEnableWifi(uint32_t code,MessageParcel & data,MessageParcel & reply)225 void WifiDeviceStub::OnEnableWifi(uint32_t code, MessageParcel &data, MessageParcel &reply)
226 {
227     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
228     ErrCode ret = EnableWifi();
229     reply.WriteInt32(0);
230     reply.WriteInt32(ret);
231 
232     return;
233 }
234 
OnDisableWifi(uint32_t code,MessageParcel & data,MessageParcel & reply)235 void WifiDeviceStub::OnDisableWifi(uint32_t code, MessageParcel &data, MessageParcel &reply)
236 {
237     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
238     ErrCode ret = DisableWifi();
239     reply.WriteInt32(0);
240     reply.WriteInt32(ret);
241     return;
242 }
243 
OnInitWifiProtect(uint32_t code,MessageParcel & data,MessageParcel & reply)244 void WifiDeviceStub::OnInitWifiProtect(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     ErrCode ret = WIFI_OPT_FAILED;
248     WifiProtectType protectType = (WifiProtectType)data.ReadInt32();
249     const char *readStr = data.ReadCString();
250     if (readStr == nullptr) {
251         ret = WIFI_OPT_INVALID_PARAM;
252     } else {
253         std::string protectName = readStr;
254         ret = InitWifiProtect(protectType, protectName);
255     }
256     reply.WriteInt32(0);
257     reply.WriteInt32(ret);
258     return;
259 }
260 
OnGetWifiProtectRef(uint32_t code,MessageParcel & data,MessageParcel & reply)261 void WifiDeviceStub::OnGetWifiProtectRef(uint32_t code, MessageParcel &data, MessageParcel &reply)
262 {
263     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
264     ErrCode ret = WIFI_OPT_FAILED;
265     WifiProtectMode protectMode = (WifiProtectMode)data.ReadInt32();
266     const char *readStr = data.ReadCString();
267     if (readStr == nullptr) {
268         ret = WIFI_OPT_INVALID_PARAM;
269     } else {
270         std::string protectName = readStr;
271         ret = GetWifiProtectRef(protectMode, protectName);
272     }
273     reply.WriteInt32(0);
274     reply.WriteInt32(ret);
275     return;
276 }
277 
OnPutWifiProtectRef(uint32_t code,MessageParcel & data,MessageParcel & reply)278 void WifiDeviceStub::OnPutWifiProtectRef(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     ErrCode ret = WIFI_OPT_FAILED;
282     const char *readStr = data.ReadCString();
283     if (readStr == nullptr) {
284         ret = WIFI_OPT_INVALID_PARAM;
285     } else {
286         std::string protectName = readStr;
287         ret = PutWifiProtectRef(protectName);
288     }
289     reply.WriteInt32(0);
290     reply.WriteInt32(ret);
291     return;
292 }
293 
OnIsHeldWifiProtectRef(uint32_t code,MessageParcel & data,MessageParcel & reply)294 void WifiDeviceStub::OnIsHeldWifiProtectRef(uint32_t code, MessageParcel &data, MessageParcel &reply)
295 {
296     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
297     ErrCode ret = WIFI_OPT_FAILED;
298     const char *readStr = data.ReadCString();
299     bool isHoldProtect = false;
300     if (readStr == nullptr) {
301         ret = WIFI_OPT_INVALID_PARAM;
302     } else {
303         std::string protectName = readStr;
304         ret = IsHeldWifiProtectRef(protectName, isHoldProtect);
305     }
306     reply.WriteInt32(0);
307     reply.WriteInt32(ret);
308     if (ret == WIFI_OPT_SUCCESS) {
309         reply.WriteBool(isHoldProtect);
310     }
311     return;
312 }
313 
OnAddDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)314 void WifiDeviceStub::OnAddDeviceConfig(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     bool isCandidate = data.ReadBool();
318     WifiDeviceConfig config;
319     ReadWifiDeviceConfig(data, config);
320 
321     int result = INVALID_NETWORK_ID;
322     ErrCode ret = AddDeviceConfig(config, result, isCandidate);
323 
324     reply.WriteInt32(0);
325     reply.WriteInt32(ret);
326     if (ret == WIFI_OPT_SUCCESS) {
327         reply.WriteInt32(result);
328     }
329 
330     return;
331 }
332 
OnUpdateDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)333 void WifiDeviceStub::OnUpdateDeviceConfig(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     WifiDeviceConfig config;
337     ReadWifiDeviceConfig(data, config);
338     int result = INVALID_NETWORK_ID;
339     ErrCode ret = UpdateDeviceConfig(config, result);
340     reply.WriteInt32(0);
341     reply.WriteInt32(ret);
342     if (ret == WIFI_OPT_SUCCESS) {
343         reply.WriteInt32(result);
344     }
345     return;
346 }
347 
ReadEapConfig(MessageParcel & data,WifiEapConfig & wifiEapConfig)348 void WifiDeviceStub::ReadEapConfig(MessageParcel &data, WifiEapConfig &wifiEapConfig)
349 {
350     wifiEapConfig.eap = data.ReadString();
351     wifiEapConfig.phase2Method = Phase2Method(data.ReadInt32());
352     wifiEapConfig.identity = data.ReadString();
353     wifiEapConfig.anonymousIdentity = data.ReadString();
354     wifiEapConfig.password = data.ReadString();
355 
356     wifiEapConfig.caCertPath = data.ReadString();
357     wifiEapConfig.caCertAlias = data.ReadString();
358     data.ReadUInt8Vector(&wifiEapConfig.certEntry);
359 
360     wifiEapConfig.clientCert = data.ReadString();
361     if (strcpy_s(wifiEapConfig.certPassword, sizeof(wifiEapConfig.certPassword),
362         data.ReadString().c_str()) != EOK) {
363         WIFI_LOGE("%{public}s: failed to copy", __func__);
364     }
365     wifiEapConfig.privateKey = data.ReadString();
366 
367     wifiEapConfig.altSubjectMatch = data.ReadString();
368     wifiEapConfig.domainSuffixMatch = data.ReadString();
369     wifiEapConfig.realm = data.ReadString();
370     wifiEapConfig.plmn = data.ReadString();
371     wifiEapConfig.eapSubId = data.ReadInt32();
372 }
373 
ReadWifiDeviceConfig(MessageParcel & data,WifiDeviceConfig & config)374 void WifiDeviceStub::ReadWifiDeviceConfig(MessageParcel &data, WifiDeviceConfig &config)
375 {
376     config.networkId = data.ReadInt32();
377     config.status = data.ReadInt32();
378     config.bssid = data.ReadString();
379     config.bssidType = data.ReadInt32();
380     config.ssid = data.ReadString();
381     config.band = data.ReadInt32();
382     config.channel = data.ReadInt32();
383     config.frequency = data.ReadInt32();
384     config.level = data.ReadInt32();
385     config.isPasspoint = data.ReadBool();
386     config.isEphemeral = data.ReadBool();
387     config.preSharedKey = data.ReadString();
388     config.keyMgmt = data.ReadString();
389     for (int i = 0; i < WEPKEYS_SIZE; i++) {
390         config.wepKeys[i] = data.ReadString();
391     }
392     config.wepTxKeyIndex = data.ReadInt32();
393     config.priority = data.ReadInt32();
394     config.hiddenSSID = data.ReadBool();
395     config.wifiIpConfig.assignMethod = AssignIpMethod(data.ReadInt32());
396     ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.ipAddress.address);
397     config.wifiIpConfig.staticIpAddress.ipAddress.prefixLength = data.ReadInt32();
398     config.wifiIpConfig.staticIpAddress.ipAddress.flags = data.ReadInt32();
399     config.wifiIpConfig.staticIpAddress.ipAddress.scope = data.ReadInt32();
400     ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.gateway);
401     ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer1);
402     ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer2);
403     config.wifiIpConfig.staticIpAddress.domains = data.ReadString();
404     ReadEapConfig(data, config.wifiEapConfig);
405     config.wifiProxyconfig.configureMethod = ConfigureProxyMethod(data.ReadInt32());
406     config.wifiProxyconfig.autoProxyConfig.pacWebAddress = data.ReadString();
407     config.wifiProxyconfig.manualProxyConfig.serverHostName = data.ReadString();
408     config.wifiProxyconfig.manualProxyConfig.serverPort = data.ReadInt32();
409     config.wifiProxyconfig.manualProxyConfig.exclusionObjectList = data.ReadString();
410     config.wifiPrivacySetting = WifiPrivacyConfig(data.ReadInt32());
411     config.callProcessName = data.ReadString();
412     config.ancoCallProcessName = data.ReadString();
413     config.uid = data.ReadInt32();
414     config.wifiWapiConfig.wapiPskType = data.ReadInt32();
415     config.wifiWapiConfig.wapiAsCertData = data.ReadString();
416     config.wifiWapiConfig.wapiUserCertData = data.ReadString();
417     return;
418 }
419 
ReadIpAddress(MessageParcel & data,WifiIpAddress & address)420 void WifiDeviceStub::ReadIpAddress(MessageParcel &data, WifiIpAddress &address)
421 {
422     constexpr int MAX_LIMIT_SIZE = 1024;
423     address.family = data.ReadInt32();
424     address.addressIpv4 = static_cast<uint32_t>(data.ReadInt32());
425     int size = data.ReadInt32();
426     if (size > MAX_LIMIT_SIZE) {
427         WIFI_LOGE("Read ip address parameter error: %{public}d", size);
428         return;
429     }
430     for (int i = 0; i < size; i++) {
431         address.addressIpv6.push_back(data.ReadInt8());
432     }
433     return;
434 }
435 
WriteEapConfig(MessageParcel & reply,const WifiEapConfig & wifiEapConfig)436 void WifiDeviceStub::WriteEapConfig(MessageParcel &reply, const WifiEapConfig &wifiEapConfig)
437 {
438     reply.WriteString(wifiEapConfig.eap);
439     reply.WriteInt32(static_cast<int>(wifiEapConfig.phase2Method));
440     reply.WriteString(wifiEapConfig.identity);
441     reply.WriteString(wifiEapConfig.anonymousIdentity);
442     reply.WriteString(wifiEapConfig.password);
443 
444     reply.WriteString(wifiEapConfig.caCertPath);
445     reply.WriteString(wifiEapConfig.caCertAlias);
446     reply.WriteUInt8Vector(wifiEapConfig.certEntry);
447 
448     reply.WriteString(wifiEapConfig.clientCert);
449     reply.WriteString(std::string(wifiEapConfig.certPassword));
450     reply.WriteString(wifiEapConfig.privateKey);
451 
452     reply.WriteString(wifiEapConfig.altSubjectMatch);
453     reply.WriteString(wifiEapConfig.domainSuffixMatch);
454     reply.WriteString(wifiEapConfig.realm);
455     reply.WriteString(wifiEapConfig.plmn);
456     reply.WriteInt32(wifiEapConfig.eapSubId);
457 }
458 
BigDataWriteEapConfig(const WifiEapConfig & wifiEapConfig,std::stringstream & bigDataStream)459 void WifiDeviceStub::BigDataWriteEapConfig(const WifiEapConfig &wifiEapConfig, std::stringstream &bigDataStream)
460 {
461     bigDataStream << StringToHex(wifiEapConfig.eap) << ";";
462     bigDataStream << static_cast<int>(wifiEapConfig.phase2Method) << ";";
463     bigDataStream << StringToHex(wifiEapConfig.identity) << ";";
464     bigDataStream << StringToHex(wifiEapConfig.anonymousIdentity) << ";";
465     bigDataStream << StringToHex(wifiEapConfig.password) << ";";
466 
467     bigDataStream << StringToHex(wifiEapConfig.caCertPath) << ";";
468     bigDataStream << StringToHex(wifiEapConfig.caCertAlias) << ";";
469 
470     bigDataStream << StringToHex(wifiEapConfig.clientCert) << ";";
471     bigDataStream << StringToHex(wifiEapConfig.privateKey) << ";";
472 
473     bigDataStream << StringToHex(wifiEapConfig.altSubjectMatch) << ";";
474     bigDataStream << StringToHex(wifiEapConfig.domainSuffixMatch) << ";";
475     bigDataStream << StringToHex(wifiEapConfig.realm) << ";";
476     bigDataStream << StringToHex(wifiEapConfig.plmn) << ";";
477     bigDataStream << wifiEapConfig.eapSubId << ";";
478 }
479 
WriteWifiDeviceConfig(MessageParcel & reply,const WifiDeviceConfig & config)480 void WifiDeviceStub::WriteWifiDeviceConfig(MessageParcel &reply, const WifiDeviceConfig &config)
481 {
482     reply.WriteInt32(config.networkId);
483     reply.WriteInt32(config.status);
484     reply.WriteString(config.bssid);
485     reply.WriteInt32(config.bssidType);
486     reply.WriteString(config.ssid);
487     reply.WriteInt32(config.band);
488     reply.WriteInt32(config.channel);
489     reply.WriteInt32(config.frequency);
490     reply.WriteInt32(config.level);
491     reply.WriteBool(config.isPasspoint);
492     reply.WriteBool(config.isEphemeral);
493     reply.WriteString(config.preSharedKey);
494     reply.WriteString(config.keyMgmt);
495     for (int j = 0; j < WEPKEYS_SIZE; j++) {
496         reply.WriteString(config.wepKeys[j]);
497     }
498     reply.WriteInt32(config.wepTxKeyIndex);
499     reply.WriteInt32(config.priority);
500     reply.WriteBool(config.hiddenSSID);
501     reply.WriteInt32((int)config.wifiIpConfig.assignMethod);
502     WriteIpAddress(reply, config.wifiIpConfig.staticIpAddress.ipAddress.address);
503     reply.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.prefixLength);
504     reply.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.flags);
505     reply.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.scope);
506     WriteIpAddress(reply, config.wifiIpConfig.staticIpAddress.gateway);
507     WriteIpAddress(reply, config.wifiIpConfig.staticIpAddress.dnsServer1);
508     WriteIpAddress(reply, config.wifiIpConfig.staticIpAddress.dnsServer2);
509     reply.WriteString(config.wifiIpConfig.staticIpAddress.domains);
510     WriteEapConfig(reply, config.wifiEapConfig);
511     reply.WriteInt32((int)config.wifiProxyconfig.configureMethod);
512     reply.WriteString(config.wifiProxyconfig.autoProxyConfig.pacWebAddress);
513     reply.WriteString(config.wifiProxyconfig.manualProxyConfig.serverHostName);
514     reply.WriteInt32(config.wifiProxyconfig.manualProxyConfig.serverPort);
515     reply.WriteString(config.wifiProxyconfig.manualProxyConfig.exclusionObjectList);
516     reply.WriteInt32((int)config.wifiPrivacySetting);
517     reply.WriteInt32(config.uid);
518     reply.WriteString(config.callProcessName);
519     reply.WriteString(config.ancoCallProcessName);
520     reply.WriteInt32(config.wifiWapiConfig.wapiPskType);
521     reply.WriteInt32((int)config.networkSelectionStatus.status);
522     reply.WriteInt32((int)config.networkSelectionStatus.networkSelectionDisableReason);
523     return;
524 }
525 
WriteIpAddress(MessageParcel & reply,const WifiIpAddress & address)526 void WifiDeviceStub::WriteIpAddress(MessageParcel &reply, const WifiIpAddress &address)
527 {
528     reply.WriteInt32(address.family);
529     reply.WriteInt32(address.addressIpv4);
530     int size = static_cast<int>(address.addressIpv6.size());
531     reply.WriteInt32(size);
532     for (int i = 0; i < size; i++) {
533         reply.WriteInt8(address.addressIpv6[i]);
534     }
535 
536     return;
537 }
538 
BigDataWriteIpAddress(const WifiIpAddress & address,std::stringstream & bigDataStream)539 void WifiDeviceStub::BigDataWriteIpAddress(const WifiIpAddress &address, std::stringstream &bigDataStream)
540 {
541     bigDataStream << address.family << ";";
542     bigDataStream << address.addressIpv4 << ";";
543     int size = static_cast<int>(address.addressIpv6.size());
544     bigDataStream << size << ";";
545     for (int i = 0; i < size; i++) {
546         bigDataStream << address.addressIpv6[i] << ";";
547     }
548 
549     return;
550 }
551 
OnRemoveDevice(uint32_t code,MessageParcel & data,MessageParcel & reply)552 void WifiDeviceStub::OnRemoveDevice(uint32_t code, MessageParcel &data, MessageParcel &reply)
553 {
554     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
555     int networkId = data.ReadInt32();
556     ErrCode ret = RemoveDevice(networkId);
557     reply.WriteInt32(0);
558     reply.WriteInt32(ret);
559 
560     return;
561 }
562 
OnRemoveAllDevice(uint32_t code,MessageParcel & data,MessageParcel & reply)563 void WifiDeviceStub::OnRemoveAllDevice(uint32_t code, MessageParcel &data, MessageParcel &reply)
564 {
565     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
566     ErrCode ret = RemoveAllDevice();
567     reply.WriteInt32(0);
568     reply.WriteInt32(ret);
569 
570     return;
571 }
572 
SendBigConfigEx(int contentSize,std::vector<WifiDeviceConfig> & result,std::stringstream & bigDataStream)573 void WifiDeviceStub::SendBigConfigEx(int contentSize, std::vector<WifiDeviceConfig> &result,
574     std::stringstream &bigDataStream)
575 {
576     for (int i = 0; i < contentSize; ++i) {
577         bigDataStream << result[i].networkId << ";";
578         bigDataStream << result[i].status << ";";
579         bigDataStream << StringToHex(result[i].bssid) << ";";
580         bigDataStream << result[i].bssidType << ";";
581         bigDataStream << StringToHex(result[i].ssid) << ";";
582         bigDataStream << result[i].band << ";";
583         bigDataStream << result[i].channel << ";";
584         bigDataStream << result[i].frequency << ";";
585         bigDataStream << result[i].level << ";";
586         bigDataStream << result[i].isPasspoint << ";";
587         bigDataStream << result[i].isEphemeral << ";";
588         bigDataStream << StringToHex(result[i].preSharedKey) << ";";
589         bigDataStream << StringToHex(result[i].keyMgmt) << ";";
590         for (int j = 0; j < WEPKEYS_SIZE; j++) {
591             bigDataStream << StringToHex(result[i].wepKeys[j]) << ";";
592         }
593         bigDataStream << result[i].wepTxKeyIndex << ";";
594         bigDataStream << result[i].priority << ";";
595         bigDataStream << result[i].hiddenSSID << ";";
596         bigDataStream << (int)result[i].wifiIpConfig.assignMethod << ";";
597         BigDataWriteIpAddress(result[i].wifiIpConfig.staticIpAddress.ipAddress.address, bigDataStream);
598         bigDataStream << result[i].wifiIpConfig.staticIpAddress.ipAddress.prefixLength << ";";
599         bigDataStream << result[i].wifiIpConfig.staticIpAddress.ipAddress.flags << ";";
600         bigDataStream << result[i].wifiIpConfig.staticIpAddress.ipAddress.scope << ";";
601         BigDataWriteIpAddress(result[i].wifiIpConfig.staticIpAddress.gateway, bigDataStream);
602         BigDataWriteIpAddress(result[i].wifiIpConfig.staticIpAddress.dnsServer1, bigDataStream);
603         BigDataWriteIpAddress(result[i].wifiIpConfig.staticIpAddress.dnsServer2, bigDataStream);
604         bigDataStream << StringToHex(result[i].wifiIpConfig.staticIpAddress.domains) << ";";
605         BigDataWriteEapConfig(result[i].wifiEapConfig, bigDataStream);
606         bigDataStream << (int)result[i].wifiProxyconfig.configureMethod << ";";
607         bigDataStream << StringToHex(result[i].wifiProxyconfig.autoProxyConfig.pacWebAddress) << ";";
608         bigDataStream << StringToHex(result[i].wifiProxyconfig.manualProxyConfig.serverHostName) << ";";
609         bigDataStream << result[i].wifiProxyconfig.manualProxyConfig.serverPort << ";";
610         bigDataStream << StringToHex(result[i].wifiProxyconfig.manualProxyConfig.exclusionObjectList) << ";";
611         bigDataStream << (int)result[i].wifiPrivacySetting << ";";
612         bigDataStream << result[i].uid << ";";
613         bigDataStream << StringToHex(result[i].callProcessName) << ";";
614         bigDataStream << StringToHex(result[i].ancoCallProcessName) << ";";
615         bigDataStream << (int)result[i].networkSelectionStatus.status << ";";
616         bigDataStream << (int)result[i].networkSelectionStatus.networkSelectionDisableReason << ";";
617     }
618 }
619 
SendBigConfig(int contentSize,std::vector<WifiDeviceConfig> & result,MessageParcel & reply)620 void WifiDeviceStub::SendBigConfig(int contentSize, std::vector<WifiDeviceConfig> &result, MessageParcel &reply)
621 {
622     WIFI_LOGI("WifiDeviceStub SendBigConfig");
623     std::string name = "deviceconfigs";
624     sptr<Ashmem> ashmem = Ashmem::CreateAshmem(name.c_str(), contentSize * sizeof(WifiDeviceConfig));
625     if (ashmem == nullptr || !ashmem->MapReadAndWriteAshmem()) {
626         reply.WriteInt32(WIFI_OPT_FAILED);
627         if (ashmem != nullptr) {
628             ashmem->UnmapAshmem();
629             ashmem->CloseAshmem();
630         }
631         return;
632     }
633     std::stringstream bigDataStream;
634     SendBigConfigEx(contentSize, result, bigDataStream);
635 
636     reply.WriteInt32(WIFI_OPT_SUCCESS);
637     reply.WriteInt32(contentSize);
638     long len = static_cast<long>(bigDataStream.str().length());
639     reply.WriteInt64(len);
640     ashmem->WriteToAshmem(bigDataStream.str().c_str(), bigDataStream.str().length(), 0);
641     reply.WriteAshmem(ashmem);
642 
643     ashmem->UnmapAshmem();
644     ashmem->CloseAshmem();
645 }
646 
SendSmallConfig(int32_t size,std::vector<WifiDeviceConfig> & result,MessageParcel & reply)647 void WifiDeviceStub::SendSmallConfig(int32_t size, std::vector<WifiDeviceConfig> &result, MessageParcel &reply)
648 {
649     reply.WriteInt32(WIFI_OPT_SUCCESS);
650     reply.WriteInt32(size);
651     for (int32_t i = 0; i < size; ++i) {
652         WriteWifiDeviceConfig(reply, result[i]);
653     }
654 
655     return;
656 }
657 
OnGetDeviceConfigs(uint32_t code,MessageParcel & data,MessageParcel & reply)658 void WifiDeviceStub::OnGetDeviceConfigs(uint32_t code, MessageParcel &data, MessageParcel &reply)
659 {
660     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
661     bool isCandidate = data.ReadBool();
662     std::vector<WifiDeviceConfig> result;
663     ErrCode ret = GetDeviceConfigs(result, isCandidate);
664     reply.WriteInt32(0);
665 
666     if (ret != WIFI_OPT_SUCCESS) {
667         reply.WriteInt32(ret);
668         return;
669     }
670     unsigned int size = result.size();
671     if (size > MAX_ASHMEM_SIZE) {
672         SendBigConfig(size, result, reply);
673         return;
674     }
675     SendSmallConfig(size, result, reply);
676     return;
677 }
678 
OnEnableDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)679 void WifiDeviceStub::OnEnableDeviceConfig(uint32_t code, MessageParcel &data, MessageParcel &reply)
680 {
681     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
682     int networkId = data.ReadInt32();
683     bool attemptEnable = data.ReadBool();
684     ErrCode ret = EnableDeviceConfig(networkId, attemptEnable);
685     reply.WriteInt32(0);
686     reply.WriteInt32(ret);
687 
688     return;
689 }
690 
OnDisableDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)691 void WifiDeviceStub::OnDisableDeviceConfig(uint32_t code, MessageParcel &data, MessageParcel &reply)
692 {
693     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
694     int networkId = data.ReadInt32();
695     ErrCode ret = DisableDeviceConfig(networkId);
696     reply.WriteInt32(0);
697     reply.WriteInt32(ret);
698 
699     return;
700 }
701 
OnGetChangeDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)702 void WifiDeviceStub::OnGetChangeDeviceConfig(uint32_t code, MessageParcel &data, MessageParcel &reply)
703 {
704     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
705     Wifi::ConfigChange value;
706     Wifi::WifiDeviceConfig config;
707     ErrCode ret = GetChangeDeviceConfig(value, config);
708     reply.WriteInt32(0);
709     reply.WriteInt32((int)value);
710     reply.WriteInt32(config.networkId);
711     reply.WriteString(config.ssid);
712     reply.WriteString(config.bssid);
713     reply.WriteString(config.callProcessName);
714     reply.WriteString(config.keyMgmt);
715     reply.WriteString(config.ancoCallProcessName);
716     reply.WriteInt32(ret);
717     return;
718 }
719 
OnConnectTo(uint32_t code,MessageParcel & data,MessageParcel & reply)720 void WifiDeviceStub::OnConnectTo(uint32_t code, MessageParcel &data, MessageParcel &reply)
721 {
722     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
723     bool isCandidate = data.ReadBool();
724     int networkId = data.ReadInt32();
725     ErrCode ret = ConnectToNetwork(networkId, isCandidate);
726     reply.WriteInt32(0);
727     reply.WriteInt32(ret);
728 
729     return;
730 }
731 
OnConnect2To(uint32_t code,MessageParcel & data,MessageParcel & reply)732 void WifiDeviceStub::OnConnect2To(uint32_t code, MessageParcel &data, MessageParcel &reply)
733 {
734     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
735     WifiDeviceConfig config;
736     ReadWifiDeviceConfig(data, config);
737     ErrCode ret = ConnectToDevice(config);
738     reply.WriteInt32(0);
739     reply.WriteInt32(ret);
740 
741     return;
742 }
743 
OnStartRoamToNetwork(uint32_t code,MessageParcel & data,MessageParcel & reply)744 void WifiDeviceStub::OnStartRoamToNetwork(uint32_t code, MessageParcel &data, MessageParcel &reply)
745 {
746     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
747     int networkId = data.ReadInt32();
748     std::string bssid = data.ReadString();
749     bool isCandidate = data.ReadBool();
750     ErrCode ret = StartRoamToNetwork(networkId, bssid, isCandidate);
751     reply.WriteInt32(0);
752     reply.WriteInt32(ret);
753     return;
754 }
755 
OnStartConnectToUserSelectNetwork(uint32_t code,MessageParcel & data,MessageParcel & reply)756 void WifiDeviceStub::OnStartConnectToUserSelectNetwork(uint32_t code, MessageParcel &data, MessageParcel &reply)
757 {
758     WIFI_LOGD("enter %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
759     int networkId = data.ReadInt32();
760     std::string bssid = data.ReadString();
761     bool isCandidate = data.ReadBool();
762     ErrCode ret = StartConnectToUserSelectNetwork(networkId, bssid, isCandidate);
763     reply.WriteInt32(0);
764     reply.WriteInt32(ret);
765     return;
766 }
767 
OnIsWifiConnected(uint32_t code,MessageParcel & data,MessageParcel & reply)768 void WifiDeviceStub::OnIsWifiConnected(uint32_t code, MessageParcel &data, MessageParcel &reply)
769 {
770     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
771     bool isConnected = false;
772     ErrCode ret = IsConnected(isConnected);
773     reply.WriteInt32(0);
774     reply.WriteInt32(ret);
775     if (ret == WIFI_OPT_SUCCESS) {
776         reply.WriteBool(isConnected);
777     }
778     return;
779 }
780 
OnReConnect(uint32_t code,MessageParcel & data,MessageParcel & reply)781 void WifiDeviceStub::OnReConnect(uint32_t code, MessageParcel &data, MessageParcel &reply)
782 {
783     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
784     ErrCode ret = ReConnect();
785     reply.WriteInt32(0);
786     reply.WriteInt32(ret);
787 
788     return;
789 }
790 
OnReAssociate(uint32_t code,MessageParcel & data,MessageParcel & reply)791 void WifiDeviceStub::OnReAssociate(uint32_t code, MessageParcel &data, MessageParcel &reply)
792 {
793     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
794     ErrCode ret = ReAssociate();
795     reply.WriteInt32(0);
796     reply.WriteInt32(ret);
797 
798     return;
799 }
800 
OnDisconnect(uint32_t code,MessageParcel & data,MessageParcel & reply)801 void WifiDeviceStub::OnDisconnect(uint32_t code, MessageParcel &data, MessageParcel &reply)
802 {
803     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
804     ErrCode ret = Disconnect();
805     reply.WriteInt32(0);
806     reply.WriteInt32(ret);
807 
808     return;
809 }
810 
OnStartWps(uint32_t code,MessageParcel & data,MessageParcel & reply)811 void WifiDeviceStub::OnStartWps(uint32_t code, MessageParcel &data, MessageParcel &reply)
812 {
813     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
814     ErrCode ret = WIFI_OPT_FAILED;
815     WpsConfig config;
816     config.setup = SetupMethod(data.ReadInt32());
817     const char *pinRead = data.ReadCString();
818     const char *bssidRead = data.ReadCString();
819     if (pinRead == nullptr || bssidRead == nullptr) {
820         ret = WIFI_OPT_INVALID_PARAM;
821     } else {
822         config.pin = pinRead;
823         config.bssid = bssidRead;
824         ret = StartWps(config);
825     }
826 
827     reply.WriteInt32(0);
828     reply.WriteInt32(ret);
829 
830     return;
831 }
832 
OnCancelWps(uint32_t code,MessageParcel & data,MessageParcel & reply)833 void WifiDeviceStub::OnCancelWps(uint32_t code, MessageParcel &data, MessageParcel &reply)
834 {
835     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
836     ErrCode ret = CancelWps();
837     reply.WriteInt32(0);
838     reply.WriteInt32(ret);
839 
840     return;
841 }
842 
OnIsWifiActive(uint32_t code,MessageParcel & data,MessageParcel & reply)843 void WifiDeviceStub::OnIsWifiActive(uint32_t code, MessageParcel &data, MessageParcel &reply)
844 {
845     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
846     bool bActive = false;
847     ErrCode ret = IsWifiActive(bActive);
848     reply.WriteInt32(0);
849     reply.WriteInt32(ret);
850     if (ret == WIFI_OPT_SUCCESS) {
851         reply.WriteBool(bActive);
852     }
853     return;
854 }
855 
OnGetWifiState(uint32_t code,MessageParcel & data,MessageParcel & reply)856 void WifiDeviceStub::OnGetWifiState(uint32_t code, MessageParcel &data, MessageParcel &reply)
857 {
858     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
859     int state = 0;
860     ErrCode ret = GetWifiState(state);
861     reply.WriteInt32(0);
862     reply.WriteInt32(ret);
863     if (ret == WIFI_OPT_SUCCESS) {
864         reply.WriteInt32(state);
865     }
866     return;
867 }
868 
OnIsMeteredHotspot(uint32_t code,MessageParcel & data,MessageParcel & reply)869 void WifiDeviceStub::OnIsMeteredHotspot(uint32_t code, MessageParcel &data, MessageParcel &reply)
870 {
871     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
872     bool bMeteredHotspot = false;
873     ErrCode ret = IsMeteredHotspot(bMeteredHotspot);
874     reply.WriteInt32(0);
875     reply.WriteInt32(ret);
876     if (ret == WIFI_OPT_SUCCESS) {
877         reply.WriteBool(bMeteredHotspot);
878     }
879     return;
880 }
881 
OnGetLinkedInfo(uint32_t code,MessageParcel & data,MessageParcel & reply)882 void WifiDeviceStub::OnGetLinkedInfo(uint32_t code, MessageParcel &data, MessageParcel &reply)
883 {
884     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
885     WifiLinkedInfo wifiInfo;
886     ErrCode ret = GetLinkedInfo(wifiInfo);
887     reply.WriteInt32(0);
888     reply.WriteInt32(ret);
889 
890     if (ret == WIFI_OPT_SUCCESS) {
891         reply.WriteInt32(wifiInfo.networkId);
892         reply.WriteString(wifiInfo.ssid);
893         reply.WriteString(wifiInfo.bssid);
894         reply.WriteInt32(wifiInfo.rssi);
895         reply.WriteInt32(wifiInfo.band);
896         reply.WriteInt32(wifiInfo.frequency);
897         reply.WriteInt32(wifiInfo.linkSpeed);
898         reply.WriteString(wifiInfo.macAddress);
899         reply.WriteInt32(wifiInfo.macType);
900         reply.WriteInt32(wifiInfo.ipAddress);
901         reply.WriteInt32((int)wifiInfo.connState);
902         reply.WriteBool(wifiInfo.ifHiddenSSID);
903         reply.WriteInt32(wifiInfo.rxLinkSpeed);
904         reply.WriteInt32(wifiInfo.txLinkSpeed);
905         reply.WriteInt32(wifiInfo.chload);
906         reply.WriteInt32(wifiInfo.snr);
907         reply.WriteInt32(wifiInfo.isDataRestricted);
908         reply.WriteString(wifiInfo.portalUrl);
909         reply.WriteInt32((int)wifiInfo.supplicantState);
910         reply.WriteInt32((int)wifiInfo.detailedState);
911         reply.WriteInt32((int)wifiInfo.wifiStandard);
912         reply.WriteInt32((int)wifiInfo.maxSupportedRxLinkSpeed);
913         reply.WriteInt32((int)wifiInfo.maxSupportedTxLinkSpeed);
914         reply.WriteInt32((int)wifiInfo.channelWidth);
915         reply.WriteBool(wifiInfo.isAncoConnected);
916         reply.WriteInt32((int)wifiInfo.supportedWifiCategory);
917         reply.WriteBool(wifiInfo.isHiLinkNetwork);
918     }
919 
920     return;
921 }
922 
OnGetIpInfo(uint32_t code,MessageParcel & data,MessageParcel & reply)923 void WifiDeviceStub::OnGetIpInfo(uint32_t code, MessageParcel &data, MessageParcel &reply)
924 {
925     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
926     IpInfo info;
927     ErrCode ret = GetIpInfo(info);
928     reply.WriteInt32(0);
929     reply.WriteInt32(ret);
930     if (ret == WIFI_OPT_SUCCESS) {
931         reply.WriteInt32(info.ipAddress);
932         reply.WriteInt32(info.gateway);
933         reply.WriteInt32(info.netmask);
934         reply.WriteInt32(info.primaryDns);
935         reply.WriteInt32(info.secondDns);
936         reply.WriteInt32(info.serverIp);
937         reply.WriteInt32(info.leaseDuration);
938     }
939     return;
940 }
941 
OnGetIpV6Info(uint32_t code,MessageParcel & data,MessageParcel & reply)942 void WifiDeviceStub::OnGetIpV6Info(uint32_t code, MessageParcel &data, MessageParcel &reply)
943 {
944     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
945     IpV6Info info;
946     ErrCode ret = GetIpv6Info(info);
947     reply.WriteInt32(0);
948     reply.WriteInt32(ret);
949     if (ret == WIFI_OPT_SUCCESS) {
950         reply.WriteString(info.linkIpV6Address);
951         reply.WriteString(info.globalIpV6Address);
952         reply.WriteString(info.randGlobalIpV6Address);
953         reply.WriteString(info.uniqueLocalAddress1);
954         reply.WriteString(info.uniqueLocalAddress2);
955         reply.WriteString(info.gateway);
956         reply.WriteString(info.netmask);
957         reply.WriteString(info.primaryDns);
958         reply.WriteString(info.secondDns);
959     }
960     return;
961 }
962 
OnSetCountryCode(uint32_t code,MessageParcel & data,MessageParcel & reply)963 void WifiDeviceStub::OnSetCountryCode(uint32_t code, MessageParcel &data, MessageParcel &reply)
964 {
965     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
966     ErrCode ret = WIFI_OPT_FAILED;
967     std::string countrycode = data.ReadString();
968     ret = SetCountryCode(countrycode);
969     reply.WriteInt32(0);
970     reply.WriteInt32(ret);
971     return;
972 }
973 
OnGetCountryCode(uint32_t code,MessageParcel & data,MessageParcel & reply)974 void WifiDeviceStub::OnGetCountryCode(uint32_t code, MessageParcel &data, MessageParcel &reply)
975 {
976     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
977     std::string countryCode;
978     ErrCode ret = GetCountryCode(countryCode);
979     reply.WriteInt32(0);
980     reply.WriteInt32(ret);
981 
982     if (ret == WIFI_OPT_SUCCESS) {
983         reply.WriteString(countryCode);
984     }
985 
986     return;
987 }
988 
OnRegisterCallBack(uint32_t code,MessageParcel & data,MessageParcel & reply)989 void WifiDeviceStub::OnRegisterCallBack(uint32_t code, MessageParcel &data, MessageParcel &reply)
990 {
991     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
992     ErrCode ret = WIFI_OPT_FAILED;
993     do {
994         sptr<IRemoteObject> remote = data.ReadRemoteObject();
995         if (remote == nullptr) {
996             WIFI_LOGW("Failed to ReadRemoteObject!");
997             break;
998         }
999         sptr<IWifiDeviceCallBack> callback_ = iface_cast<IWifiDeviceCallBack>(remote);
1000         if (callback_ == nullptr) {
1001             callback_ = new (std::nothrow) WifiDeviceCallBackProxy(remote);
1002             WIFI_LOGI("create new WifiDeviceCallBackProxy!");
1003         }
1004 
1005         int pid = data.ReadInt32();
1006         int tokenId = data.ReadInt32();
1007         int eventNum = data.ReadInt32();
1008         std::vector<std::string> event;
1009         if (eventNum > 0 && eventNum <= MAX_READ_EVENT_SIZE) {
1010             for (int i = 0; i < eventNum; ++i) {
1011                 event.emplace_back(data.ReadString());
1012             }
1013         }
1014         WIFI_LOGD("%{public}s, get pid: %{public}d, tokenId: %{private}d", __func__, pid, tokenId);
1015 
1016         if (mSingleCallback) {
1017             ret = RegisterCallBack(callback_, event);
1018         } else {
1019             std::unique_lock<std::mutex> lock(deathRecipientMutex);
1020             if (deathRecipient_ == nullptr) {
1021                 deathRecipient_ = new (std::nothrow) WifiDeviceDeathRecipient();
1022             }
1023             // Add death recipient to remote object if this is the first time to register callback.
1024             if (remote->IsProxyObject() &&
1025                 !WifiInternalEventDispatcher::GetInstance().HasStaRemote(remote, m_instId)) {
1026                 remote->AddDeathRecipient(deathRecipient_);
1027             }
1028             if (callback_ != nullptr) {
1029                 for (const auto &eventName : event) {
1030                     ret = WifiInternalEventDispatcher::GetInstance().AddStaCallback(remote, callback_, pid, eventName,
1031                         tokenId, m_instId);
1032                 }
1033             }
1034         }
1035     } while (0);
1036     reply.WriteInt32(0);
1037     reply.WriteInt32(ret);
1038     return;
1039 }
1040 
OnGetSignalLevel(uint32_t code,MessageParcel & data,MessageParcel & reply)1041 void WifiDeviceStub::OnGetSignalLevel(uint32_t code, MessageParcel &data, MessageParcel &reply)
1042 {
1043     int rssi = data.ReadInt32();
1044     int band = data.ReadInt32();
1045     int level = 0;
1046     ErrCode ret = GetSignalLevel(rssi, band, level);
1047     reply.WriteInt32(0);
1048     reply.WriteInt32(ret);
1049     if (ret == WIFI_OPT_SUCCESS) {
1050         reply.WriteInt32(level);
1051     }
1052     return;
1053 }
1054 
OnGetSupportedFeatures(uint32_t code,MessageParcel & data,MessageParcel & reply)1055 void WifiDeviceStub::OnGetSupportedFeatures(uint32_t code, MessageParcel &data, MessageParcel &reply)
1056 {
1057     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1058     long features = 0;
1059     int ret = GetSupportedFeatures(features);
1060     reply.WriteInt32(0);
1061     reply.WriteInt32(ret);
1062 
1063     if (ret == WIFI_OPT_SUCCESS) {
1064         reply.WriteInt64(features);
1065     }
1066 
1067     return;
1068 }
1069 
OnGetDeviceMacAdd(uint32_t code,MessageParcel & data,MessageParcel & reply)1070 void WifiDeviceStub::OnGetDeviceMacAdd(uint32_t code, MessageParcel &data, MessageParcel &reply)
1071 {
1072     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1073     std::string strMacAddr;
1074     ErrCode ret = GetDeviceMacAddress(strMacAddr);
1075     reply.WriteInt32(0);
1076     reply.WriteInt32(ret);
1077     if (ret == WIFI_OPT_SUCCESS) {
1078         reply.WriteCString(strMacAddr.c_str());
1079     }
1080 
1081     return;
1082 }
1083 
OnSetLowLatencyMode(uint32_t code,MessageParcel & data,MessageParcel & reply)1084 void WifiDeviceStub::OnSetLowLatencyMode(uint32_t code, MessageParcel &data, MessageParcel &reply)
1085 {
1086     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1087 
1088     bool enabled = data.ReadBool();
1089     reply.WriteInt32(0);
1090     reply.WriteBool(SetLowLatencyMode(enabled));
1091 }
1092 
OnRemoveCandidateConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)1093 void WifiDeviceStub::OnRemoveCandidateConfig(uint32_t code, MessageParcel &data, MessageParcel &reply)
1094 {
1095     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1096     ErrCode ret = WIFI_OPT_FAILED;
1097     int flag = data.ReadInt32();
1098     /* Read a flag: 1-remove config by networkId, 2-remove config by WifiDeviceConfig */
1099     if (flag == 1) {
1100         int networkId = data.ReadInt32();
1101         WIFI_LOGI("Remove candidate config by networkId: %{public}d", networkId);
1102         ret = RemoveCandidateConfig(networkId);
1103     } else {
1104         WifiDeviceConfig config;
1105         ReadWifiDeviceConfig(data, config);
1106         WIFI_LOGD("Remove candidate config by config: %{public}s", SsidAnonymize(config.ssid).c_str());
1107         ret = RemoveCandidateConfig(config);
1108     }
1109     reply.WriteInt32(0);
1110     reply.WriteInt32(ret);
1111     return;
1112 }
1113 
OnIsBandTypeSupported(uint32_t code,MessageParcel & data,MessageParcel & reply)1114 void WifiDeviceStub::OnIsBandTypeSupported(uint32_t code, MessageParcel &data, MessageParcel &reply)
1115 {
1116     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1117     ErrCode ret = WIFI_OPT_FAILED;
1118     int bandType = data.ReadInt32();
1119     bool result = false;
1120     ret = IsBandTypeSupported(bandType, result);
1121     reply.WriteInt32(0);
1122     reply.WriteInt32(ret);
1123     reply.WriteBool(result);
1124     return;
1125 }
1126 
OnGet5GHzChannelList(uint32_t code,MessageParcel & data,MessageParcel & reply)1127 void WifiDeviceStub::OnGet5GHzChannelList(uint32_t code, MessageParcel &data, MessageParcel &reply)
1128 {
1129     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1130     std::vector<int> channelList;
1131     ErrCode ret = Get5GHzChannelList(channelList);
1132     reply.WriteInt32(0);
1133     reply.WriteInt32(ret);
1134     if (ret == WIFI_OPT_SUCCESS) {
1135         unsigned int size = channelList.size();
1136         reply.WriteInt32(size);
1137         for (unsigned int i = 0; i < size; ++i) {
1138             reply.WriteInt32(channelList[i]);
1139         }
1140     }
1141     return;
1142 }
1143 
OnStartPortalCertification(uint32_t code,MessageParcel & data,MessageParcel & reply)1144 void WifiDeviceStub::OnStartPortalCertification(uint32_t code, MessageParcel &data, MessageParcel &reply)
1145 {
1146     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1147     ErrCode ret = StartPortalCertification();
1148     reply.WriteInt32(0);
1149     reply.WriteInt32(ret);
1150     return;
1151 }
1152 
OnGetDisconnectedReason(uint32_t code,MessageParcel & data,MessageParcel & reply)1153 void WifiDeviceStub::OnGetDisconnectedReason(uint32_t code, MessageParcel &data, MessageParcel &reply)
1154 {
1155     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1156     DisconnectedReason reason = DisconnectedReason::DISC_REASON_DEFAULT;
1157     ErrCode ret = GetDisconnectedReason(reason);
1158     reply.WriteInt32(0);
1159     reply.WriteInt32(ret);
1160     if (ret == WIFI_OPT_SUCCESS) {
1161         reply.WriteInt32((int)reason);
1162     }
1163     return;
1164 }
1165 
OnSetFrozenApp(uint32_t code,MessageParcel & data,MessageParcel & reply)1166 void WifiDeviceStub::OnSetFrozenApp(uint32_t code, MessageParcel& data, MessageParcel& reply)
1167 {
1168     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1169     int size = data.ReadInt32();
1170     size = size < MAX_PID_LIST_SIZE ? size : MAX_PID_LIST_SIZE;
1171     std::set<int> pidList;
1172     for (int i = 0; i < size; i++) {
1173         pidList.insert(data.ReadInt32());
1174     }
1175     bool frozen = data.ReadBool();
1176     ErrCode ret = SetAppFrozen(pidList, frozen);
1177     reply.WriteInt32(0);
1178     reply.WriteInt32(ret);
1179     return;
1180 }
1181 
OnResetAllFrozenApp(uint32_t code,MessageParcel & data,MessageParcel & reply)1182 void WifiDeviceStub::OnResetAllFrozenApp(uint32_t code, MessageParcel& data, MessageParcel& reply)
1183 {
1184     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1185     ErrCode ret = ResetAllFrozenApp();
1186     reply.WriteInt32(0);
1187     reply.WriteInt32(ret);
1188     return;
1189 }
1190 
OnDisableAutoJoin(uint32_t code,MessageParcel & data,MessageParcel & reply)1191 void WifiDeviceStub::OnDisableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply)
1192 {
1193     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1194     ErrCode ret = DisableAutoJoin(data.ReadString());
1195     reply.WriteInt32(0);
1196     reply.WriteInt32(ret);
1197     return;
1198 }
1199 
OnEnableAutoJoin(uint32_t code,MessageParcel & data,MessageParcel & reply)1200 void WifiDeviceStub::OnEnableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply)
1201 {
1202     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1203     ErrCode ret = EnableAutoJoin(data.ReadString());
1204     reply.WriteInt32(0);
1205     reply.WriteInt32(ret);
1206     return;
1207 }
1208 
OnFactoryReset(uint32_t code,MessageParcel & data,MessageParcel & reply)1209 void WifiDeviceStub::OnFactoryReset(uint32_t code, MessageParcel &data, MessageParcel &reply)
1210 {
1211     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1212     ErrCode ret = FactoryReset();
1213     reply.WriteInt32(0);
1214     reply.WriteInt32(ret);
1215     return;
1216 }
1217 
OnLimitSpeed(uint32_t code,MessageParcel & data,MessageParcel & reply)1218 void WifiDeviceStub::OnLimitSpeed(uint32_t code, MessageParcel &data, MessageParcel &reply)
1219 {
1220     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1221     int controlId = data.ReadInt32();
1222     int limitMode = data.ReadInt32();
1223     ErrCode ret = LimitSpeed(controlId, limitMode);
1224     reply.WriteInt32(0);
1225     reply.WriteInt32(ret);
1226     return;
1227 }
1228 
OnEnableHiLinkHandshake(uint32_t code,MessageParcel & data,MessageParcel & reply)1229 void WifiDeviceStub::OnEnableHiLinkHandshake(uint32_t code, MessageParcel &data, MessageParcel &reply)
1230 {
1231     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__,  code, data.GetRawDataSize());
1232     bool uiFlag = data.ReadBool();
1233     std::string bssid = data.ReadString();
1234     WifiDeviceConfig deviceConfig;
1235     ReadWifiDeviceConfig(data, deviceConfig);
1236     ErrCode ret = EnableHiLinkHandshake(uiFlag, bssid, deviceConfig);
1237     reply.WriteInt32(0);
1238     reply.WriteInt32(ret);
1239     return;
1240 }
1241 
OnSetSatelliteState(uint32_t code,MessageParcel & data,MessageParcel & reply)1242 void WifiDeviceStub::OnSetSatelliteState(uint32_t code, MessageParcel &data, MessageParcel &reply)
1243 {
1244     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1245     int state = data.ReadInt32();
1246     ErrCode ret = SetSatelliteState(state);
1247     reply.WriteInt32(0);
1248     reply.WriteInt32(ret);
1249     return;
1250 }
1251 
OnEnableSemiWifi(uint32_t code,MessageParcel & data,MessageParcel & reply)1252 void WifiDeviceStub::OnEnableSemiWifi(uint32_t code, MessageParcel &data, MessageParcel &reply)
1253 {
1254     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1255     ErrCode ret = EnableSemiWifi();
1256     reply.WriteInt32(0);
1257     reply.WriteInt32(ret);
1258     return;
1259 }
1260 
OnGetWifiDetailState(uint32_t code,MessageParcel & data,MessageParcel & reply)1261 void WifiDeviceStub::OnGetWifiDetailState(uint32_t code, MessageParcel &data, MessageParcel &reply)
1262 {
1263     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1264     WifiDetailState state = WifiDetailState::STATE_UNKNOWN;
1265     ErrCode ret = GetWifiDetailState(state);
1266     reply.WriteInt32(0);
1267     reply.WriteInt32(ret);
1268     if (ret == WIFI_OPT_SUCCESS) {
1269         reply.WriteInt32(static_cast<int>(state));
1270     }
1271 
1272     return;
1273 }
1274 
OnSetLowTxPower(uint32_t code,MessageParcel & data,MessageParcel & reply)1275 void WifiDeviceStub::OnSetLowTxPower(uint32_t code, MessageParcel &data, MessageParcel &reply)
1276 {
1277     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1278     WifiLowPowerParam wifiLowPowerParam;
1279     wifiLowPowerParam.ifName = data.ReadString();
1280     wifiLowPowerParam.scene = data.ReadInt32();
1281     wifiLowPowerParam.rssiThreshold = data.ReadInt32();
1282     wifiLowPowerParam.peerMacaddr = data.ReadString();
1283     wifiLowPowerParam.powerParam = data.ReadString();
1284     wifiLowPowerParam.powerParamLen = data.ReadInt32();
1285     ErrCode ret = SetLowTxPower(wifiLowPowerParam);
1286     reply.WriteInt32(0);
1287     reply.WriteInt32(ret);
1288     return;
1289 }
1290 
OnSetTxPower(uint32_t code,MessageParcel & data,MessageParcel & reply)1291 void WifiDeviceStub::OnSetTxPower(uint32_t code, MessageParcel &data, MessageParcel &reply)
1292 {
1293     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__,  code, data.GetRawDataSize());
1294     int power = data.ReadInt32();
1295     ErrCode ret = SetTxPower(power);
1296     reply.WriteInt32(0);
1297     reply.WriteInt32(ret);
1298     return;
1299 }
1300 
OnGetDeviceConfig(uint32_t code,MessageParcel & data,MessageParcel & reply)1301 void WifiDeviceStub::OnGetDeviceConfig(uint32_t code, MessageParcel &data, MessageParcel &reply)
1302 {
1303     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1304     bool networkId = data.ReadInt32();
1305     WifiDeviceConfig config;
1306     ErrCode ret = GetDeviceConfig(networkId, config);
1307     reply.WriteInt32(0);
1308 
1309     if (ret != WIFI_OPT_SUCCESS) {
1310         reply.WriteInt32(ret);
1311         return;
1312     }
1313     WriteWifiDeviceConfig(reply, config);
1314     return;
1315 }
1316 
OnSetDpiMarkRule(uint32_t code,MessageParcel & data,MessageParcel & reply)1317 void WifiDeviceStub::OnSetDpiMarkRule(uint32_t code, MessageParcel &data, MessageParcel &reply)
1318 {
1319     WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize());
1320     ErrCode ret = WIFI_OPT_FAILED;
1321     const char *readStr = data.ReadCString();
1322     int uid = data.ReadInt32();
1323     int protocol = data.ReadInt32();
1324     int enable = data.ReadInt32();
1325     if (readStr == nullptr) {
1326         ret = WIFI_OPT_INVALID_PARAM;
1327     } else {
1328         std::string ifaceName = readStr;
1329         ret = SetDpiMarkRule(ifaceName, uid, protocol, enable);
1330     }
1331     reply.WriteInt32(0);
1332     reply.WriteInt32(ret);
1333     return;
1334 }
1335 
1336 }  // namespace Wifi
1337 }  // namespace OHOS
1338