1 /*
2 * Copyright (c) 2022-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 "netpolicy_exec.h"
17
18 #include "napi_utils.h"
19 #include "net_policy_client.h"
20 #include "net_policy_constants.h"
21 #include "netmanager_base_log.h"
22
23 namespace OHOS {
24 namespace NetManagerStandard {
ExecSetPolicyByUid(SetPolicyByUidContext * context)25 bool NetPolicyExec::ExecSetPolicyByUid(SetPolicyByUidContext *context)
26 {
27 int32_t result = NetPolicyClient::GetInstance().SetPolicyByUid(context->uid_, context->policy_);
28 if (result != NETMANAGER_SUCCESS) {
29 NETMANAGER_BASE_LOGE("ExecSetPolicyByUid error, uid = %{public}s, policy = %{public}d, result = %{public}d",
30 std::to_string(context->uid_).c_str(), context->policy_, result);
31 context->SetErrorCode(result);
32 return false;
33 }
34 context->SetErrorCode(result);
35 return true;
36 }
37
ExecGetPolicyByUid(GetPolicyByUidContext * context)38 bool NetPolicyExec::ExecGetPolicyByUid(GetPolicyByUidContext *context)
39 {
40 int32_t result = NetPolicyClient::GetInstance().GetPolicyByUid(context->uid_, context->policy_);
41 if (result != NETMANAGER_SUCCESS) {
42 context->SetErrorCode(result);
43 return false;
44 }
45 context->SetErrorCode(result);
46 return true;
47 }
48
ExecGetUidsByPolicy(GetUidsByPolicyContext * context)49 bool NetPolicyExec::ExecGetUidsByPolicy(GetUidsByPolicyContext *context)
50 {
51 int32_t result = NetPolicyClient::GetInstance().GetUidsByPolicy(context->policy_, context->uidTogether_);
52 if (result != NETMANAGER_SUCCESS) {
53 context->SetErrorCode(result);
54 return false;
55 }
56 context->SetErrorCode(result);
57 return true;
58 }
59
ExecSetBackgroundPolicy(SetBackgroundPolicyContext * context)60 bool NetPolicyExec::ExecSetBackgroundPolicy(SetBackgroundPolicyContext *context)
61 {
62 int32_t result = NetPolicyClient::GetInstance().SetBackgroundPolicy(context->isAllowed_);
63 if (result != NETMANAGER_SUCCESS) {
64 NETMANAGER_BASE_LOGE("ExecSetBackgroundPolicy error, isAllowed = %{public}d, result = %{public}d",
65 context->isAllowed_, result);
66 context->SetErrorCode(result);
67 return false;
68 }
69 context->SetErrorCode(result);
70 return true;
71 }
72
ExecGetBackgroundPolicy(GetBackgroundPolicyContext * context)73 bool NetPolicyExec::ExecGetBackgroundPolicy(GetBackgroundPolicyContext *context)
74 {
75 int32_t result = NetPolicyClient::GetInstance().GetBackgroundPolicy(context->backgroundPolicy_);
76 if (result != NETMANAGER_SUCCESS) {
77 context->SetErrorCode(result);
78 return false;
79 }
80 context->SetErrorCode(result);
81 return true;
82 }
83
ExecGetNetQuotaPolicies(GetNetQuotaPoliciesContext * context)84 bool NetPolicyExec::ExecGetNetQuotaPolicies(GetNetQuotaPoliciesContext *context)
85 {
86 int32_t result = NetPolicyClient::GetInstance().GetNetQuotaPolicies(context->quotaPolicys_);
87 if (result != NETMANAGER_SUCCESS) {
88 NETMANAGER_BASE_LOGE("ExecGetNetQuotaPolicies error, result = %{public}d", result);
89 context->SetErrorCode(result);
90 return false;
91 }
92 context->SetErrorCode(result);
93 return true;
94 }
95
ExecSetNetQuotaPolicies(SetNetQuotaPoliciesContext * context)96 bool NetPolicyExec::ExecSetNetQuotaPolicies(SetNetQuotaPoliciesContext *context)
97 {
98 int32_t result = NetPolicyClient::GetInstance().SetNetQuotaPolicies(context->quotaPolicys_);
99 if (result != NETMANAGER_SUCCESS) {
100 NETMANAGER_BASE_LOGE("ExecSetNetQuotaPolicies error, result = %{public}d, arr size = %{public}zu", result,
101 context->quotaPolicys_.size());
102 context->SetErrorCode(result);
103 return false;
104 }
105 context->SetErrorCode(result);
106 return true;
107 }
108
ExecRestoreAllPolicies(RestoreAllPoliciesContext * context)109 bool NetPolicyExec::ExecRestoreAllPolicies(RestoreAllPoliciesContext *context)
110 {
111 int32_t result = NetPolicyClient::GetInstance().ResetPolicies(context->iccid_);
112 if (result != NETMANAGER_SUCCESS) {
113 NETMANAGER_BASE_LOGE("ExecRestoreAllPolicies error, result = %{public}d", result);
114 context->SetErrorCode(result);
115 return false;
116 }
117 context->SetErrorCode(result);
118 return true;
119 }
120
ExecIsUidNetAllowed(IsUidNetAllowedContext * context)121 bool NetPolicyExec::ExecIsUidNetAllowed(IsUidNetAllowedContext *context)
122 {
123 int32_t result = NETMANAGER_SUCCESS;
124 if (context->isBoolean_) {
125 result = NetPolicyClient::GetInstance().IsUidNetAllowed(context->uid_, context->isMetered_, context->isUidNet_);
126 } else {
127 result = NetPolicyClient::GetInstance().IsUidNetAllowed(context->uid_, context->iface_, context->isUidNet_);
128 }
129
130 if (result != NETMANAGER_SUCCESS) {
131 NETMANAGER_BASE_LOGE("ExecIsUidNetAllowed error, result = %{public}d", result);
132 context->SetErrorCode(result);
133 return false;
134 }
135 context->SetErrorCode(result);
136 return true;
137 }
138
ExecSetDeviceIdleTrustlist(SetDeviceIdleTrustlistContext * context)139 bool NetPolicyExec::ExecSetDeviceIdleTrustlist(SetDeviceIdleTrustlistContext *context)
140 {
141 int32_t result = NetPolicyClient::GetInstance().SetDeviceIdleTrustlist(context->uids_, context->isAllow_);
142 if (result != NETMANAGER_SUCCESS) {
143 context->SetErrorCode(result);
144 return false;
145 }
146 context->SetErrorCode(result);
147 return true;
148 }
149
ExecGetDeviceIdleTrustlist(GetDeviceIdleTrustlistContext * context)150 bool NetPolicyExec::ExecGetDeviceIdleTrustlist(GetDeviceIdleTrustlistContext *context)
151 {
152 int32_t result = NetPolicyClient::GetInstance().GetDeviceIdleTrustlist(context->uids_);
153 if (result != NETMANAGER_SUCCESS) {
154 NETMANAGER_BASE_LOGE("ExecGetDeviceIdleTrustlist error: result = %{public}d, arr size = %{public}zu", result,
155 context->uids_.size());
156 context->SetErrorCode(result);
157 return false;
158 }
159 context->SetErrorCode(result);
160 return true;
161 }
162
ExecSetPowerSaveTrustlist(SetPowerSaveTrustlistContext * context)163 bool NetPolicyExec::ExecSetPowerSaveTrustlist(SetPowerSaveTrustlistContext *context)
164 {
165 int32_t result = NetPolicyClient::GetInstance().SetPowerSaveTrustlist(context->uids_, context->isAllow_);
166 if (result != NETMANAGER_SUCCESS) {
167 NETMANAGER_BASE_LOGE("ExecSetPowerSaveTrustlist error: result = %{public}d, arr size = %{public}zu", result,
168 context->uids_.size());
169 context->SetErrorCode(result);
170 return false;
171 }
172 context->SetErrorCode(result);
173 return true;
174 }
175
ExecGetPowerSaveTrustlist(GetPowerSaveTrustlistContext * context)176 bool NetPolicyExec::ExecGetPowerSaveTrustlist(GetPowerSaveTrustlistContext *context)
177 {
178 int32_t result = NetPolicyClient::GetInstance().GetPowerSaveTrustlist(context->uids_);
179 if (result != NETMANAGER_SUCCESS) {
180 NETMANAGER_BASE_LOGE("ExecGetPowerSaveTrustlist error: result = %{public}d, arr size = %{public}zu", result,
181 context->uids_.size());
182 context->SetErrorCode(result);
183 return false;
184 }
185 context->SetErrorCode(result);
186 return true;
187 }
188
ExecGetBackgroundPolicyByUid(GetBackgroundPolicyByUidContext * context)189 bool NetPolicyExec::ExecGetBackgroundPolicyByUid(GetBackgroundPolicyByUidContext *context)
190 {
191 int32_t result =
192 NetPolicyClient::GetInstance().GetBackgroundPolicyByUid(context->uid_, context->backgroundPolicyOfUid_);
193 if (result != NETMANAGER_SUCCESS) {
194 NETMANAGER_BASE_LOGE("ExecGetBackgroundPolicyByUid error: result = %{public}d", result);
195 context->SetErrorCode(result);
196 return false;
197 }
198 context->SetErrorCode(result);
199 return true;
200 }
201
ExecResetPolicies(ResetPoliciesContext * context)202 bool NetPolicyExec::ExecResetPolicies(ResetPoliciesContext *context)
203 {
204 int32_t result = NetPolicyClient::GetInstance().ResetPolicies(context->iccid_);
205 if (result != NETMANAGER_SUCCESS) {
206 NETMANAGER_BASE_LOGE("ExecResetPolicies error: result = %{public}d", result);
207 context->SetErrorCode(result);
208 return false;
209 }
210 context->SetErrorCode(result);
211 return true;
212 }
213
ExecUpdateRemindPolicy(UpdateRemindPolicyContext * context)214 bool NetPolicyExec::ExecUpdateRemindPolicy(UpdateRemindPolicyContext *context)
215 {
216 int32_t result =
217 NetPolicyClient::GetInstance().UpdateRemindPolicy(context->netType_, context->iccid_, context->remindType_);
218 if (result != NETMANAGER_SUCCESS) {
219 NETMANAGER_BASE_LOGE("ExecUpdateRemindPolicy error: result = %{public}d", result);
220 context->SetErrorCode(result);
221 return false;
222 }
223 context->SetErrorCode(result);
224 return true;
225 }
226
SetPolicyByUidCallback(SetPolicyByUidContext * context)227 napi_value NetPolicyExec::SetPolicyByUidCallback(SetPolicyByUidContext *context)
228 {
229 return NapiUtils::GetUndefined(context->GetEnv());
230 }
231
GetPolicyByUidCallback(GetPolicyByUidContext * context)232 napi_value NetPolicyExec::GetPolicyByUidCallback(GetPolicyByUidContext *context)
233 {
234 return NapiUtils::CreateInt32(context->GetEnv(), context->policy_);
235 }
236
GetUidsByPolicyCallback(GetUidsByPolicyContext * context)237 napi_value NetPolicyExec::GetUidsByPolicyCallback(GetUidsByPolicyContext *context)
238 {
239 napi_value uids = NapiUtils::CreateArray(context->GetEnv(), context->uidTogether_.size());
240 uint32_t index = 0;
241 for (const auto &uid : context->uidTogether_) {
242 napi_value element = NapiUtils::CreateInt32(context->GetEnv(), uid);
243 NapiUtils::SetArrayElement(context->GetEnv(), uids, index++, element);
244 }
245 return uids;
246 }
247
SetBackgroundPolicyCallback(SetBackgroundPolicyContext * context)248 napi_value NetPolicyExec::SetBackgroundPolicyCallback(SetBackgroundPolicyContext *context)
249 {
250 return NapiUtils::GetUndefined(context->GetEnv());
251 }
252
GetBackgroundPolicyCallback(GetBackgroundPolicyContext * context)253 napi_value NetPolicyExec::GetBackgroundPolicyCallback(GetBackgroundPolicyContext *context)
254 {
255 return NapiUtils::GetBoolean(context->GetEnv(), context->backgroundPolicy_);
256 }
257
GetNetQuotaPoliciesCallback(GetNetQuotaPoliciesContext * context)258 napi_value NetPolicyExec::GetNetQuotaPoliciesCallback(GetNetQuotaPoliciesContext *context)
259 {
260 napi_value callbackValue = NapiUtils::CreateArray(context->GetEnv(), context->quotaPolicys_.size());
261 uint32_t index = 0;
262 for (const auto "aPolicy : context->quotaPolicys_) {
263 napi_value element = NetPolicyExec::CreateNetQuotaPolicy(context->GetEnv(), quotaPolicy);
264 NapiUtils::SetArrayElement(context->GetEnv(), callbackValue, index++, element);
265 }
266 return callbackValue;
267 }
268
FillNetWorkMatchRule(napi_env env,napi_value elementObject,const NetQuotaPolicy & netQuotaPolicy)269 void NetPolicyExec::FillNetWorkMatchRule(napi_env env, napi_value elementObject, const NetQuotaPolicy &netQuotaPolicy)
270 {
271 napi_value netWorkMatchRule = NapiUtils::CreateObject(env);
272 NapiUtils::SetInt32Property(env, netWorkMatchRule, "netType", netQuotaPolicy.networkmatchrule.netType);
273 NapiUtils::SetStringPropertyUtf8(env, netWorkMatchRule, "simId", netQuotaPolicy.networkmatchrule.simId);
274 NapiUtils::SetStringPropertyUtf8(env, netWorkMatchRule, "identity", netQuotaPolicy.networkmatchrule.ident);
275 NapiUtils::SetNamedProperty(env, elementObject, "networkMatchRule", netWorkMatchRule);
276 }
277
FillQuotaPolicy(napi_env env,napi_value elementObject,const NetQuotaPolicy & netQuotaPolicy)278 void NetPolicyExec::FillQuotaPolicy(napi_env env, napi_value elementObject, const NetQuotaPolicy &netQuotaPolicy)
279 {
280 napi_value quotaPolicy = NapiUtils::CreateObject(env);
281 NapiUtils::SetStringPropertyUtf8(env, quotaPolicy, "periodDuration", netQuotaPolicy.quotapolicy.periodDuration);
282 NapiUtils::SetInt64Property(env, quotaPolicy, "warningBytes", netQuotaPolicy.quotapolicy.warningBytes);
283 NapiUtils::SetInt64Property(env, quotaPolicy, "limitBytes", netQuotaPolicy.quotapolicy.limitBytes);
284 NapiUtils::SetInt64Property(env, quotaPolicy, "lastWarningRemind", netQuotaPolicy.quotapolicy.lastWarningRemind);
285 NapiUtils::SetInt64Property(env, quotaPolicy, "lastLimitRemind", netQuotaPolicy.quotapolicy.lastLimitRemind);
286 NapiUtils::SetBooleanProperty(env, quotaPolicy, "metered", netQuotaPolicy.quotapolicy.metered);
287 NapiUtils::SetInt32Property(env, quotaPolicy, "limitAction", netQuotaPolicy.quotapolicy.limitAction);
288 NapiUtils::SetNamedProperty(env, elementObject, "quotaPolicy", quotaPolicy);
289 }
290
CreateNetQuotaPolicy(napi_env env,const NetQuotaPolicy & item)291 napi_value NetPolicyExec::CreateNetQuotaPolicy(napi_env env, const NetQuotaPolicy &item)
292 {
293 napi_value elementObject = NapiUtils::CreateObject(env);
294 FillNetWorkMatchRule(env, elementObject, item);
295 FillQuotaPolicy(env, elementObject, item);
296 return elementObject;
297 }
298
SetNetQuotaPoliciesCallback(SetNetQuotaPoliciesContext * context)299 napi_value NetPolicyExec::SetNetQuotaPoliciesCallback(SetNetQuotaPoliciesContext *context)
300 {
301 return NapiUtils::GetUndefined(context->GetEnv());
302 }
303
RestoreAllPoliciesCallback(RestoreAllPoliciesContext * context)304 napi_value NetPolicyExec::RestoreAllPoliciesCallback(RestoreAllPoliciesContext *context)
305 {
306 return NapiUtils::GetUndefined(context->GetEnv());
307 }
308
IsUidNetAllowedCallback(IsUidNetAllowedContext * context)309 napi_value NetPolicyExec::IsUidNetAllowedCallback(IsUidNetAllowedContext *context)
310 {
311 return NapiUtils::GetBoolean(context->GetEnv(), context->isUidNet_);
312 }
313
SetDeviceIdleTrustlistCallback(SetDeviceIdleTrustlistContext * context)314 napi_value NetPolicyExec::SetDeviceIdleTrustlistCallback(SetDeviceIdleTrustlistContext *context)
315 {
316 return NapiUtils::GetUndefined(context->GetEnv());
317 }
318
GetDeviceIdleTrustlistCallback(GetDeviceIdleTrustlistContext * context)319 napi_value NetPolicyExec::GetDeviceIdleTrustlistCallback(GetDeviceIdleTrustlistContext *context)
320 {
321 napi_value list = NapiUtils::CreateArray(context->GetEnv(), context->uids_.size());
322 uint32_t index = 0;
323 for (const auto &uid : context->uids_) {
324 napi_value element = NapiUtils::CreateUint32(context->GetEnv(), uid);
325 NapiUtils::SetArrayElement(context->GetEnv(), list, index++, element);
326 }
327 return list;
328 }
329
SetPowerSaveTrustlistCallback(SetPowerSaveTrustlistContext * context)330 napi_value NetPolicyExec::SetPowerSaveTrustlistCallback(SetPowerSaveTrustlistContext *context)
331 {
332 return NapiUtils::GetUndefined(context->GetEnv());
333 }
334
GetPowerSaveTrustlistCallback(GetPowerSaveTrustlistContext * context)335 napi_value NetPolicyExec::GetPowerSaveTrustlistCallback(GetPowerSaveTrustlistContext *context)
336 {
337 napi_value list = NapiUtils::CreateArray(context->GetEnv(), context->uids_.size());
338 uint32_t index = 0;
339 for (const auto &uid : context->uids_) {
340 napi_value element = NapiUtils::CreateUint32(context->GetEnv(), uid);
341 NapiUtils::SetArrayElement(context->GetEnv(), list, index++, element);
342 }
343 return list;
344 }
345
GetBackgroundPolicyByUidCallback(GetBackgroundPolicyByUidContext * context)346 napi_value NetPolicyExec::GetBackgroundPolicyByUidCallback(GetBackgroundPolicyByUidContext *context)
347 {
348 return NapiUtils::CreateInt32(context->GetEnv(), static_cast<int32_t>(context->backgroundPolicyOfUid_));
349 }
350
ResetPoliciesCallback(ResetPoliciesContext * context)351 napi_value NetPolicyExec::ResetPoliciesCallback(ResetPoliciesContext *context)
352 {
353 return NapiUtils::GetUndefined(context->GetEnv());
354 }
355
UpdateRemindPolicyCallback(UpdateRemindPolicyContext * context)356 napi_value NetPolicyExec::UpdateRemindPolicyCallback(UpdateRemindPolicyContext *context)
357 {
358 return NapiUtils::GetUndefined(context->GetEnv());
359 }
360 } // namespace NetManagerStandard
361 } // namespace OHOS
362