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 
ExecSetNetworkAccessPolicy(SetNetworkAccessPolicyContext * context)227 bool NetPolicyExec::ExecSetNetworkAccessPolicy(SetNetworkAccessPolicyContext *context)
228 {
229     int32_t errorCode = NetPolicyClient::GetInstance().SetNetworkAccessPolicy(context->uid_, context->policy_,
230                                                                               context->isReconfirmFlag_);
231     if (errorCode != NETMANAGER_SUCCESS) {
232         NETMANAGER_BASE_LOGE("exec SetNetworkAccessPolicy failed errorCode: %{public}d", errorCode);
233         context->SetErrorCode(errorCode);
234         return false;
235     }
236     return true;
237 }
238 
ExecGetNetworkAccessPolicy(GetNetworkAccessPolicyContext * context)239 bool NetPolicyExec::ExecGetNetworkAccessPolicy(GetNetworkAccessPolicyContext *context)
240 {
241     int32_t errorCode =
242         NetPolicyClient::GetInstance().GetNetworkAccessPolicy(context->policy_parmeter_, context->policy_save_);
243     if (errorCode != NETMANAGER_SUCCESS) {
244         NETMANAGER_BASE_LOGE("exec GetNetworkAccessPolicy failed errorCode: %{public}d", errorCode);
245         context->SetErrorCode(errorCode);
246         return false;
247     }
248     return true;
249 }
250 
SetPolicyByUidCallback(SetPolicyByUidContext * context)251 napi_value NetPolicyExec::SetPolicyByUidCallback(SetPolicyByUidContext *context)
252 {
253     return NapiUtils::GetUndefined(context->GetEnv());
254 }
255 
GetPolicyByUidCallback(GetPolicyByUidContext * context)256 napi_value NetPolicyExec::GetPolicyByUidCallback(GetPolicyByUidContext *context)
257 {
258     return NapiUtils::CreateInt32(context->GetEnv(), context->policy_);
259 }
260 
GetUidsByPolicyCallback(GetUidsByPolicyContext * context)261 napi_value NetPolicyExec::GetUidsByPolicyCallback(GetUidsByPolicyContext *context)
262 {
263     napi_value uids = NapiUtils::CreateArray(context->GetEnv(), context->uidTogether_.size());
264     uint32_t index = 0;
265     for (const auto &uid : context->uidTogether_) {
266         napi_value element = NapiUtils::CreateInt32(context->GetEnv(), uid);
267         NapiUtils::SetArrayElement(context->GetEnv(), uids, index++, element);
268     }
269     return uids;
270 }
271 
SetBackgroundPolicyCallback(SetBackgroundPolicyContext * context)272 napi_value NetPolicyExec::SetBackgroundPolicyCallback(SetBackgroundPolicyContext *context)
273 {
274     return NapiUtils::GetUndefined(context->GetEnv());
275 }
276 
GetBackgroundPolicyCallback(GetBackgroundPolicyContext * context)277 napi_value NetPolicyExec::GetBackgroundPolicyCallback(GetBackgroundPolicyContext *context)
278 {
279     return NapiUtils::GetBoolean(context->GetEnv(), context->backgroundPolicy_);
280 }
281 
GetNetQuotaPoliciesCallback(GetNetQuotaPoliciesContext * context)282 napi_value NetPolicyExec::GetNetQuotaPoliciesCallback(GetNetQuotaPoliciesContext *context)
283 {
284     napi_value callbackValue = NapiUtils::CreateArray(context->GetEnv(), context->quotaPolicys_.size());
285     uint32_t index = 0;
286     for (const auto &quotaPolicy : context->quotaPolicys_) {
287         napi_value element = NetPolicyExec::CreateNetQuotaPolicy(context->GetEnv(), quotaPolicy);
288         NapiUtils::SetArrayElement(context->GetEnv(), callbackValue, index++, element);
289     }
290     return callbackValue;
291 }
292 
FillNetWorkMatchRule(napi_env env,napi_value elementObject,const NetQuotaPolicy & netQuotaPolicy)293 void NetPolicyExec::FillNetWorkMatchRule(napi_env env, napi_value elementObject, const NetQuotaPolicy &netQuotaPolicy)
294 {
295     napi_value netWorkMatchRule =  NapiUtils::CreateObject(env);
296     NapiUtils::SetInt32Property(env, netWorkMatchRule, "netType", netQuotaPolicy.networkmatchrule.netType);
297     NapiUtils::SetStringPropertyUtf8(env, netWorkMatchRule, "simId", netQuotaPolicy.networkmatchrule.simId);
298     NapiUtils::SetStringPropertyUtf8(env, netWorkMatchRule, "identity", netQuotaPolicy.networkmatchrule.ident);
299     NapiUtils::SetNamedProperty(env, elementObject, "networkMatchRule", netWorkMatchRule);
300 }
301 
FillQuotaPolicy(napi_env env,napi_value elementObject,const NetQuotaPolicy & netQuotaPolicy)302 void NetPolicyExec::FillQuotaPolicy(napi_env env, napi_value elementObject, const NetQuotaPolicy &netQuotaPolicy)
303 {
304     napi_value quotaPolicy =  NapiUtils::CreateObject(env);
305     NapiUtils::SetStringPropertyUtf8(env, quotaPolicy, "periodDuration", netQuotaPolicy.quotapolicy.periodDuration);
306     NapiUtils::SetInt64Property(env, quotaPolicy, "warningBytes", netQuotaPolicy.quotapolicy.warningBytes);
307     NapiUtils::SetInt64Property(env, quotaPolicy, "limitBytes", netQuotaPolicy.quotapolicy.limitBytes);
308     NapiUtils::SetInt64Property(env, quotaPolicy, "lastWarningRemind", netQuotaPolicy.quotapolicy.lastWarningRemind);
309     NapiUtils::SetInt64Property(env, quotaPolicy, "lastLimitRemind", netQuotaPolicy.quotapolicy.lastLimitRemind);
310     NapiUtils::SetBooleanProperty(env, quotaPolicy, "metered", netQuotaPolicy.quotapolicy.metered);
311     NapiUtils::SetInt32Property(env, quotaPolicy, "limitAction", netQuotaPolicy.quotapolicy.limitAction);
312     NapiUtils::SetNamedProperty(env, elementObject, "quotaPolicy", quotaPolicy);
313 }
314 
CreateNetQuotaPolicy(napi_env env,const NetQuotaPolicy & item)315 napi_value NetPolicyExec::CreateNetQuotaPolicy(napi_env env, const NetQuotaPolicy &item)
316 {
317     napi_value elementObject = NapiUtils::CreateObject(env);
318     FillNetWorkMatchRule(env, elementObject, item);
319     FillQuotaPolicy(env, elementObject, item);
320     return elementObject;
321 }
322 
SetNetQuotaPoliciesCallback(SetNetQuotaPoliciesContext * context)323 napi_value NetPolicyExec::SetNetQuotaPoliciesCallback(SetNetQuotaPoliciesContext *context)
324 {
325     return NapiUtils::GetUndefined(context->GetEnv());
326 }
327 
RestoreAllPoliciesCallback(RestoreAllPoliciesContext * context)328 napi_value NetPolicyExec::RestoreAllPoliciesCallback(RestoreAllPoliciesContext *context)
329 {
330     return NapiUtils::GetUndefined(context->GetEnv());
331 }
332 
IsUidNetAllowedCallback(IsUidNetAllowedContext * context)333 napi_value NetPolicyExec::IsUidNetAllowedCallback(IsUidNetAllowedContext *context)
334 {
335     return NapiUtils::GetBoolean(context->GetEnv(), context->isUidNet_);
336 }
337 
SetDeviceIdleTrustlistCallback(SetDeviceIdleTrustlistContext * context)338 napi_value NetPolicyExec::SetDeviceIdleTrustlistCallback(SetDeviceIdleTrustlistContext *context)
339 {
340     return NapiUtils::GetUndefined(context->GetEnv());
341 }
342 
GetDeviceIdleTrustlistCallback(GetDeviceIdleTrustlistContext * context)343 napi_value NetPolicyExec::GetDeviceIdleTrustlistCallback(GetDeviceIdleTrustlistContext *context)
344 {
345     napi_value list = NapiUtils::CreateArray(context->GetEnv(), context->uids_.size());
346     uint32_t index = 0;
347     for (const auto &uid : context->uids_) {
348         napi_value element = NapiUtils::CreateUint32(context->GetEnv(), uid);
349         NapiUtils::SetArrayElement(context->GetEnv(), list, index++, element);
350     }
351     return list;
352 }
353 
SetPowerSaveTrustlistCallback(SetPowerSaveTrustlistContext * context)354 napi_value NetPolicyExec::SetPowerSaveTrustlistCallback(SetPowerSaveTrustlistContext *context)
355 {
356     return NapiUtils::GetUndefined(context->GetEnv());
357 }
358 
GetPowerSaveTrustlistCallback(GetPowerSaveTrustlistContext * context)359 napi_value NetPolicyExec::GetPowerSaveTrustlistCallback(GetPowerSaveTrustlistContext *context)
360 {
361     napi_value list = NapiUtils::CreateArray(context->GetEnv(), context->uids_.size());
362     uint32_t index = 0;
363     for (const auto &uid : context->uids_) {
364         napi_value element = NapiUtils::CreateUint32(context->GetEnv(), uid);
365         NapiUtils::SetArrayElement(context->GetEnv(), list, index++, element);
366     }
367     return list;
368 }
369 
GetBackgroundPolicyByUidCallback(GetBackgroundPolicyByUidContext * context)370 napi_value NetPolicyExec::GetBackgroundPolicyByUidCallback(GetBackgroundPolicyByUidContext *context)
371 {
372     return NapiUtils::CreateInt32(context->GetEnv(), static_cast<int32_t>(context->backgroundPolicyOfUid_));
373 }
374 
ResetPoliciesCallback(ResetPoliciesContext * context)375 napi_value NetPolicyExec::ResetPoliciesCallback(ResetPoliciesContext *context)
376 {
377     return NapiUtils::GetUndefined(context->GetEnv());
378 }
379 
UpdateRemindPolicyCallback(UpdateRemindPolicyContext * context)380 napi_value NetPolicyExec::UpdateRemindPolicyCallback(UpdateRemindPolicyContext *context)
381 {
382     return NapiUtils::GetUndefined(context->GetEnv());
383 }
384 
SetNetworkAccessPolicyCallback(SetNetworkAccessPolicyContext * context)385 napi_value NetPolicyExec::SetNetworkAccessPolicyCallback(SetNetworkAccessPolicyContext *context)
386 {
387     return NapiUtils::GetUndefined(context->GetEnv());
388 }
389 
GetNetworkAccessPolicyCallback(GetNetworkAccessPolicyContext * context)390 napi_value NetPolicyExec::GetNetworkAccessPolicyCallback(GetNetworkAccessPolicyContext *context)
391 {
392     if (context->policy_parmeter_.flag) {
393         napi_value obj = NapiUtils::CreateObject(context->GetEnv());
394         NapiUtils::SetBooleanProperty(context->GetEnv(), obj, "allowWiFi", context->policy_save_.policy.wifiAllow);
395         NapiUtils::SetBooleanProperty(context->GetEnv(), obj, "allowCellular",
396                                       context->policy_save_.policy.cellularAllow);
397         return obj;
398     }
399 
400     napi_value result = NapiUtils::CreateObject(context->GetEnv());
401     for (const auto &item : context->policy_save_.uid_policies) {
402         napi_value obj = NapiUtils::CreateObject(context->GetEnv());
403         NapiUtils::SetBooleanProperty(context->GetEnv(), obj, "allowWiFi", item.second.wifiAllow);
404         NapiUtils::SetBooleanProperty(context->GetEnv(), obj, "allowCellular", item.second.cellularAllow);
405         NapiUtils::SetNamedProperty(context->GetEnv(), result, std::to_string(item.first).c_str(), obj);
406     }
407     return result;
408 }
409 } // namespace NetManagerStandard
410 } // namespace OHOS
411