1 /*
2  * Copyright (c) 2021-2023 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 "net_policy_service_stub.h"
17 
18 #include "net_mgr_log_wrapper.h"
19 #include "net_policy_core.h"
20 #include "net_quota_policy.h"
21 #include "netmanager_base_permission.h"
22 #include "ipc_skeleton.h"
23 
24 namespace OHOS {
25 namespace NetManagerStandard {
26 namespace {
27 std::map<uint32_t, const char *> g_codeNPS = {
28     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID), Permission::MANAGE_NET_STRATEGY},
29     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID), Permission::MANAGE_NET_STRATEGY},
30     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY), Permission::MANAGE_NET_STRATEGY},
31     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED), Permission::MANAGE_NET_STRATEGY},
32     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE), Permission::MANAGE_NET_STRATEGY},
33     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_REGISTER_NET_POLICY_CALLBACK), Permission::MANAGE_NET_STRATEGY},
34     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UNREGISTER_NET_POLICY_CALLBACK),
35      Permission::MANAGE_NET_STRATEGY},
36     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES), Permission::MANAGE_NET_STRATEGY},
37     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES), Permission::MANAGE_NET_STRATEGY},
38     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY), Permission::MANAGE_NET_STRATEGY},
39     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST), Permission::MANAGE_NET_STRATEGY},
40     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST), Permission::MANAGE_NET_STRATEGY},
41     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY), Permission::MANAGE_NET_STRATEGY},
42     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES), Permission::MANAGE_NET_STRATEGY},
43     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY), Permission::MANAGE_NET_STRATEGY},
44     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY), Permission::MANAGE_NET_STRATEGY},
45     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID), Permission::MANAGE_NET_STRATEGY},
46     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST), Permission::MANAGE_NET_STRATEGY},
47     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST), Permission::MANAGE_NET_STRATEGY},
48     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_POLICY), Permission::MANAGE_NET_STRATEGY},
49     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_CHECK_PERMISSION), Permission::MANAGE_NET_STRATEGY},
50     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY), Permission::MANAGE_NET_STRATEGY},
51     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY), Permission::MANAGE_NET_STRATEGY},
52     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_NOTIFY_NETWORK_ACCESS_POLICY_DIAG),
53      Permission::MANAGE_NET_STRATEGY},
54     {static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NIC_TRAFFIC_ALLOWED), Permission::MANAGE_NET_STRATEGY},
55 };
56 constexpr uint32_t MAX_IFACENAMES_SIZE = 128;
57 } // namespace
58 
NetPolicyServiceStub()59 NetPolicyServiceStub::NetPolicyServiceStub() : ffrtQueue_(NET_POLICY_STUB_QUEUE)
60 {
61     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID)] =
62         &NetPolicyServiceStub::OnSetPolicyByUid;
63     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID)] =
64         &NetPolicyServiceStub::OnGetPolicyByUid;
65     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY)] =
66         &NetPolicyServiceStub::OnGetUidsByPolicy;
67     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED)] =
68         &NetPolicyServiceStub::OnIsUidNetAllowedMetered;
69     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE)] =
70         &NetPolicyServiceStub::OnIsUidNetAllowedIfaceName;
71     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_REGISTER_NET_POLICY_CALLBACK)] =
72         &NetPolicyServiceStub::OnRegisterNetPolicyCallback;
73     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UNREGISTER_NET_POLICY_CALLBACK)] =
74         &NetPolicyServiceStub::OnUnregisterNetPolicyCallback;
75     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES)] =
76         &NetPolicyServiceStub::OnSetNetQuotaPolicies;
77     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES)] =
78         &NetPolicyServiceStub::OnGetNetQuotaPolicies;
79     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES)] =
80         &NetPolicyServiceStub::OnResetPolicies;
81     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY)] =
82         &NetPolicyServiceStub::OnSnoozePolicy;
83     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST)] =
84         &NetPolicyServiceStub::OnSetDeviceIdleTrustlist;
85     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST)] =
86         &NetPolicyServiceStub::OnGetDeviceIdleTrustlist;
87     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY)] =
88         &NetPolicyServiceStub::OnSetDeviceIdlePolicy;
89     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST)] =
90         &NetPolicyServiceStub::OnGetPowerSaveTrustlist;
91     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST)] =
92         &NetPolicyServiceStub::OnSetPowerSaveTrustlist;
93     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY)] =
94         &NetPolicyServiceStub::OnSetBackgroundPolicy;
95     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY)] =
96         &NetPolicyServiceStub::OnGetBackgroundPolicy;
97     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID)] =
98         &NetPolicyServiceStub::OnGetBackgroundPolicyByUid;
99     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_POLICY)] =
100         &NetPolicyServiceStub::OnSetPowerSavePolicy;
101     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_CHECK_PERMISSION)] =
102         &NetPolicyServiceStub::OnCheckPermission;
103     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_FACTORYRESET_POLICIES)] =
104         &NetPolicyServiceStub::OnFactoryResetPolicies;
105     ExtraNetPolicyServiceStub();
106     InitEventHandler();
107 }
108 
ExtraNetPolicyServiceStub()109 void NetPolicyServiceStub::ExtraNetPolicyServiceStub()
110 {
111     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY)] =
112         &NetPolicyServiceStub::OnSetNetworkAccessPolicy;
113     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY)] =
114         &NetPolicyServiceStub::OnGetNetworkAccessPolicy;
115     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_NOTIFY_NETWORK_ACCESS_POLICY_DIAG)] =
116         &NetPolicyServiceStub::OnNotifyNetAccessPolicyDiag;
117     memberFuncMap_[static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NIC_TRAFFIC_ALLOWED)] =
118         &NetPolicyServiceStub::OnSetNicTrafficAllowed;
119     return;
120 }
121 
122 NetPolicyServiceStub::~NetPolicyServiceStub() = default;
123 
InitEventHandler()124 void NetPolicyServiceStub::InitEventHandler()
125 {
126     std::call_once(onceFlag, [this]() {
127         auto core = DelayedSingleton<NetPolicyCore>::GetInstance();
128         handler_ = std::make_shared<NetPolicyEventHandler>(core, ffrtQueue_);
129         core->Init(handler_);
130     });
131 }
132 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)133 int32_t NetPolicyServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
134                                               MessageOption &option)
135 {
136     std::u16string myDescriptor = NetPolicyServiceStub::GetDescriptor();
137     std::u16string remoteDescriptor = data.ReadInterfaceToken();
138     if (myDescriptor != remoteDescriptor) {
139         NETMGR_LOG_E("descriptor checked fail");
140         return NETMANAGER_ERR_DESCRIPTOR_MISMATCH;
141     }
142     NETMGR_LOG_D("stub call start, code = [%{public}d]", code);
143     if (handler_ == nullptr) {
144         NETMGR_LOG_E("Net policy handler is null, recreate handler.");
145         InitEventHandler();
146         if (handler_ == nullptr) {
147             NETMGR_LOG_E("recreate net policy handler failed.");
148             return NETMANAGER_ERR_INTERNAL;
149         }
150     }
151     auto itFunc = memberFuncMap_.find(code);
152     if (itFunc != memberFuncMap_.end()) {
153         int32_t checkPermissionResult = CheckPolicyPermission(code);
154         if (checkPermissionResult != NETMANAGER_SUCCESS) {
155             if (!reply.WriteInt32(checkPermissionResult)) {
156                 return IPC_STUB_WRITE_PARCEL_ERR;
157             }
158             return NETMANAGER_SUCCESS;
159         }
160         int32_t result = NETMANAGER_SUCCESS;
161         auto requestFunc = itFunc->second;
162         if (requestFunc != nullptr) {
163             auto task = ffrtQueue_.submit_h([this, &data, &reply, &requestFunc, &result]() {
164                           result = (this->*requestFunc)(data, reply);
165             }, ffrt::task_attr().name("FfrtOnRemoteRequest"));
166             ffrtQueue_.wait(task);
167             NETMGR_LOG_D("stub call end, code = [%{public}d], ret = [%{public}d]", code, result);
168             return result;
169         }
170     }
171     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
172 }
173 
SubCheckPermission(const std::string & permission,uint32_t funcCode)174 bool NetPolicyServiceStub::SubCheckPermission(const std::string &permission, uint32_t funcCode)
175 {
176     if (NetManagerPermission::CheckPermission(permission)) {
177         return true;
178     }
179     NETMGR_LOG_E("Permission denied funcCode: %{public}d permission: %{public}s", funcCode, permission.c_str());
180     return false;
181 }
182 
CheckPolicyPermission(uint32_t code)183 int32_t NetPolicyServiceStub::CheckPolicyPermission(uint32_t code)
184 {
185     bool result = NetManagerPermission::IsSystemCaller();
186     if (!result) {
187         return NETMANAGER_ERR_NOT_SYSTEM_CALL;
188     }
189     if (g_codeNPS.find(code) != g_codeNPS.end()) {
190         result = SubCheckPermission(g_codeNPS[code], code);
191         if (!result) {
192             return NETMANAGER_ERR_PERMISSION_DENIED;
193         }
194         return NETMANAGER_SUCCESS;
195     }
196     NETMGR_LOG_E("Error funcCode, need check");
197     return NETMANAGER_ERR_PERMISSION_DENIED;
198 }
199 
OnSetPolicyByUid(MessageParcel & data,MessageParcel & reply)200 int32_t NetPolicyServiceStub::OnSetPolicyByUid(MessageParcel &data, MessageParcel &reply)
201 {
202     NETMGR_LOG_I("SetPolicyByUid callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
203                  IPCSkeleton::GetCallingPid());
204     uint32_t uid = 0;
205     if (!data.ReadUint32(uid)) {
206         NETMGR_LOG_E("Read Uint32 data failed.");
207         return NETMANAGER_ERR_READ_DATA_FAIL;
208     }
209 
210     uint32_t netPolicy = 0;
211     if (!data.ReadUint32(netPolicy)) {
212         NETMGR_LOG_E("Read Uint32 data failed.");
213         return NETMANAGER_ERR_READ_DATA_FAIL;
214     }
215 
216     int32_t result = SetPolicyByUid(uid, netPolicy);
217     if (!reply.WriteInt32(result)) {
218         NETMGR_LOG_E("Write int32 reply failed.");
219         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
220     }
221 
222     return NETMANAGER_SUCCESS;
223 }
224 
OnGetPolicyByUid(MessageParcel & data,MessageParcel & reply)225 int32_t NetPolicyServiceStub::OnGetPolicyByUid(MessageParcel &data, MessageParcel &reply)
226 {
227     NETMGR_LOG_I("GetPolicyByUid callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
228                  IPCSkeleton::GetCallingPid());
229     uint32_t uid = 0;
230     if (!data.ReadUint32(uid)) {
231         return NETMANAGER_ERR_READ_DATA_FAIL;
232     }
233 
234     uint32_t policy = 0;
235     int32_t result = GetPolicyByUid(uid, policy);
236     if (!reply.WriteInt32(result)) {
237         NETMGR_LOG_E("Write int32 reply failed.");
238         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
239     }
240 
241     if (result == NETMANAGER_SUCCESS) {
242         if (!reply.WriteInt32(policy)) {
243             NETMGR_LOG_E("Write int32 reply failed.");
244             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
245         }
246     }
247 
248     return NETMANAGER_SUCCESS;
249 }
250 
OnGetUidsByPolicy(MessageParcel & data,MessageParcel & reply)251 int32_t NetPolicyServiceStub::OnGetUidsByPolicy(MessageParcel &data, MessageParcel &reply)
252 {
253     NETMGR_LOG_I("GetUidsByPolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
254                  IPCSkeleton::GetCallingPid());
255     uint32_t policy = 0;
256     if (!data.ReadUint32(policy)) {
257         NETMGR_LOG_E("Read uint32 data failed");
258         return NETMANAGER_ERR_READ_DATA_FAIL;
259     }
260 
261     std::vector<uint32_t> uids;
262     int32_t result = GetUidsByPolicy(policy, uids);
263     if (!reply.WriteInt32(result)) {
264         NETMGR_LOG_E("Write int32 reply failed");
265         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
266     }
267 
268     if (result == NETMANAGER_SUCCESS) {
269         if (!reply.WriteUInt32Vector(uids)) {
270             NETMGR_LOG_E("Write uint32 vector reply failed");
271             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
272         }
273     }
274 
275     return NETMANAGER_SUCCESS;
276 }
277 
OnIsUidNetAllowedMetered(MessageParcel & data,MessageParcel & reply)278 int32_t NetPolicyServiceStub::OnIsUidNetAllowedMetered(MessageParcel &data, MessageParcel &reply)
279 {
280     NETMGR_LOG_I("IsUidNetAllowedMetered callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
281                  IPCSkeleton::GetCallingPid());
282     uint32_t uid = 0;
283     bool metered = false;
284     if (!data.ReadUint32(uid)) {
285         NETMGR_LOG_E("Read uint32 data failed");
286         return NETMANAGER_ERR_READ_DATA_FAIL;
287     }
288 
289     if (!data.ReadBool(metered)) {
290         NETMGR_LOG_E("Read Bool data failed");
291         return NETMANAGER_ERR_READ_DATA_FAIL;
292     }
293 
294     bool isAllowed = false;
295     int32_t result = IsUidNetAllowed(uid, metered, isAllowed);
296     if (!reply.WriteInt32(result)) {
297         NETMGR_LOG_E("Write int32 reply failed");
298         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
299     }
300 
301     if (result == NETMANAGER_SUCCESS) {
302         if (!reply.WriteBool(isAllowed)) {
303             NETMGR_LOG_E("Write Bool reply failed");
304             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
305         }
306     }
307     return NETMANAGER_SUCCESS;
308 }
309 
OnIsUidNetAllowedIfaceName(MessageParcel & data,MessageParcel & reply)310 int32_t NetPolicyServiceStub::OnIsUidNetAllowedIfaceName(MessageParcel &data, MessageParcel &reply)
311 {
312     NETMGR_LOG_I("IsUidNetAllowedIfaceName callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
313                  IPCSkeleton::GetCallingPid());
314     uint32_t uid = 0;
315     std::string ifaceName;
316     if (!data.ReadUint32(uid)) {
317         NETMGR_LOG_E("Read uint32 data failed");
318         return NETMANAGER_ERR_READ_DATA_FAIL;
319     }
320 
321     if (!data.ReadString(ifaceName)) {
322         NETMGR_LOG_E("Read String data failed");
323         return NETMANAGER_ERR_READ_DATA_FAIL;
324     }
325 
326     bool isAllowed = false;
327     int32_t result = IsUidNetAllowed(uid, ifaceName, isAllowed);
328     if (!reply.WriteInt32(result)) {
329         NETMGR_LOG_E("Write int32 reply failed");
330         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
331     }
332     if (result == NETMANAGER_SUCCESS) {
333         if (!reply.WriteBool(isAllowed)) {
334             NETMGR_LOG_E("Write Bool reply failed");
335             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
336         }
337     }
338     return NETMANAGER_SUCCESS;
339 }
340 
OnRegisterNetPolicyCallback(MessageParcel & data,MessageParcel & reply)341 int32_t NetPolicyServiceStub::OnRegisterNetPolicyCallback(MessageParcel &data, MessageParcel &reply)
342 {
343     NETMGR_LOG_I("RegisterNetPolicyCallback callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
344                  IPCSkeleton::GetCallingPid());
345     sptr<IRemoteObject> remote = data.ReadRemoteObject();
346     if (remote == nullptr) {
347         NETMGR_LOG_E("Callback ptr is nullptr.");
348         reply.WriteInt32(NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
349         return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
350     }
351 
352     sptr<INetPolicyCallback> callback = iface_cast<INetPolicyCallback>(remote);
353     int32_t result = RegisterNetPolicyCallback(callback);
354     if (!reply.WriteInt32(result)) {
355         NETMGR_LOG_E("Write int32 reply failed");
356         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
357     }
358 
359     return NETMANAGER_SUCCESS;
360 }
361 
OnUnregisterNetPolicyCallback(MessageParcel & data,MessageParcel & reply)362 int32_t NetPolicyServiceStub::OnUnregisterNetPolicyCallback(MessageParcel &data, MessageParcel &reply)
363 {
364     NETMGR_LOG_I("UnregisterNetPolicyCallback callingUid/callingPid: %{public}d/%{public}d",
365                  IPCSkeleton::GetCallingUid(), IPCSkeleton::GetCallingPid());
366     sptr<IRemoteObject> remote = data.ReadRemoteObject();
367     if (remote == nullptr) {
368         NETMGR_LOG_E("callback ptr is nullptr.");
369         reply.WriteInt32(NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
370         return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
371     }
372     sptr<INetPolicyCallback> callback = iface_cast<INetPolicyCallback>(remote);
373     int32_t result = UnregisterNetPolicyCallback(callback);
374     if (!reply.WriteInt32(result)) {
375         NETMGR_LOG_E("Write int32 reply failed");
376         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
377     }
378 
379     return NETMANAGER_SUCCESS;
380 }
381 
OnSetNetQuotaPolicies(MessageParcel & data,MessageParcel & reply)382 int32_t NetPolicyServiceStub::OnSetNetQuotaPolicies(MessageParcel &data, MessageParcel &reply)
383 {
384     NETMGR_LOG_I("SetNetQuotaPolicies callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
385                  IPCSkeleton::GetCallingPid());
386     std::vector<NetQuotaPolicy> quotaPolicies;
387     if (!NetQuotaPolicy::Unmarshalling(data, quotaPolicies)) {
388         NETMGR_LOG_E("Unmarshalling failed.");
389         return NETMANAGER_ERR_READ_DATA_FAIL;
390     }
391 
392     int32_t result = SetNetQuotaPolicies(quotaPolicies);
393     if (!reply.WriteInt32(result)) {
394         NETMGR_LOG_E("Write int32 reply failed");
395         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
396     }
397 
398     return NETMANAGER_SUCCESS;
399 }
400 
OnGetNetQuotaPolicies(MessageParcel & data,MessageParcel & reply)401 int32_t NetPolicyServiceStub::OnGetNetQuotaPolicies(MessageParcel &data, MessageParcel &reply)
402 {
403     NETMGR_LOG_I("GetNetQuotaPolicies callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
404                  IPCSkeleton::GetCallingPid());
405     std::vector<NetQuotaPolicy> quotaPolicies;
406 
407     int32_t result = GetNetQuotaPolicies(quotaPolicies);
408     if (!reply.WriteInt32(result)) {
409         NETMGR_LOG_E("Write int32 reply failed");
410         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
411     }
412     if (result == NETMANAGER_SUCCESS) {
413         if (!NetQuotaPolicy::Marshalling(reply, quotaPolicies)) {
414             NETMGR_LOG_E("Marshalling failed");
415             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
416         }
417     }
418 
419     return NETMANAGER_SUCCESS;
420 }
421 
OnResetPolicies(MessageParcel & data,MessageParcel & reply)422 int32_t NetPolicyServiceStub::OnResetPolicies(MessageParcel &data, MessageParcel &reply)
423 {
424     NETMGR_LOG_I("ResetPolicies callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
425                  IPCSkeleton::GetCallingPid());
426     std::string subscriberId;
427     if (!data.ReadString(subscriberId)) {
428         NETMGR_LOG_E("Read String data failed");
429         return NETMANAGER_ERR_READ_DATA_FAIL;
430     }
431 
432     int32_t result = ResetPolicies(subscriberId);
433     if (!reply.WriteInt32(result)) {
434         NETMGR_LOG_E("Write int32 reply failed");
435         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
436     }
437 
438     return NETMANAGER_SUCCESS;
439 }
440 
OnSetBackgroundPolicy(MessageParcel & data,MessageParcel & reply)441 int32_t NetPolicyServiceStub::OnSetBackgroundPolicy(MessageParcel &data, MessageParcel &reply)
442 {
443     NETMGR_LOG_I("SetBackgroundPolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
444                  IPCSkeleton::GetCallingPid());
445     bool isBackgroundPolicyAllow = false;
446     if (!data.ReadBool(isBackgroundPolicyAllow)) {
447         NETMGR_LOG_E("Read Bool data failed");
448         return NETMANAGER_ERR_READ_DATA_FAIL;
449     }
450 
451     int32_t result = SetBackgroundPolicy(isBackgroundPolicyAllow);
452     if (!reply.WriteInt32(result)) {
453         NETMGR_LOG_E("Write int32 reply failed");
454         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
455     }
456 
457     return NETMANAGER_SUCCESS;
458 }
459 
OnGetBackgroundPolicy(MessageParcel & data,MessageParcel & reply)460 int32_t NetPolicyServiceStub::OnGetBackgroundPolicy(MessageParcel &data, MessageParcel &reply)
461 {
462     NETMGR_LOG_I("GetBackgroundPolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
463                  IPCSkeleton::GetCallingPid());
464     bool backgroundPolicy = false;
465     int32_t result = GetBackgroundPolicy(backgroundPolicy);
466     if (!reply.WriteInt32(result)) {
467         NETMGR_LOG_E("Write int32 reply failed");
468         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
469     }
470     if (result == NETMANAGER_SUCCESS) {
471         if (!reply.WriteBool(backgroundPolicy)) {
472             NETMGR_LOG_E("Write Bool reply failed");
473             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
474         }
475     }
476     return NETMANAGER_SUCCESS;
477 }
478 
OnGetBackgroundPolicyByUid(MessageParcel & data,MessageParcel & reply)479 int32_t NetPolicyServiceStub::OnGetBackgroundPolicyByUid(MessageParcel &data, MessageParcel &reply)
480 {
481     NETMGR_LOG_I("GetBackgroundPolicyByUid callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
482                  IPCSkeleton::GetCallingPid());
483     uint32_t uid = 0;
484     if (!data.ReadUint32(uid)) {
485         NETMGR_LOG_E("Read uint32 data failed");
486         return NETMANAGER_ERR_READ_DATA_FAIL;
487     }
488 
489     uint32_t backgroundPolicyOfUid = 0;
490     int32_t result = GetBackgroundPolicyByUid(uid, backgroundPolicyOfUid);
491     if (!reply.WriteInt32(result)) {
492         NETMGR_LOG_E("Write int32 reply failed");
493         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
494     }
495     if (result == NETMANAGER_SUCCESS) {
496         if (!reply.WriteUint32(backgroundPolicyOfUid)) {
497             NETMGR_LOG_E("Write uint32 reply failed");
498             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
499         }
500     }
501 
502     return NETMANAGER_SUCCESS;
503 }
504 
OnSnoozePolicy(MessageParcel & data,MessageParcel & reply)505 int32_t NetPolicyServiceStub::OnSnoozePolicy(MessageParcel &data, MessageParcel &reply)
506 {
507     NETMGR_LOG_I("SnoozePolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
508                  IPCSkeleton::GetCallingPid());
509     int32_t netType = 0;
510     if (!data.ReadInt32(netType)) {
511         NETMGR_LOG_E("Read int32 data failed");
512         return NETMANAGER_ERR_READ_DATA_FAIL;
513     }
514 
515     std::string simId;
516     if (!data.ReadString(simId)) {
517         NETMGR_LOG_E("Read String data failed");
518         return NETMANAGER_ERR_READ_DATA_FAIL;
519     }
520 
521     uint32_t remindType = 0;
522     if (!data.ReadUint32(remindType)) {
523         NETMGR_LOG_E("Read uint32 data failed");
524         return NETMANAGER_ERR_READ_DATA_FAIL;
525     }
526 
527     int32_t result = UpdateRemindPolicy(netType, simId, remindType);
528     if (!reply.WriteInt32(result)) {
529         NETMGR_LOG_E("Write int32 reply failed");
530         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
531     }
532 
533     return NETMANAGER_SUCCESS;
534 }
535 
OnSetDeviceIdleTrustlist(MessageParcel & data,MessageParcel & reply)536 int32_t NetPolicyServiceStub::OnSetDeviceIdleTrustlist(MessageParcel &data, MessageParcel &reply)
537 {
538     NETMGR_LOG_I("SetDeviceIdleTrustlist callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
539                  IPCSkeleton::GetCallingPid());
540     std::vector<uint32_t> uids;
541     if (!data.ReadUInt32Vector(&uids)) {
542         NETMGR_LOG_E("Read uint32 data failed");
543         return NETMANAGER_ERR_READ_DATA_FAIL;
544     }
545 
546     bool isAllowed = false;
547     if (!data.ReadBool(isAllowed)) {
548         NETMGR_LOG_E("Read Bool data failed");
549         return NETMANAGER_ERR_READ_DATA_FAIL;
550     }
551 
552     int32_t result = SetDeviceIdleTrustlist(uids, isAllowed);
553     if (!reply.WriteInt32(result)) {
554         NETMGR_LOG_E("Write int32 reply failed");
555         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
556     }
557 
558     return NETMANAGER_SUCCESS;
559 }
560 
OnGetDeviceIdleTrustlist(MessageParcel & data,MessageParcel & reply)561 int32_t NetPolicyServiceStub::OnGetDeviceIdleTrustlist(MessageParcel &data, MessageParcel &reply)
562 {
563     NETMGR_LOG_I("GetDeviceIdleTrustlist callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
564                  IPCSkeleton::GetCallingPid());
565     std::vector<uint32_t> uids;
566     int32_t result = GetDeviceIdleTrustlist(uids);
567     if (!reply.WriteInt32(result)) {
568         NETMGR_LOG_E("Write int32 reply failed");
569         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
570     }
571     if (result == NETMANAGER_SUCCESS) {
572         if (!reply.WriteUInt32Vector(uids)) {
573             NETMGR_LOG_E("Write uint32 vector reply failed");
574             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
575         }
576     }
577 
578     return NETMANAGER_SUCCESS;
579 }
580 
OnSetDeviceIdlePolicy(MessageParcel & data,MessageParcel & reply)581 int32_t NetPolicyServiceStub::OnSetDeviceIdlePolicy(MessageParcel &data, MessageParcel &reply)
582 {
583     NETMGR_LOG_I("SetDeviceIdlePolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
584                  IPCSkeleton::GetCallingPid());
585     bool isAllowed = false;
586     if (!data.ReadBool(isAllowed)) {
587         NETMGR_LOG_E("Read Bool data failed");
588         return NETMANAGER_ERR_READ_DATA_FAIL;
589     }
590 
591     int32_t result = SetDeviceIdlePolicy(isAllowed);
592     if (!reply.WriteInt32(result)) {
593         NETMGR_LOG_E("Write int32 reply failed");
594         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
595     }
596     return NETMANAGER_SUCCESS;
597 }
598 
OnGetPowerSaveTrustlist(MessageParcel & data,MessageParcel & reply)599 int32_t NetPolicyServiceStub::OnGetPowerSaveTrustlist(MessageParcel &data, MessageParcel &reply)
600 {
601     NETMGR_LOG_I("GetPowerSaveTrustlist callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
602                  IPCSkeleton::GetCallingPid());
603     std::vector<uint32_t> uids;
604     int32_t result = GetPowerSaveTrustlist(uids);
605     if (!reply.WriteInt32(result)) {
606         NETMGR_LOG_E("Write int32 reply failed");
607         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
608     }
609     if (result == NETMANAGER_SUCCESS) {
610         if (!reply.WriteUInt32Vector(uids)) {
611             NETMGR_LOG_E("Write uint32 Vector reply failed");
612             return NETMANAGER_ERR_WRITE_REPLY_FAIL;
613         }
614     }
615 
616     return NETMANAGER_SUCCESS;
617 }
618 
OnSetPowerSaveTrustlist(MessageParcel & data,MessageParcel & reply)619 int32_t NetPolicyServiceStub::OnSetPowerSaveTrustlist(MessageParcel &data, MessageParcel &reply)
620 {
621     NETMGR_LOG_I("SetPowerSaveTrustlist callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
622                  IPCSkeleton::GetCallingPid());
623     std::vector<uint32_t> uids;
624     if (!data.ReadUInt32Vector(&uids)) {
625         NETMGR_LOG_E("Read uint32 data failed");
626         return NETMANAGER_ERR_READ_DATA_FAIL;
627     }
628 
629     bool isAllowed = false;
630     if (!data.ReadBool(isAllowed)) {
631         NETMGR_LOG_E("Read Bool data failed");
632         return NETMANAGER_ERR_READ_DATA_FAIL;
633     }
634 
635     int32_t result = SetPowerSaveTrustlist(uids, isAllowed);
636     if (!reply.WriteInt32(result)) {
637         NETMGR_LOG_E("Write int32 reply failed");
638         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
639     }
640 
641     return NETMANAGER_SUCCESS;
642 }
643 
OnSetPowerSavePolicy(MessageParcel & data,MessageParcel & reply)644 int32_t NetPolicyServiceStub::OnSetPowerSavePolicy(MessageParcel &data, MessageParcel &reply)
645 {
646     NETMGR_LOG_I("SetPowerSavePolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
647                  IPCSkeleton::GetCallingPid());
648     bool isAllowed = false;
649     if (!data.ReadBool(isAllowed)) {
650         NETMGR_LOG_E("Read Bool data failed");
651         return NETMANAGER_ERR_READ_DATA_FAIL;
652     }
653 
654     int32_t result = SetPowerSavePolicy(isAllowed);
655     if (!reply.WriteInt32(result)) {
656         NETMGR_LOG_E("Write int32 reply failed");
657         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
658     }
659 
660     return NETMANAGER_SUCCESS;
661 }
662 
OnCheckPermission(MessageParcel & data,MessageParcel & reply)663 int32_t NetPolicyServiceStub::OnCheckPermission(MessageParcel &data, MessageParcel &reply)
664 {
665     if (!reply.WriteInt32(NETMANAGER_SUCCESS)) {
666         NETMGR_LOG_E("Write int32 reply failed");
667         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
668     }
669     return NETMANAGER_SUCCESS;
670 }
671 
OnFactoryResetPolicies(MessageParcel & data,MessageParcel & reply)672 int32_t NetPolicyServiceStub::OnFactoryResetPolicies(MessageParcel &data, MessageParcel &reply)
673 {
674     return NETMANAGER_SUCCESS;
675 }
676 
OnSetNetworkAccessPolicy(MessageParcel & data,MessageParcel & reply)677 int32_t NetPolicyServiceStub::OnSetNetworkAccessPolicy(MessageParcel &data, MessageParcel &reply)
678 {
679     NETMGR_LOG_I("SetNetworkAccessPolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
680                  IPCSkeleton::GetCallingPid());
681     uint32_t uid;
682 
683     if (!data.ReadUint32(uid)) {
684         return NETMANAGER_ERR_READ_DATA_FAIL;
685     }
686 
687     uint8_t wifi_allow;
688     uint8_t cellular_allow;
689     NetworkAccessPolicy policy;
690     bool reconfirmFlag = true;
691 
692     if (!data.ReadUint8(wifi_allow)) {
693         return NETMANAGER_ERR_READ_DATA_FAIL;
694     }
695 
696     if (!data.ReadUint8(cellular_allow)) {
697         return NETMANAGER_ERR_READ_DATA_FAIL;
698     }
699 
700     if (!data.ReadBool(reconfirmFlag)) {
701         return NETMANAGER_ERR_READ_DATA_FAIL;
702     }
703 
704     policy.wifiAllow = wifi_allow;
705     policy.cellularAllow = cellular_allow;
706     int32_t ret = SetNetworkAccessPolicy(uid, policy, reconfirmFlag);
707     if (!reply.WriteInt32(ret)) {
708         NETMGR_LOG_E("Write int32 reply failed");
709         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
710     }
711 
712     return NETMANAGER_SUCCESS;
713 }
714 
OnGetNetworkAccessPolicy(MessageParcel & data,MessageParcel & reply)715 int32_t NetPolicyServiceStub::OnGetNetworkAccessPolicy(MessageParcel &data, MessageParcel &reply)
716 {
717     NETMGR_LOG_I("GetNetworkAccessPolicy callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
718                  IPCSkeleton::GetCallingPid());
719     int32_t uid = 0;
720     uint32_t userId = 1;
721     bool flag = false;
722     if (!data.ReadBool(flag)) {
723         return NETMANAGER_ERR_READ_DATA_FAIL;
724     }
725 
726     if (!data.ReadInt32(uid)) {
727         return NETMANAGER_ERR_READ_DATA_FAIL;
728     }
729 
730     if (!data.ReadUint32(userId)) {
731         return NETMANAGER_ERR_READ_DATA_FAIL;
732     }
733 
734     AccessPolicySave policies;
735     AccessPolicyParameter parameters;
736     parameters.flag = flag;
737     parameters.uid = uid;
738     parameters.userId = userId;
739 
740     int32_t ret = GetNetworkAccessPolicy(parameters, policies);
741     if (!reply.WriteInt32(ret)) {
742         NETMGR_LOG_E("Write int32 reply failed");
743         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
744     }
745 
746     if (ret == NETMANAGER_SUCCESS) {
747         ret = NetworkAccessPolicy::Marshalling(reply, policies, flag);
748         if (ret != NETMANAGER_SUCCESS) {
749             NETMGR_LOG_E("GetNetworkAccessPolicy marshalling failed");
750             return ret;
751         }
752     }
753 
754     return ret;
755 }
756 
OnNotifyNetAccessPolicyDiag(MessageParcel & data,MessageParcel & reply)757 int32_t NetPolicyServiceStub::OnNotifyNetAccessPolicyDiag(MessageParcel &data, MessageParcel &reply)
758 {
759     NETMGR_LOG_I("NotifyNetAccessPolicyDiag callingUid/callingPid: %{public}d/%{public}d", IPCSkeleton::GetCallingUid(),
760                  IPCSkeleton::GetCallingPid());
761     uint32_t uid;
762 
763     if (!data.ReadUint32(uid)) {
764         return NETMANAGER_ERR_READ_DATA_FAIL;
765     }
766 
767     int32_t ret = NotifyNetAccessPolicyDiag(uid);
768     if (!reply.WriteInt32(ret)) {
769         NETMGR_LOG_E("Write int32 reply failed");
770         return NETMANAGER_ERR_WRITE_REPLY_FAIL;
771     }
772 
773     return ret;
774 }
775 
OnSetNicTrafficAllowed(MessageParcel & data,MessageParcel & reply)776 int32_t NetPolicyServiceStub::OnSetNicTrafficAllowed(MessageParcel &data, MessageParcel &reply)
777 {
778     if (!NetManagerStandard::NetManagerPermission::CheckNetSysInternalPermission(
779         NetManagerStandard::Permission::NETSYS_INTERNAL)) {
780         NETMGR_LOG_E("OnSetNicTrafficAllowed CheckNetSysInternalPermission failed");
781         return NETMANAGER_ERR_PERMISSION_DENIED;
782     }
783 
784     bool status = false;
785     int32_t size = 0;
786     if (!data.ReadBool(status) || !data.ReadInt32(size)) {
787         NETMGR_LOG_E("OnSetNicTrafficAllowed read status or size failed");
788         return ERR_FLATTEN_OBJECT;
789     }
790     if (size > static_cast<int32_t>(MAX_IFACENAMES_SIZE)) {
791         NETMGR_LOG_E("OnSetNicTrafficAllowed read data size too big");
792         return ERR_FLATTEN_OBJECT;
793     }
794     std::vector<std::string> ifaceNames;
795     std::string ifaceName;
796     for (int32_t index = 0; index < size; index++) {
797         data.ReadString(ifaceName);
798         if (ifaceName.empty()) {
799             NETMGR_LOG_E("OnSetNicTrafficAllowed ifaceName is empty, size mismatch");
800             return ERR_FLATTEN_OBJECT;
801         }
802         ifaceNames.push_back(ifaceName);
803     }
804     int32_t result = SetNicTrafficAllowed(ifaceNames, status);
805     if (!reply.WriteInt32(result)) {
806         NETMGR_LOG_E("Write OnSetNicTrafficAllowed result failed");
807         return ERR_FLATTEN_OBJECT;
808     }
809     return NETMANAGER_SUCCESS;
810 }
811 } // namespace NetManagerStandard
812 } // namespace OHOS
813